Java——多态

一、多态的概念

二、多态实现条件

在java中要实现多态，必须要满足如下3种条件：
1. 必须发生继承.
2. 子类必须要对父类中方法进行重写 .
3. 通过父类的引用调用重写方法.

class Animal {
    public String name;
    public int age;
    
    public void eat() {
        System.out.println(this.name+"正在干饭");
    }
}
class Cat extends Animal{
    public void eat() {
        System.out.println(this.name+"正在吃猫粮");
        
    }
}

三、 重写

class Cycle {
    public void draw() {
        System.out.println("●");
    }
}
class Flower {
    public void draw() {
        System.out.println("❀");
    }
}

【方法重写的规则】

• 子类不能比父类中被重写的方法的访问权限更低.
• 父类被static、private修饰的方法、构造方法都不能被重写.
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法.
• 重写的方法, 可以使用 @Override 注解来显式指定.

【重写和重载的区别】

三、向上转型

【使用场景】

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

class Animal {
    public String name;
    public int age;

    public void eat() {
        System.out.println(this.name+"正在干饭");
    }
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println(this.name+"正在吃狗粮");
    }
}

public class Test2 {
    public static Animal eatFood1() {
        return new Dog();//方法返回
    }
    public static void eatFood(Animal animal) {
        animal.eat();//方法传参
    }
    public static void main(String[] args) {
       Animal animal = new Dog(); //直接赋值
       animal.eat();
       eatFood(new Dog());
    }
}

向上转型的优点：让代码更加简单灵活.
向上转型的缺陷：不能调用到子类特有的方法.

四、 多态的优缺点

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

 String[] shapes = {"cycle","rect","flower"};
        for (int i = 0; i < shapes.length; i++) {
            if(shapes[i].equals("cycle")) {
                cycle.draw();
            }else if(shapes[i].equals("rect")) {
                rect.draw();
            }else if(shapes[i].equals("flower")) {
                flower.draw();
            }
        }

五、 Bug坑

这是一段有坑的代码,注意看它的运行结果 : //D.func()0

class B {
    public B() {
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;

    public D(int num) {
        this.num = num;
    }

    @Override
    public void func() {
        System.out.println("D.func()"+num);//D.func()0
    }
}
public class Test4 {
    public static void main(String[] args) {
        D d = new D();
    }
}

过程 :

• 构造 D 对象的时候–>调用 B 的构造方法.
• B 的构造方法中–>func 方法, 此时会调用到 D 中的 func .
• D 对象自身还没有构造, num值为 默认值.