OOP(面向对象编程)具有三大特性（继承、封装、多态），了解之后总结如下：
- 封装
- 继承
- 向上转型
- 向下转型
- 重写
- 运行时绑定（动态绑定）
- 多态
封装
封装的本质是让类的调用者不必太多类的实现者是如何实现类的，只知道如何使用类就行了。
public修饰的成员变量或成员方法，可以直接被类的调用者使用。
private修饰的成员变量或成员方法，不可以直接被类的调用者使用。
当要获取或者修改private属性，就需要getter/setter方法了。。注意以下几点：
a. getName 即为 getter 方法, 表示获取这个成员的值。
b. setName 即为 setter 方法, 表示设置这个成员的值.。
c. 当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用。
d. 在 IDEA 中可以使用 alt + insert (或者 alt + F12) 快速生成 setter / getter 方法. 在 VSCode 中可以使用鼠标右键 。
字段 vs 属性 ：我们通常将类的数据成员称为 "字段(fifield)" , 如果该字段同时提供了 getter / setter 方法, 那么我称它为“属性”。
继承
继承（is - a）的实质就是减少重复代码的出现。用extends关键字进行继承。如 A extends B:那么B就称为父类（基类或超类），A就称为子类（派生类）。Java中的继承是单继承。
那么子类到底继承了父类什么呢？ 子类继承了父类除了构造函数外的所有。子类继承了父类，子类需要帮助父类进行构造。
我觉得这句话是太太太重要了，以下都是围绕这句话展开。
首先，子类继承了父类public的字段和方法。对于父类的privata的字段和方法，子类是无法访问的。 protected修饰的字段和方法，子类是可以访问的。
子类不能继承父类的构造方法，因此要帮助父类进行构造，就引入了super关键字，super可以调用父类的构造方法，必须放在第一行，因为构造子类必须先要构造父类。
如果在继承关系中加入代码块，它们的执行顺序：
父类的静态代码块 (执行一次)> 子类的静态代码块(执行一次) > 父类实例代码块 > 父类构造代码块 > 子类实例代码块 > 子类构造代码块
向上转型
向上转型是从子类-->父类，那也就是一个较专用类型向较通用类型转换，因此比较安全。
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
System.out.println("吃饭饭");
}
}
class Cat extends Animal {
public Cat(String name) {
//使用super调用父类的构造方法
super(name);
}
}
class Bird extends Animal {
public Bird(String name) {
super(name);
}
public void fly() {
System.out.println("飞飞飞");
}
}
若执行：
Aniamls bird = new Bird("二哈")就是向上转型，即父类 Aniamls引用子类的 Bird对象。
向上转型发生的时机：
1、直接赋值
Animal animal = new Bird("二哈");
animal.x;此时要注意：animal是父类的引用，它只能调用自己的方法或者访问自己的属性。
虽然animal此时是Bird的一个引用，但是编译器是以animal的类型（Animal）来查看有哪些方法的。
即：编译器检查有哪些方法存在，看的是Animal这个类型
执行时究竟执行父类的方法还是子类的方法，看的是Bird这个类型
若animal访问Bird中的方法会产生，ClassCastExceptin(类转型异常)，若一定要执行那就要进行强制类型转换了。见向下转型。
2、方法传参
public class Test {
public static void main(String[] args) {
Bird bird = new Bird("二哈");
feed(bird);
}
public static void feed(Animal animal) { //向上转型
animal.eat();
}
}3、方法返回
public class Test {
public static void main(String[] args) {
//向上转型
Animal animal = findMyAnimal();
}
public static Animal findMyAnimal() {
Bird bird = new Bird("二哈");
return bird;
}
}向下类型转换
向下类型转换存在不确定性，比如你是一个图形类，但是不一定是圆形类。对于上面向上转型直接赋值出现的问题，我们可以进行强制类型转换来解决。
Animal animal = new Bird("二哈"); //向上转型
Bird bird = (Bird)animal; //强制类型转换（向下转型）
bird.x; //x可以是Bird当中的方法这样虽然可以执行不会报错，其实也不是非常靠谱，假如存在下面的代码：
Animal animal = new Cat("咪咪");
Bird bird = (Bird)animal;
bird.x; //x为Bird当中的方法 这样的代码运行时会产生ClassCastExceptin(类转型异常)，因为animal其实是Cat对象的一个引用，不能转化为Bird对象的。为了解决这个问题，我们可以在转型前判断animal本质是不是Bird的实例。
因此：向下转型的前提条件是（向下转型）父类已经引用了子类（向下转型后的类型）的对象。
Animal animal = new Cat("咪咪");
if(animal instanceof Bird) {
Bird bird = (Bird)animal;
bird.x; //x为Bird当中的方法
}instanceof可以判断一个引用是否是某个类的实例，如果是则返回true，这时再进行向下转型就比较安全了。
重写
子类实现父类的同名方法，并且参数的类型完全相同，这种情况称为覆写/重写/覆盖（Override）
重写要注意：
1、static修饰的静态方法不能被重写
2、重写时子类的方法的访问权限必须大于等于父类方法的权限
3、父类方法的权限不能是私有的
4、可以使用@override注解来显性指示
重写和重载的区别：
重载发生在同一个类中，方法名称相同、参数类型或个数不同的方法。对权限没有具体要求
重载在有继承关系的类中，方法名称，返回值类型，参数类型及个数完全相同的方法。并且子类的访问修饰权限必须大于等于子类的访问修饰权限，静态方法和私有方法不能被重写。
class Animal {
String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
System.out.println(this.name + "animal eat");
}
}
class Cat extends Animal {
public Cat(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(this.name + "cat eat");
}
}
public class TestDemo {
public static void main(String[] args) {
Animal animal = new Cat("花花"); //向上转型
animal.eat();
}
}运行这段代码，我们会发现没有子类没有重写父类的方法时，调用的父类的方法eat。当子类重写了父类的方法时，运行出来的是子类的eat方法。为什么呢？ 底层是这样实现的
当我们查看底层代码时，编译时确实调用的是Animal的eat()方法，运行时是Cat的eat()方法。
运行时多态的原理：
1、如果子类没有重写eat方法时，调用的确实是父类的eat（）
2、子类重写父类的方法时，编译时还是调用父类的方法。运行时确是子类的方法，这个是运行时绑定。
3、在运行时，子类方法的地址覆盖了父类方法的地址。导致调用了子类的方法
这就是动态绑定（运行时绑定）：调用某个类的方法，究竟执行了父类的方法还是子类的方法，要看这个引用究竟指向了父类对象还是子类对象。这个过程是程序运行时决定的，不是编译时。
下图所示过程：
1、方法表和class对象是和类型是一一对应的
2、方法表是在编译的时候产生的
3、不是所有的对象都在堆上，class对象存放的方法区
多态：
字面上：一种事物的多种形态
代码程序程序层次：发生多态的前提是：①向上转型②同名覆盖方法③调用同名覆盖方法会发生运行时绑定
使用多态的好处：
1、类的调用者对类的使用成本进一步降低
2、能够降低代码的圈复杂度，避免使用大量的if-else
3、可扩展能力更强
