JAVA中的多态

A.多态的概述

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

B.多态的前提和体现

1.有继承/实现关系

2.有方法重写

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

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

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

 

对Cat实例化，外部看到的是Animal对象，Animal对象无weight属性，报错：

 

访问到父类的成员变量：

 

 

 

编译看左边，Animal类中无palyGame方法，编译报错：

 

 

 

执行看右边，子类重写了父类方法：

 

 

 

 

为什么成员变量和成员方法的访问不一样：

因为成员方法有重写，而成员变量没有。

 

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