1.多态的概念
简单来说，多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
多态是面向对象编程中的一个重要概念，指的是同一种操作可以作用于不同的对象，并根据对象的不同而执行不同的行为。多态性能够提高代码的灵活性和可扩展性。
在多态中，同一种操作可以根据对象的不同而具有不同的实现。这种操作可以是方法调用、函数调用或者运算符的使用。多态性的实现通常依赖于继承和重写。
多态性的核心概念是接口和抽象类。通过定义接口或者抽象类，可以定义一组共同的方法，然后不同的子类可以根据自己的需求来实现这些方法。当调用这些方法时，根据实际的对象类型，会执行对应子类的方法。
多态性的优点包括代码的可读性和可维护性增强，能够简化代码的设计和实现，提高代码的重用性和灵活性。多态性也是面向对象编程的重要特征之一，可以帮助开发者更好地组织和管理代码。
吃饭是同一件事情，但是不同的动物的吃的却不一样，不同的对象会有不同的状态。
2.多态的实现条件
多态的实现必须要满足以下几个条件（缺一不可）：
- 必须在继承体系下
- 子类必须要对父类中方法进行重写
- 通过父类的引用调用重写的方法
多态的体现：
在代码运行时，当传递不同类对象时，会调用对应类中的方法。
class Animal { String name; int age; public Animal(String name, int age){ this.name = name; this.age = age; } public void eat(){ System.out.println(name + "吃饭"); } } class Cat extends Animal{ public Cat(String name, int age){ super(name, age); } @Override public void eat(){ System.out.println(name+"吃鱼~~~"); } } class Dog extends Animal { public Dog(String name, int age){ super(name, age); } @Override public void eat(){ System.out.println(name+"吃骨头~~~"); } } /// public class Exercise { // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法 // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法 // 此处的形参类型必须是父类类型才可以 public static void eat(Animal a){ a.eat(); } public static void main(String[] args) { Dog dog = new Dog("小七",7); Cat cat = new Cat("咪咪",3); eat(dog); eat(cat); } }
在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的。
当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例。
此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态。
3.重写
重写(override)：
也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
方法重写的规则：
- 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
被重写的方法返回值类型可以不同，但是必须是具有父子关系的
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
父类被static、private修饰的方法、构造方法都不能被重写。
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写
重写与重载的区别：
| 区别点 | 重写(override) | 重载(override) |
| 参数列表 | 一定不能修改 | 必须修改 |
| 返回类型 | 一定不能修改【除非可以构成父子类关系】 | 可以修改 |
| 访问限定符 | 一定不能做更严格的限制（可以降低限制） | 可以修改 |
方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现
重写的设计原则：
对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。
静态绑定：
也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
静态绑定的条件包括：
- 变量的声明类型：静态绑定是根据变量的声明类型来决定调用哪个方法。因此，变量的声明类型必须是确定的，不能是多态类型。
- 编译时类型确定：在编译阶段，编译器会根据变量的声明类型来确定调用的方法，而不考虑实际运行时的对象类型。
动态绑定：
也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。
动态绑定的条件包括：
- 方法的重写：动态绑定需要存在父类和子类之间的方法重写，即子类重写了父类的方法。
- 发生向上转型：Animal animal = new Dog
- 父类引用：通过父类引用来调用父类和子类的重写方法。
4.向上转型和向下转型
4.1向上转型
实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名 = new 子类类型()
Animal animal = new Cat("小小",3);
animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。
class TestAnimal { // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象 public static void eatFood(Animal a){ a.eat(); } // 3. 作返回值：返回任意子类对象 public static Animal buyAnimal(String var){ if("狗".equals(var) ){ return new Dog("狗狗",1); }else if("猫" .equals(var)){ return new Cat("猫猫", 1); }else{ return null; } } public static void main(String[] args) { // 1. 直接赋值：子类对象赋值给父类对象 Animal cat = new Cat("元宝",2); Dog dog = new Dog("小七", 1); eatFood(cat); eatFood(dog); Animal animal = buyAnimal("狗"); animal.eat(); animal = buyAnimal("猫"); animal.eat(); } }
向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。
4.2向下转型
将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
public static void main(String[] args) { Animal animal1 = new Dog("小七",7);//向上转型 Animal animal2 = new Cat("咪咪",3);//向上转型 animal1 = (Dog)animal1;//向下转型 animal2 = (Cat)animal1;//向下转型编译报错，因为animal1实际上是指向的是Dog，强制转化为Cat无法还原 }
向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。
5.多态的优缺点
多态的优点：
- 提高代码的可扩展性和可维护性：通过多态，可以将具体的实现与抽象的接口分离，使得系统的各个模块之间的耦合度降低，从而方便对系统进行扩展和维护。
- 增强代码的灵活性：通过多态，可以在运行时动态地决定对象的具体类型，从而实现不同对象的不同行为。这样可以根据实际需求灵活地进行对象的选择和使用。
- 提高代码的可读性和可理解性：通过多态，可以将对象的具体类型隐藏起来，只关注对象的抽象类型和接口，从而使得代码更加简洁、清晰，易于理解和阅读
- 能够降低代码的 "圈复杂度", 避免使用大量的 if - else
扩展：
圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.
因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度"。如果一个方法的圈复杂度太高, 就需要考虑重构，不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 。
class Book{ public void read(){ System.out.println("看书"); } } class English extends Book{ public void read(){ System.out.println("看英语书"); } } class Maths extends Book{ public void read(){ System.out.println("看数学书"); } } class Language extends Book{ @Override public void read() { System.out.println("看语文书"); } } public class Exercise3 { public static void readBook(){ English english = new English(); Maths maths = new Maths(); Language language = new Language(); Book[] book = {english,language,maths,language,maths,english}; for (Book x:book) { x.read(); } } public static void main(String[] args) { readBook(); } }
多态缺陷：
性能损失：由于多态需要在运行时进行类型的判断和方法的动态绑定，所以会带来一定的性能损失。相比于直接调用具体类型的方法，多态需要进行额外的判断和查找，从而导致一定的性能下降。
可能引发运行时错误：由于多态是在运行时动态决定对象的具体类型，所以如果在使用多态的过程中出现了类型错误或者类型转换错误，就会导致运行时错误的发生。这就需要在使用多态时进行严格的类型检查和错误处理，增加了代码的复杂性和难度。
可能导致代码的混乱和难以理解：多态的使用会使得代码中出现更多的抽象和接口，从而增加了代码的复杂性和难度。如果使用不当，可能会导致代码的混乱和难以理解，降低代码的可读性和可维护性。因此，在使用多态时需要谨慎设计和使用。
6.避免构造方法中调用重写的方法
class B { public B() { // do nothing func(); } public void func() { System.out.println("B.func()"); } } class D extends B { private int num = 1; @Override public void func() { System.out.println("D.func() " + num); } } public class Test { public static void main(String[] args) { D d = new D(); } } // 执行结果D.func() 0
一段有坑的代码. 我们创建两个类, B 是父类, D 是子类. D 中重写 func 方法. 并且在 B 的构造方法中调用 func。
构造 D 对象的同时, 会调用 B 的构造方法.
B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0. 如果具备多态性，num的值应该是1.
所以在构造函数内，尽量避免使用实例方法，除了final和private方法。
总结： "用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。
以上就是本期的全部内容啦，希望看完后能够对你有所帮助。希望小伙伴们可以点赞收藏加关注，学习知识不迷路，hhh~
