JAVASE-三大特性之封装，继承和多态-白红宇

JAVASE-三大特性之封装，继承和多态

阅读量：652 次

发布时间：2019-03-15

本文共 5255 字，大约阅读时间需要 17 分钟。

三大特性：封装、继承和多态

作为Java编程中的核心概念，封装、继承和多态是对象-oriented programming（OOP）的基石。本文将从这些概念的特性、语法应用以及实际案例入手，帮助读者更好地理解和掌握这些知识点。

一、封装

1.封装

封装是一种将类的内部实现细节隐藏起来的机制，防止外部程序直接访问对象的私有属性。通过提供get和set方法，外界只能通过特定的方法对属性进行读写操作。这不仅保护了对象的内部状态，也提高了代码的安全性和可维护性。

在Java中，get/set方法是外界获取和访问对象私有属性的唯一通道。例如，可以通过调用Student类的setAge方法来为age属性赋值，而不是直接修改私有字段。

注意事项：在构造方法中，super或this必须在第一行，确保能够正确调用父类或同类的构造方法。

2.代码演示

案例一：

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "tom";    // name属性可见且可写
        s1.setAge(20);     // 通过set方法赋值
        s1.sex = "male";   // sex属性可见且可写
        s1.score = 99.0;   // score属性可见且可写
        
        System.out.println(s1.getAge()); // 调用get方法获取私有属性
    }
}
class Student {
    String name;           // 可见属性，外部可修改
    private int age;       // 私有属性，必须通过set方法修改
    String sex;          // 可见属性，外部可修改
    double score;        // 可见属性，外部可修改
    public Student() {}   // 空构造方法
    public void setAge(int age) {
        if (age >= 0 && age <= 153) {
            this.age = age;
        } else {
            this.age = 18; // 默认设置为18
        }
    }
    public int getAge() {
        return this.age;
    }
}

案例二：

public class Test {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        t1.setName("jack");
        t1.setAge(20);
        t1.setSex("male");
        t1.setSalary(2000.0);
        
        System.out.println(t1.getName() + "\t" + t1.getAge() + "\t" + t1.getSex() + "\t" + t1.getSalary());
    }
}
class Teacher {
    private String name;
    private int age;
    private String sex;
    private double salary;
    public Teacher() {}
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return this.age;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getSex() {
        return this.sex;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public double getSalary() {
        return this.salary;
    }
}

二、继承

1.继承

继承是一种类与类之间特征和行为的传递关系，是OOP的核心概念之一。通过使用class子类extends父类的语法，可以表示子类继承父类的属性和方法。

2.语法

class 子类 extends 父类 {
    // 子类独有的属性和方法
    // 父类通过super关键字访问，子类通过this关键字访问
}

3.应用

当一个子类继承父类后，子类可以在不修改父类代码的情况下，扩展父类的功能。例如，可以定义子类独有的属性和方法，同时可以通过调用父类的方法实现代码复用。

4.好处

复用性：子类可以重复利用父类的功能，减少代码编写。

可扩展性：新增功能时只需对子类进行扩展，不影响已有父类。

5.访问修饰符

private → default → protected → public
             从严到宽

例如：

public class Animal {
    private String name;
    int age;         // 默认访问修饰符
    protected String type;
    public String sex;
}

三、多态

1.多态

多态是指父类引用指向子类对象，从而使其呈现多种形态的现象。在Java中，多态主要体现在方法的多态和属性的多态。

2.多态的应用

场景一：方法多态

public class Animal {
    public void eat() {
        System.out.println("吃吃吃");
    }
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃老鼠");
    }
}
public class Dog extends Animal {
    public void eat() {
        System.out.println("吃肉肉");
    }
}

场景二：属性多态

public class Animal {
    String name;
}
public class SubClass extends Animal {
    String name = "SubClass";
}
SubClass obj = new SubClass();
System.out.println(obj.name); // 输出 "SubClass"

3.instanceof关键字

检验对象的类型关系：

public class Animal {}
public class SubClass extends Animal {}
SubClass obj = new SubClass();
if (obj instanceof SubClass) {
    // 可以进行SubClass特有的操作
}

4.案例

public class Animal {
    public void sayHi() {
        System.out.println("我们已经说Hi了100遍");
    }
}
public class Student extends Animal {
    String name = "student";
    public void test() {
        String name = "test";
        System.out.println(super.name);
        System.out.println(this.name);
        System.out.println(name);
        super.sayHi();
    }
    public void sayHi() {
        super.sayHi();
        System.out.println("我来sayhi");
    }
}
public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.test();
        s.sayHi();
    }
}

四、super关键字

1.访问方法

使用super调父类的方法或属性：

super.方法(); // 调用父类的方法
super.属性; // 调用父类的属性

案例

public class A {
    public A() {
        System.out.println("this is A");
    }
}
public class B extends A {
    public B() {
        System.out.println("this is B");
        super(); // 调用父类无参构造方法
    }
}
public class C extends B {
    public C() {
        super(); // 默认调用父类无参构造
        System.out.println("this is C");
    }
}

2.构造方法调用

super()：调用父类无参构造方法

super(参数)：调用父类有参构造方法

如果没有显示调用super(), 会默认调用父类的无参构造方法

案例

public class Person {
    private String name = "person";
    public Person() {
        System.out.println("这是Person的无参构造");
    }
    public Person(String name) {
        System.out.println("这是Person的有参构造");
        this.name = name;
    }
}
public class Student extends Person {
    private String name = "student";
    public Student(String name) {
        this(name);
        System.out.println("这是Student的有参构造");
    }
    public Student() {
        this("名字");
        System.out.println("这是Student的无参构造");
    }
}

五、总结

封装、继承和多态是Java编程中的核心概念，分别掌握这三大特性，是构建复杂应用程序的基础。通过合理使用封装，可以保护对象的主要状态不被外界随意修改；通过继承，可以在已有类的基础上开发出更高效、更功能完善的新类；而通过多态，可以让父类引用灵活地指向不同子类对象。在实际编程中，这三大特性必须结合使用，才能充分发挥Java的优势，为代码开发提供更高效的解决方案。

转载地址：http://qvdmz.baihongyu.com/

你可能感兴趣的文章