Java：多态

多态：同一事物不同时刻表现出的不同状态

多态的前提：

1、要有继承关系；

2、要有方法的重写；

3、要有父类应用指向子类对象

向上转型

父类名 f=new 子类名（....）;

多态访问成员的特点：

1、成员变量：编译看左边，执行看左边

构造方法：构造对象的时候，先访问父类中的成员方法，先对父类中的数据进行初始化

2、成员方法：编译看左边，执行看右边

因为成员方法存在重写，所以访问看右边

3、静态方法：编译看左边，执行看左边

由于被statuic修饰的成员都是与类相关的，这里不是重写，所以访问还是看右边的

class Fu1{
    int num=100;
    public void show(){
        System.out.println("这是父类中的无参方法");
    }
    public static void show1(){
        System.out.println("这是父类中的静态方法");
    }
}
class Zi1 extends Fu1{
    int num=200;
    @Override
    public void show(){
        System.out.println("这是子类中的方法");
    }
    public static void show1(){
        System.out.println("这是子类中的静态方法");
    }


}
public class Polymorphic1 {
    public static void main(String[] args) {
        Fu1 fu1=new Zi1();
        System.out.println(fu1.num);
//        100
        fu1.show();
//        这是子类中的方法
        fu1.show1();
//        这是父类中的静态方法
    }

}

多态的弊端：无法使用子类特有的方法

package com.one;
class Fu2{
    public void show(){
        System.out.println("这是父类中的show方法");
    }
}
class Zi2 extends Fu2{
    public void show(){
        System.out.println("这是子类中的show方法");
    }
    public void show1(){
        System.out.println("这是子类中特有的show1方法");
    }
}
public class Polymorphic2 {
    public static void main(String[] args) {
        Fu2 fu2=new Zi2();
        fu2.show();
    }
}

向下转型：

子类名 s=（子类名）f;

1、向上转型：
    Fu f = new Son();

2、向下转型
    Son s = (Son)f;

向下转型需要注意一个问题：

要求转型的类与父类的引用必须存在继承关系，并且在一开始创建多态的时候使用的是该类；

class Fu3{
    public void show(){
        System.out.println("这是父类中的show方法");
    }
}
class Zi3 extends Fu3{
    public void show(){
        System.out.println("这是子类中的show方法");
    }
    public void show1(){
        System.out.println("这是子类中特有的show1方法");
    }
}
public class Polymorphic3 {
    public static void main(String[] args) {
        Fu3 fu3=new Zi3();
        fu3.show();
//        这是子类中的show方法
        Zi3 zi3=(Zi3) fu3;
        zi3.show();
//        这是子类中的show方法
        zi3.show1();
//        这是子类中特有的show1方法
    }
}

猫狗案例：

class Animal{
    public void eat(){
        System.out.println("吃");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("🐱吃🐟");
    }
    public void show(){
        System.out.println("🐱抓🐀");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("🐕吃骨头");
    }
    public void show(){
        System.out.println("🐕看🚪");
    }
}
public class Polymorphic4 {
    public static void main(String[] args) {
        Animal animal = new Dog();

        Dog dog = (Dog) animal;
        dog.eat();
//        🐕吃骨头
        dog.show();
//        🐕看🚪

        Animal animal1 = new Cat();
        Cat cat = (Cat) animal1;
        cat.eat();
//        🐱吃🐟
        cat.show();
//        🐱抓🐀
    }
}