Java多态 学习笔记

Java继承 学习笔记

• • 1.多态
  • • 1.1多态实现条件
    • 1.2向上转型和向下转型
    • • 1.2.1向上转型
      • 1.2.2向下转型
    • 1.3重写与重载
    • • 1.3.1重写
      • 1.3.2重写与重载的区别
      • 1.3.3动态绑定与静态绑定
    • 1.4回顾多态
    • • 1.4.1多态思想
      • 1.4.2多态的优缺点

1.多态

对一个事物产生不同的态度

1.1多态实现条件

多态实现的三个必要条件

• 必须在父类的继承体系下
• 子类必须要对父类中方法进行重写
• 通过父类的引用调用重写的方法

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。如果有，再去调用子类的同名方法。

1.2向上转型和向下转型

1.2.1向上转型

概念：创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型 对象名 = new 子类类型()

Animalanimal=newCat("元宝",2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

向上转型的几种方法：

• 直接赋值
• 方法的传参
• 方法的返回值

注意事项：

• 通过父类的引用，调用子类特有的方法是无法直接调用的，这里只能调用父类自己的。

classAnimal{publicStringname;publicAnimal(Stringname){this.name=name;}}classDogextendsAnimal{publicDog(Stringname){super(name);}}classCatextendsAnimal{publicCat(Stringname){super(name);}}publicclassTest{//方法二：方法的传参publicstaticvoidfunction(Animalanimal){}//方法三：返回值publicstaticAnimalfunction2(){Dogdog=newDog("Papy Dog");returndog;}publicstaticvoidmain(String[]args){//方法一：直接赋值Animaldog=newDog("Papy Dog");Catcat=newCat("Papy Cat");//方法二：方法的传参function(cat);//方法三：返回值Animaldog2=function2();}}

1.2.2向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。

继续根据向上转型的类举例：

classAnimal{publicStringname;publicAnimal(Stringname){this.name=name;}}classDogextendsAnimal{publicDog(Stringname){super(name);}}classCatextendsAnimal{publicCat(Stringname){super(name);}}publicclassTest{publicstaticvoidmain(String[]args){Dogdog=newDog("Papy Dog");Catcat=newCat("Papy Cat");Animalanimal=newDog("Papy Dog");//向上转型Dogdog=(Dog)animal;//合法的向下转型//cat = (Cat)animal; //非法的向下转型}}

注意向下转型的要求：

• 必须先有向上转型（前提）
• 对象的真实类型必须是目标子类或者其子类
• 需要强制类型转换（Cast）
• 推荐instanceof检查类型（安全转型方式）

if(ainstanceofDog){Dogd=(Dog)a;d.bark();}

来个比喻呢就是

• 向上转型：你把 “iPhone” 当成 “手机” 来用，没问题。
• 向下转型：你把 “手机” 强行当成 “iPhone” 用，只有当它本来就是 iPhone 才行，如果本来是 “小米”，那么立马报错。

1.3重写与重载

1.3.1重写

classAnimal{publicStringname;publicAnimal(Stringname){this.name=name;}publicvoideat(){System.out.println("Animal在吃饭");}}classDogextendsAnimal{publicDog(Stringname){super(name);}publicvoideat(){System.out.println("Dog在吃饭");}}//输出结果：Dog在吃饭

以上例子构成了重写，按规则是要调用父类的eat的，但是构成了动态绑定（伏笔）

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写,形参列表与被重写方法的参数列表必须完全相同。

方法重写的规则：

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型方法名 (参数列表) 要完全一致
• 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

对第二点解释：

classParent{NumbergetValue(){return1;}}classChildextendsParent{@OverrideIntegergetValue(){return2;}// OK，Integer 是 Number 的子类}

1.3.2重写与重载的区别

区别点	重载Overload	重写Override
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改[除非构成父子类关系]
访问限定符	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

重写的原则：

对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。

• 父类：DrinkMachine（饮料机）

classDrinkMachine{publicvoidmakeDrink(){System.out.println("制作普通饮料");}}

• 子类：CoffeeMachine（咖啡机）

classCoffeeMachineextendsDrinkMachine{@OverridepublicvoidmakeDrink(){System.out.println("制作咖啡");}}

eg：比如饮料机。父类：DrinkMachine 子类：咖啡机CoffeeMachine，如果直接改DrinkMachine的makeDrink()方法把“普通饮料“换成”咖啡“，那以后所有买饮料的人都只能喝咖啡了， 果汁党就会抗议 😂。

正确做法应该就是新建CoffeeMachine，只改子类逻辑，不影响父类

1.3.3动态绑定与静态绑定

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

解释如下：

classParent{voidhello(){System.out.println("Parent hello");}}classChildextendsParent{@Overridevoidhello(){System.out.println("Child hello");}}publicclassMain{publicstaticvoidmain(String[]args){Parentp=newChild();// 向上转型p.hello();// 打印什么？}}

(1)编译期

• 编译器只知道p的静态类型是Parent，所以它会去Parent类中查找有没有hello()方法。
• 查到以后，编译器就说：“行，这个调用是合法的。”
• 但它不会决定最终调用哪个版本。

👉 所以编译期只检查方法是否存在，但不绑定到具体实现。

(2)运行期

• 运行时，p实际上引用的是一个Child对象。
• Java 虚拟机（JVM）在调用p.hello()的时候，会根据对象的真实类型（运行时类型）来决定到底执行Parent.hello()还是Child.hello()。
• 因为Child重写了hello()，所以 JVM 调用的是Child的版本。

这就是动态绑定（Dynamic Dispatch）

JVM底层原理

在JVM的方法区（Java8后都是元空间Metaspace）里，每个类都会有一张方法表（Method Table，类似 C++ 的 vtable） 。

1.类加载时：

• JVM 为Parent类建立方法表，里面有hello -> Parent.hello的映射。
• JVM 为Child类建立方法表，发现hello被重写了，就把hello -> Child.hello替换掉。

2.对象创建时：

• 当new Child()执行时，对象头里会有一个指针，指向Child的类信息（包括方法表）。

3.方法调用时：

执行p.hello()，JVM 并不会直接调用Parent.hello()，而是：

• 看p的运行时类型 → 发现它指向Child
• 在Child的方法表里查找hello()→ 找到Child.hello()→ 调用它。

👉 因此，真正起作用的是运行时对象的类信息 + 方法表查找，而不是变量的声明类型 。

我们可以类比为：

编译期：老师点名检查->”这个学生‘回答问题’的功能吗？“（有）

运行期：真正回答问题的是具体学生，可能每个人回答的方式不同。

1.4回顾多态

1.4.1多态思想

classAnimal{publicStringname;publicAnimal(Stringname){this.name=name;}publicvoideat(){System.out.println(this.name+"在吃饭");}}classDogextendsAnimal{publicDog(Stringname){super(name);}@Overridepublicvoideat(){System.out.println(this.name+"在吃饭");}}classCatextendsAnimal{publicCat(Stringname){super(name);}@Overridepublicvoideat(){System.out.println(this.name+"在吃饭");}}publicclassTest{publicstaticvoidfunc(Animalanimal){animal.eat();}publicstaticvoidmain(String[]args){Dogdog=newDog("Papy Dog");Catcat=newCat("Papy Cat");func(dog);func(cat);}}输出结果：PapyDog在吃饭PapyCat在吃饭

调用同一个方法，得到不同的结果（多态思想）

1.4.2多态的优缺点

优点：

publicstaticvoiddrawShapes(){Rectrect=newRect();Cyclecycle=newCycle();Flowerflower=newFlower();String[]shapes={"cycle","rect","cycle","rect","flower"};for(Stringshape:shapes){if(shape.equals("cycle")){cycle.draw();}elseif(shape.equals("rect")){rect.draw();}elseif(shape.equals("flower")){flower.draw();}}}

我们使用多态的话，就能优化一下我们的代码

publicstaticvoiddrawShapes(){// 我们创建了一个 Shape 对象的数组.Shape[]shapes={newCycle(),newRect(),newCycle(),newRect(),newFlower()};for(Shapeshape:shapes){shape.draw();}}

缺点：

多态的缺陷–代码的运行效率降低

1.属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

2.构造方法没有多态性

以上是我关于Java多态的笔记分享
感谢你读到这里，这也是我学习路上的一个小小记录。希望以后回头看时，能看到自己的成长~