java--多态（详解）

news2024/10/23 7:13:23

一、概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

在这里插入图片描述

二、多态实现的条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

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

三、向上转型和向下转型

3.1 向上转型

在这里插入图片描述
三种向上转型的方式：

1.直接赋值

  Animals animals=new Dog("小狗",6);

2.方法的传参

  public static void func(Animals animal){

    }
  public static void main(String[] args) {
    Dog dog=new Dog("x",6);
        func(dog);
    }

3.返回值

    public static Animals func2(){
        Dog dog=new Dog("x",56);
          return dog;
    }
    public static void main(String[] args) {
        Animals animals=func2();
    }
}

缺点：通过父类的引用不能调用子类的方法
在这里插入图片描述

3.2 向下转型

在这里插入图片描述

向下转型无非就是把一个父类引用放着子类对象，然后强转成对应的子类类型在赋值给子类引用，也就是将父类引用还原成子类对象。

class TestAnimal {
    public static void main(String[] args) {
        //向下转型 -> 不安全
        //instanceof 判断animal引用的对象是不是Dog类型的，如果是则为 true 不是则为 false
        Animal animal = new Dog("王五", 12);
        if (animal instanceof Dog) {
            Dog dog = (Dog)animal;
            dog.eat();
        }
    }
}

四、重写和重载

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非ﬁnal修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

【方法重写的规则】：

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

在这里插入图片描述

在子类中对父类的方法进行重写
在这里插入图片描述

方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y;
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}

【重写和重载的区别】
在这里插入图片描述

在这里插入图片描述

五、理解多态

在这里插入图片描述
可以看到animals引用的对象是不一样的，但是调用的是同一个方法，此时表现出的不同现象我们叫做多态。

5.1练习：

打印指定不同图案(多态实现)：

public class Drawing {
    public void draw() {
        System.out.println("画图");
    }
}
class DrawCircle extends Drawing {
    @Override
    public void draw() {
        System.out.print("⚪");
    }
}
class DrawFlower extends Drawing {
    @Override
    public void draw() {
        System.out.print("❀");
    }
}
class DrawTriangle extends Drawing {
    @Override
    public void draw() {
        System.out.print("▲");
    }
}

第一种方法：用 for-each语句

class TestDraw {
    //方法一：使用 循环 + if else
    public static void draw1() {
        DrawTriangle triangle = new DrawTriangle();
        DrawFlower flower = new DrawFlower();
        DrawCircle circle = new DrawCircle();
        String[] shapes = {"Triangle", "Flower", "Flower", 
                           "Circle", "Flower", "Triangle"
                          };
        //增强for循环遍历数组
        for (String s : shapes) {
            if (s.equals("Triangle")) {
                triangle.draw();
            } else if (s.equals("Flower")) {
                flower.draw();
            } else if (s.equals("Circle")) {
                circle.draw();
            }
        }
    }
    public static void main(String[] args) {
        draw1();
    }
}

第二种用多态

class TestDraw {
    public static void draw2() {
        Drawing[] shapes = { new DrawTriangle(), new DrawFlower(), new DrawFlower(),
                             new DrawCircle(), new DrawFlower(), new DrawTriangle()
                           };
        for (Drawing s : shapes) {
            s.draw();
        }
    }
    public static void main(String[] args) {
        draw2();
    }
}

在这里插入图片描述

多态部分的优点：

可以有效降低代码复杂度，避免出现多个 if else可扩展性更强，如果要新增打印，也更简单

多态的缺点：

属性没有多态性，当父类属性和子类属性同名，通过父类引用只能调用父类自己的成员属性构造方法也没有多态性

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

class A {
    public A() {
    func();
    }
    public void func() {
        System.out.println("A.func()");
    }
}
class B extends A {
    private int num = 1;
    @Override
    public void func() {
    System.out.println("B.func() " + num);
    }
}
public class Test {
    public static void main(String[] args) {
    A b = new B();
    }
}

可以看到构造 D 对象的同时, 会调用 B 的构造方法。
B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func此时 D >对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0.。
如果具备多态性，num的值应该是1.所以在构造函数内，尽量避免使用实例方法，除了ﬁnal和private方法。

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。

在这里插入图片描述