Java中的多态

A.多态的概述

a.简单说明：多态即为同一个对象在不同时刻表现出的不同形态。

B.多态的前提和体现：

1.有继承/实现关系

2.有方法重写

3.有父类引用指向子类对象

4.代码演示；

package demo120;

/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的实现前提
 *               1.有继承/实现关系
 *               2.有方法重写
 *               3.有父类引用指向子类对象
 */
public class Cat extends Animal {
        //有方法重写
    @Override
    public void eat() {
        System.out.println("猫要吃鱼。。。。");
    }
}

package demo120;

/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的实现前提
 *              举例子;我们说猫是猫：猫 Cat = new 猫();
 *                   也可以说猫是动物：动物 Animal = new 猫();
 *                   这里我们举猫的例子就是多态的表现形式
 *               多态的前提和体现：
 *                  1.有继承/实现关系
 *                  2.有方法重写
 *                  3.有父类引用指向子类对象
 *
 */
public class Animal {
    //Animal类中的方法
    public void eat() {
        System.out.println("动物要吃东西。。。。");
    }

}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的实现前提
 *              测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
    }
}

C.多态中成员访问的特点​​​

a:成员变量：编译看左边，执行看左边

b：成员方法：编译看左边，执行看右边（因为子类重写了父类的方法）

c.代码演示：

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态中成员访问的特点（父类）
 *              1.成员变量；编译看左边，执行看左边
 *              2.成员方法：编译看左边，执行看右边
 */
public class Animal02 {
    //Animal02中的成员变量
    public int age = 8;

    //Animal02中的成员方法
    public void eat() {
        System.out.println("动物要吃东西。。。。");
    }
}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态中成员访问的特点（子类）
 *              1.成员变量；编译看左边，执行看左边
 *              2.成员方法：编译看左边，执行看右边
 */
public class Cat02 extends Animal02 {
    //Cat02类中的成员变量
    public int age = 3;
    public int weight = 15;

    //重写Animal02类中的eat()方法
    @Override
    public void eat() {
        System.out.println("猫要吃鱼。。。。。");;
    }
    //自己本身的成员方法
    public void play() {
        System.out.println("猫要玩耍。。。。。");
    }

}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态中成员访问的特点（测试类）
 *              1.成员变量；编译看左边，执行看左边
 *              2.成员方法：编译看左边，执行看右边
 */
public class AnimalDemo02 {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal02 a = new Cat02();
        //成员变量；编译看左边，执行看左边(输出父类的成员变量age)
        System.out.println(a.age);

//        //成员变量；编译看左边，执行看左边(如果尝试输出子类（右边）的成员变量则会报错)
//        System.out.println(a.weight);

        //成员方法：编译看左边，执行看右边(因为子类重写了父类的成员方法）
        a.eat();


    }
}

8
猫要吃鱼。。。。。

Process finished with exit code 0

可以看到在控制台输出了"8"(父类中的成员变量，对应：成员变量编译看左边，执行看左边)，"猫要吃鱼。。。。"（子类中的成员方法，对应：成员方法编译看左边，执行看右边）

D.多态的好处与弊端；

a.好处：提高了程序的扩展性。具体体现在定义方法的时候使用父类型作为参数，在将来使用时使用具体的子类型参与操作。

b.弊端：不能使用子类的特用功能。

c.代码演示；

package demo120;

/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的好处与弊端
 *              a.好处：提高了程序的扩展性。具体体现在定义方法的时候使用父类型作为参数，
 *              在将来使用时使用具体的子类型参与操作。
 *
 *              b.弊端：不能使用子类的特用功能。
 *              父类
 */
public class Animal03 {

    public void eat() {
        System.out.println("动物要吃东西。。。。");
    }

}

ackage demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的好处与弊端
 *              a.好处：提高了程序的扩展性。具体体现在定义方法的时候使用父类型作为参数，
 *              在将来使用时使用具体的子类型参与操作。
 *
 *              b.弊端：不能使用子类的特用功能。
 *              子类
 */
public class Cat03 extends Animal03 {
    //方法重写

    @Override
    public void eat() {
        System.out.println("猫要吃鱼。。。。。");
    }
}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的好处与弊端
 *              a.好处：提高了程序的扩展性。具体体现在定义方法的时候使用父类型作为参数，
 *              在将来使用时使用具体的子类型参与操作。
 *
 *              b.弊端：不能使用子类的特用功能。
 *              子类
 */
public class Dog03 extends Animal03 {
    //方法重写

    @Override
    public void eat() {
        System.out.println("狗子要吃肉骨头。。。。。");
    }

    //在此处给狗类添加一个自己独特的成员方法
    public void play() {
        System.out.println("狗子要拆家。。。。。。");
    }
}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的好处与弊端
 *              a.好处：提高了程序的扩展性。具体体现在定义方法的时候使用父类型作为参数，
 *              在将来使用时使用具体的子类型参与操作。
 *
 *              b.弊端：不能使用子类的特用功能。
 *              操作类
 */
public class UseAnimal03 {
    //把父类型作为参数
    public void useAnimal(Animal03 a) {
        a.eat();
    }
}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的好处与弊端
 *              a.好处：提高了程序的扩展性。具体体现在定义方法的时候使用父类型作为参数，
 *              在将来使用时使用具体的子类型参与操作。
 *
 *              b.弊端：不能使用子类的特用功能。
 *              测试类
 */
public class AnimalDemo03 {
    public static void main(String[] args) {
        //创建操作类的对象
        UseAnimal03 ua = new UseAnimal03();

        //创建猫类对象
        Animal03 cat = new Cat03();

        //创建狗类的对象
        Animal03 dog = new Dog03();

        //调用操作类的方法
        ua.useAnimal(cat);
        ua.useAnimal(dog);

        //弊端：不能使用子类的特用功能测试类,
        //报错：Cannot resolve method 'play' in 'Animal03'
//        dog.play()
    }
}

E.多态中的转型；

a.向下转型：从子到父类，父类引用指向子类对象。

b.向上转型：从父到子，父类引用抓换为子类对象（解决了多态不能访问子类独自的方法问题）

c.代码演示；

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的转型
 *                  a.向下转型：从子到父类，父类引用指向子类对象。
 *
 *                  b.向上转型：从父到子，父类引用抓换为子类对象（解决了多态不能访问子类独自的方法问题）
 *
 *                  父类
 */
public class Animal04 {
    public void eat() {
        System.out.println("动物要吃东西。。。。。");
    }
}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的转型
 *                  a.向下转型：从子到父类，父类引用指向子类对象。
 *
 *                  b.向上转型：从父到子，父类引用抓换为子类对象（解决了多态不能访问子类独自的方法问题）
 *
 *                  子类
 */
public class Cat04 extends Animal04 {
    @Override
    public void eat() {
        System.out.println("猫要吃鱼。。。。。。");
    }

    //子类自己的方法
    public void play() {
        System.out.println("猫要玩。。。。。");
    }
}

package demo120;
/**
 * @author ln
 * @date 2022/1/20
 * @description 多态的转型
 *                  a.向下转型：从子到父类，父类引用指向子类对象。
 *
 *                  b.向上转型：从父到子，父类引用抓换为子类对象（解决了多态不能访问子类独自的方法问题）
 *
 *                  测试类
 */
public class AnimalDemo04 {
    public static void main(String[] args) {
        //向下转型：从子到父类，父类引用指向子类对象。
        Animal04 a = new Cat04();
        a.eat();

        //向上转型：从父到子，父类引用抓换为子类对象（解决了多态不能访问子类独自的方法问题）
        Cat04 c =(Cat04) a;
        c.eat();
        //可以调用子类自己的方法了
        c.play();
    }
}

猫要吃鱼。。。。。。
猫要吃鱼。。。。。。
猫要玩。。。。。

Process finished with exit code 0