Java-面向对象的封装、继承、多态三大特性

1. 封装

1.1 封装概念：

封装是一种将数据和方法绑定在一起形成一个独立的单元（类），并对外部隐藏对象的内部细节的机制。通过封装，可以控制对类成员的访问，提高安全性和可维护性。

1.2 封装的实现：

封装通过访问修饰符（private、protected、public）来实现对成员的访问控制。通常，数据成员使用 private 修饰，而提供公共方法（getter 和 setter）用于访问和修改这些数据。

1.3 封装的例子：

public class Car {
    private String model;
    private int year;

    // 构造方法
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    // 公共方法用于访问私有属性
    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

在上面的例子中，model 和 year 属性是私有的，通过公共的 getModel()、setModel()、getYear()、setYear() 方法来访问和修改这些属性。

2. 继承

2.1 继承的细节：

• 子类继承了父类所有的属性和方法，但是私有属性和方法不能在子类直接访问，要通过公共方法访问

• 子类必须调用父类的构造器，完成父类的初始化

• 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译不会通过。

• 如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数)

• super在使用时，需要放在构造器的第一行

• super()和this()都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器

• Java中所有类的父类都是Object。

• 父类构造器的调用不限于直接父类，将一直往上追溯直到Object类（顶级父类）

• 子类最多只能继承一个父类（指直接继承），级Java是单继承机制。

• 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

先有爸爸才有儿子，所以先初始化父类构造器，然后子类构造器

2.2 子类和父类之间的关系：

• 子类是父类的扩展，拥有父类的所有成员。
• 通过 extends 关键字实现继承。

2.3 继承的本质：

继承的本质是代码的重用和扩展，通过继承可以在不修改父类代码的情况下实现新的功能。

2.4 super 关键字：

super 关键字用于引用父类的成员，可以在子类中使用 super 调用父类的构造方法、属性和方法。

public class Parent {
    protected int parentField;

    public Parent(int parentField) {
        this.parentField = parentField;
    }

    public void parentMethod() {
        System.out.println("Parent method");
    }
}

public class Child extends Parent {
    private int childField;

    public Child(int parentField, int childField) {
        super(parentField); // 调用父类的构造方法
        this.childField = childField;
    }

    @Override
    public void parentMethod() {
        super.parentMethod(); // 调用父类的方法
        System.out.println("Child method");
    }
}

2.5 方法重写：

子类可以通过方法重写来提供对父类方法的新实现。子类使用 @Override 注解告诉编译器这是一个重写的方法。

public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

3. 多态

3.1 什么是多态：

多态是指一个对象可以在不同的情境中具有不同的状态或表现形式。在面向对象编程中，多态可以通过方法重写和继承来实现。

3.2 多态的具体体现：

Animal animal = new Dog();
animal.makeSound(); // 输出 "Dog barks."

animal 是 Animal 类型的引用，指向的是 Dog 类的实例。在运行时，会调用 Dog 类重写的 makeSound() 方法。

3.3 多态的三个条件：

• 继承关系：存在继承关系，即子类继承自父类。
• 方法重写：子类必须重写父类的方法。
• 父类引用指向子类对象：通过父类类型的引用指向子类的对象。

3.4 多态的向上转型：

Animal animal = new Dog(); // 向上转型

通过将子类对象赋值给父类引用，实现向上转型。在编译时，引用类型是父类类型，在运行时会调用子类的方法。

3.5 多态的向下转型：

Animal animal = new Dog(); // 向上转型
Dog dog = (Dog) animal; // 向下转型

通过将父类引用转型为子类引用，实现向下转型。需要注意在运行时如果实际对象不是子类的实例，会抛出 ClassCastException 异常。

3.6 动态绑定机制：

在运行时确定调用哪个方法的机制称为动态绑定。Java 中的方法调用是动态绑定的，即在运行时根据实际对象的类型来确定调用哪个类的方法。

3.7 多态的应用：

3.7.1 多态数组：

Animal[] animals = new Animal[3];
animals[0] = new Dog();
animals[1] = new Cat();
animals[2] = new Animal();

for (Animal a : animals) {
    a.makeSound(); // 根据实际对象类型调用不同的方法
}

3.7.2 多态参数：

public void playWithAnimal(Animal animal) {
    animal.makeSound();
}

playWithAnimal(new Dog()); // 输出 "Dog barks."
playWithAnimal(new Cat()); // 输出 "Cat meows."

通过多态，可以将不同子类的对象传递给相同类型的参数，实现对不同类型对象的统一处理。