多态上

多态的概述：同一个对象在不同时刻表现出来的不同形态
例：猫

我们可以说猫就是猫：猫 cat = new 猫（）；
我们也可以说猫是动物：动物 animal = new 猫（）；
此时的猫在不同的时刻表现出来不同的形态，这就是多态

多态的前提和体现：

有继承/实现关系
有方法的重写
有父类引用指向子类对象

public class DuoTai {
    public static void main(String[] args) {
        Cat c = new Cat();
        
        // 父类引用指向子类对象
        Animal a = new Cat();
        a.eat();
    }
}

class Animal{
    public void eat(){
        System.out.println("动物吃饭");
    }
}

//有继承/实现关系
class Cat extends Animal{
     //有方法的重写
    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }
}

多态当中成员访问的特点：Fu fu = new zi();

构造方法：同继承一样，子类会通过super关键字访问父类当中的构造方法
成员变量：编译者左边（父类），执行也看左边（父类）
成员方法：编译看左边（父类），执行看右边（子类）
成员变量与成员方法之所以访问不一样，是因为方法有重写而变量没有重写

public class Test2Polymorpic {
    /*
         多态的成员访问特点:

                成员变量: 编译看左边 (父类), 运行看左边 (父类)

                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

class Fu {
    int num = 10;

    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method(){
        System.out.println("Zi.. method");
    }
}

多态的好处与弊端：

多态的好处：提高程序的扩展性
          具体体现：定义方法的时候，可以使用父类作为形式参数，该方法便可以接收该父类的任意子类对象
多态的弊端：不能够使用子类特有的功能逻辑代码

package com.itheima.test3;

public class Test3Polymorpic {
    public static void main(String[] args) {
       //接收该父类的任意子类对象
        useAnimal(new Dog());
        useAnimal(new Cat());
    }
                     
                              //这里的Animal就是父类
    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();
        //a.watchHome();

        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }

//        Dog dog = (Dog) a;
//        dog.watchHome();  // ClassCastException  类型转换异常

    }

}

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

多态的转型：

向上转型：Fu fu = new Zi();
从子到父
父类引用指向子类对象
向下转型：Zi zi = (Zi)fu;    //这里就像强制类型转换，把父类转换成子类，需要强转
从父到子
父类引用转为子类对象

如果我们想要子类特有的方法最好的方法就是创建子类对象，通过对象.方法名（）的形式调用。
另外一种就是向下转型

萌新小白原创，如有不足之处，还请各位前辈多多指教，将不胜感激🙏🙏🙏