• JavaSE - 多态

    目录

    1. 重写

    面试问题：重写和重载的区别（详）：

    静态绑定和动态绑定：

    2. 向上转型和向下转型

    2.1 向上转型

    发生向上转型的场景/使用场景：

    2.2 向下转型

    3. 多态

    3.1 什么是多态

    3.2 多态的实现条件（缺一不可）

    3.3 多态的优缺点

    优点:

    缺点：

    3.4 避免在构造方法中调用重写的方法

    1. 重写

    子类对父类的某个方法进行重新实现，一定发生在继承层次上。

    重写：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的方法的实现过程进行重新编写。子类能够根据需要实现子类的方法或是父类的方法。

    重写的注意事项：

    1. 子类在重写父类的方法时，一般必须与父类方法一样： 返回值类型 方法名 (参数列表) 要完全一致 

    2. 被重写的方法返回值类型可以不同，但是必须是具有父子关系的

    3. 修饰符可以不一样，但是有要求：子类的访问权限要大于等于父类的访问权限且修饰符不可以是private，private修饰的方法是不可以重写的。

    访问权限由大到小：【public > protected > default > private 】

    4.  final 修饰的方法，我们叫做密封方法，不能被重写

    5.  如果被static修饰，也不能被重写

    6. 构造方法也不能重写，只能重载

    7. 重写的方法, 可以使用 @Override 注解，用来检查错误

    面试问题：重写和重载的区别（详）：

    1. 重写必须满足返回值类型，方法名，参数列表都完全一样。返回值类型也可以不一样，但必须要构成父子关系。而重载的返回值类型不做要求，方法名必须一样，参数列表必须不一样，个数，数据类型，不同数据类型的顺序，有一个不同就算不一样。

    2. 重写一定发生在继承层次上，重载可以发生在一个类里的多个方法之间，也可以发生在继承当中

    重写的特点：（！！！） 

    只有成员方法才有重写，因为成员方法遵循就近原则，所以重写也遵循就近原则，new的对象是谁就先访问谁，new的是子类的对象，就会调用此子类中的此方法。new的是父类的对象，就会调用父类中的此方法。如：是new Dog() 就调用Dog中的此重写方法；是new Cat()就调用Cat中的此重写方法；是new Animials 就调用Animals中的此被重写的方法。

    下面看一个重写的例子： 

    1. class Animals{
    2.     public String name;
    3.     public int age;
    4.  
    5.     public void eat(){
    6.         System.out.println("Animals::eat()");
    7.         System.out.println(name+"正在吃饭");
    8.     }
    9.  
    10.     public Animals(String name,int age){
    11.         this.name = name;
    12.         this.age = age;
    13.     }
    14. }
    15. class Cat extends Animals{
    16.     public void fun(){
    17.         super.eat();
    18.     }
    19.     public void eat(){
    20.         System.out.println("Cat::eat()");
    21.         System.out.println(name+"正在吃猫粮");
    22.     }
    23.  
    24.     public Cat(String name,int age){
    25.         super(name,age);
    26.     }
    27. }
    28. class Dog extends Animals{
    29.     public boolean silly;
    30.     public void fun(){
    31.         super.eat();
    32.     }
    33.     public void eat(){
    34.         System.out.println("Dog::eat()");
    35.         System.out.println(name+"正在吃狗粮");
    36.     }
    37.  
    38.     public Dog(String name,int age,boolean silly){
    39.         super(name,age);
    40.         this.silly = silly;
    41.     }
    42.  
    43. }
    44. public class Test {
    45.     public static void main(String[] args) {
    46.         Dog dog = new Dog("hello",2,false);
    47.         dog.eat();
    48.         dog.fun();
    49.         System.out.println("------------------------------");
    50.         Cat cat = new Cat("mimi",3);
    51.         cat.eat();
    52.         cat.fun();
    53.  
    54.     }
    55. }

     

    静态绑定和动态绑定：

    静态绑定：也称为前期绑定(早绑定)，编译的时候，根据你传入的参数，能够确定你调用哪个方法，这就叫做静态绑定。

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

    个人理解，有重写的就是有动态绑定过程而没有重写的就是静态绑定

    由于动态绑定的存在，才有了运行时多态的存在。

    编译时，不能确定方法的行为【不知道调用对象是谁】，等到程序运行时，才能够确定具体调用哪个类的方法，【看等号右侧，即new的是哪个对象。是new Dog() 就调用Dog中的此方法；是new Cat()就调用Cat中的此方法；是new Animials 就调用Animals中的此方法】。这些只有程序运行后才能知道，所以为动态绑定。

    javap -c 类名:看反汇编 

    2. 向上转型和向下转型

    2.1 向上转型

    对象从子类类型转为父类类型，自动类型转换，一定发生在继承层次上。

    把子类对象给父类的引用     实际就是创建一个子类对象，将其当成父类对象来使用。

    那么父类的这个引用【animals】就指向了子类的对象【new Dog("小灰",20,false)】

     Animals animals = new Dog("小灰",20,false);

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

    猫和狗都是动物，所以将子类对象【猫或狗】给父类【动物】引用是合理的，此对象的类型就变成了Animals,所以只能访问父类中特有的成员变量和成员方法，不能访问子类中特有的成员属性和成员方法

    此时，父类的这个引用可以访问：

    1. 父类中特有的成员变量和成员方法(若此方法为被重写的方法，不会访问)

    2. 子类中的重写方法

    发生向上转型的场景/使用场景：

    1. 直接赋值

    2. 方法传参

    3. 方法返回

    具体见下面代码：

    1. class Animals{
    2.     public String name;
    3.     public int age;
    4.  
    5.     public void eat(){
    6.         System.out.println("Animals::eat()");
    7.         System.out.println(name+"正在吃饭");
    8.     }
    9.  
    10.     public void func(){
    11.         System.out.println("Animals::func()");
    12.     }
    13.     public Animals(String name,int age){
    14.         this.name = name;
    15.         this.age = age;
    16.     }
    17. }
    18. class Cat extends Animals{
    19.  
    20.     public void eat(){
    21.         System.out.println("Cat::eat()");
    22.         System.out.println(name+"正在吃猫粮");
    23.     }
    24.     public void catchMouse(){
    25.         System.out.println(name+"正在抓老鼠");
    26.     }
    27.     public Cat(String name,int age){
    28.         super(name,age);
    29.     }
    30. }
    31. class Dog extends Animals{
    32.     public boolean silly;
    33.  
    34.     public void eat(){
    35.         System.out.println("Dog::eat()");
    36.         System.out.println(name+"正在吃狗粮");
    37.     }
    38.  
    39.     public void barks(){
    40.         System.out.println(name+"正在汪汪叫");
    41.     }
    42.     public Dog(String name,int age,boolean silly){
    43.         super(name,age);
    44.         this.silly = silly;
    45.     }
    46.  
    47.     @Override
    48.     public String toString() {
    49.         return name+" "+age+" "+silly;
    50.     }
    51. }
    52. public class Test {
    53.     /**
    54.      *  2.
    55.      * 传子类的引用，用父类类型的引用接收
    56.      *
    57.      * 此时，站在function的角度上，只有一个引用animals,
    58.      * 一个引用animals调用同一个方法eat()，
    59.      * 因为这个引用animals指向的对象不一样，(或者可以说，因为传的参数不一样)
    60.      * 所以调用这个方法function时，所表现的行为不一样，
    61.      * 这种思想就叫做多态，多态是一种思想：
    62.      * 不同对象去完成同一行为，会产生不同的状态
    63.      */
    64.     public static void function(Animals animals1){
    65.         animals1.eat();
    66.     }
    67.  
    68.     /**
    69.      *  3. 方法返回 - 返回子类对象，会转换为父类类型
    70.      *  被父类引用接收
    71.      */
    72.     public static Animals function2(){
    73.         System.out.println("方法返回");
    74.         return new Cat("haha",7);
    75.     }
    76.     public static void main(String[] args) {
    77.         /**
    78.          *  1. 直接赋值
    79.          */
    80.         Animals animals = new Dog("大黄",4,true);
    81.         animals.func();
    82.         animals.eat();
    83.         System.out.println("---------------------------");
    84.         /**
    85.          *  2. 方法传参 - 传参一般传的引用
    86.          *  接收参数的方法一般设置为静态方法，
    87.          *  因为静态方法不需要new一个此类的对象就可以直接通过类名访问，
    88.          *  且在同一个类中，类名还可以省略，就特别的方便，
    89.          *  所以平常我们使用的方法都是带static的静态方法
    90.          */
    91.         Dog dog = new Dog("小黑",6,false);
    92.         function(dog);
    93.         Cat cat = new Cat("mimmi",5);
    94.         function(cat);
    95.         System.out.println("---------------------------");
    96.  
    97.         /**
    98.          *  3.
    99.          *   用父类引用接收
    100.          */
    101.         Animals animals2 = function2();
    102.  
    103.     }
    104. }

    2.2 向下转型

    对象从父类类型转为子类类型，需要强制类型转换

    将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，

    但有时候可能需要调用子类特有的 方法，此时：将父类引用再还原为子类对象即可，即向下转换。

    向下转型极度不安全，不建议使用

    if (animals instanceof Cat) {}

    instancof:

    左边是对象，右边是类，返回类型是boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。

    3. 多态

    3.1 什么是多态

    多态是一种思想，不同对象去完成同一行为，会产生不同的状态

    一个引用，调用同一个方法，因为引用的子类对象不一样，
所以调用这个方法后，表现出来的行为就不一样，这种思想就叫做多态。

    3.2 多态的实现条件（缺一不可）

    1. 【继承】必须在继承体系下

    2. 【重写】子类必须要对父类中方法进行重写

    3. 【向上转型】通过父类的引用调用重写的方法

    3.3 多态的优缺点

    优点:

    1. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else

    2. 可扩展能力更强

    通过一个例子来体会：【画图形】

    1. /**
    2.  * 题目：
    3.  *  1. 按顺序打印出：矩形，圆，三角形
    4.  *  2. 按顺序打印出：矩形，圆，矩形，圆，三角形
    5.  */
    6. class Shape{
    7.     public void draw(){
    8.         System.out.println("画图形");
    9.     }
    10. }
    11. class rectangle extends Shape{
    12.     @Override
    13.     public void draw() {
    14.         System.out.println("画矩形");
    15.     }
    16. }
    17. class Circle extends Shape{
    18.     @Override
    19.     public void draw() {
    20.         System.out.println("画圆");
    21.     }
    22. }
    23. class Triangle extends Shape{
    24.     @Override
    25.     public void draw() {
    26.         System.out.println("画三角形");
    27.     }
    28. }
    29. public class Test {
    30.     /**
    31.      * 第一题：
    32.      *
    33.      * 一个引用，调用同一个方法，因为引用的子类对象不一样，
    34.      *  所以调用这个方法后，表现出来的行为就不一样
    35.      */
    36.     public static void drawFuc(Shape shape){
    37.         shape.draw();
    38.     }
    39.  
    40.     /**
    41.      *  第二题：
    42.      */
    43.     public static void drawShapes(Shape shape){
    44.         shape.draw();
    45.     }
    46.  
    47.     public static void main(String[] args) {
    48.         /**
    49.          * 第一题做法：按顺序打印出：矩形，圆，三角形
    50.          *
    51.          * 传参
    52.          * 1. 直接传父类类型的引用，，由父类类型接收
    53.          * 2. 传子类类型的引用 传过去会发生自动类型转换，由父类类型接收
    54.          * 3. 直接传匿名对象，传过去会发生自动类型转换，由父类类型接收
    55.          */
    56.         Shape shape = new rectangle();
    57.         drawFuc(shape);
    58.         Circle circle = new Circle();
    59.         drawFuc(circle);
    60.         drawFuc(new Triangle());
    61.         System.out.println("----------------------");
    62.         /**
    63.          *  第二题做法：按顺序打印出：矩形，圆，矩形，圆，三角形
    64.          *  传不同的对象，会产生不同的行为
    65.          */
    66.         drawShapes(new rectangle());
    67.         drawShapes(new Circle());
    68.         drawShapes(new rectangle());
    69.         drawShapes(new Circle());
    70.         drawShapes(new Triangle());
    71.         //改进后:把对象存在数组中，遍历数组
    72.         System.out.println("---------改进后----------------");
    73.         Shape[] shapes = {new rectangle(),new Circle(),new rectangle(),new Circle(),new  Triangle()};//这串代码就发生了向上转型
    74.         for (Shape s:shapes) {
    75.            // drawShapes(s);//调用了方法drawShapes进行传参
    76.             s.draw();    // 遍历数组赋值，s中已经是不同的子类对象了，
    77.                          // 所以不传参也可以，直接调用draw方法，不同的对象会产生不同的行为
    78.  
    79.         }
    80.  
    81.     }
    82. }

     

    缺点：

    代码的运行效率降低

    1.  属性没有多态性

    属性没有多态性的本质是：重写不会发生在属性中，只会发生在方法中，没有重写的特点，就没有多态性。

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

    2. 构造方法没有多态性

    3.4 避免在构造方法中调用重写的方法

    一段有坑的代码：

    我们创建两个类, B 是父类, D 是子类。D 中重写 func 方法，并且在 B 的构造方法中调用 func

    构造 D 对象的同时, 调用D的构造方法之前会【通过super();】先调用B 的构造方法

    B 的构造方法中调用了被重写的方法 func , 此时会触发动态绑定，因为new的对象是，new D();所以会调用到 D 中的 func

    此时 D 对象自身还没有构造, 没有调用D的构造方法，所以 num 处在未赋值的状态, 值为 0

    所以，在构造方法内，不要调用实例方法，避免发生重写；final和private方法除外，【它们不会出现重写情况】

    如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成，可能会出现一些隐藏的但是又极难发现的问题。

  • 相关阅读:
    leetcode面试经典150题——29 三数之和
    北斗GPS卫星时钟同步服务器在银行数据机房应用
    PID控制原理
    【Opencv实战】颜色测试：你是色盲/色弱吗？从零带你了解色彩与原理，简单的颜色识别小程序，感动.jpg（全是干货）
    应届生Java面试经验总结
    【教程】使用vuepress构建静态文档网站，并部署到github上
    美客多、亚马逊卖家如何运用自养账号进行有效测评？
    linux基础篇
    C#版 iText7——画发票PDF（完整）
    Django实战项目-学习任务系统-用户注册
  • 原文地址：https://blog.csdn.net/m0_61731585/article/details/126256432