JAVA入门-019（多态）

多态

多态概述

同一个对象，在不同时刻表现出来的不同形态
举例：猫
我们可以说猫是猫：猫 cat = new 猫();
我们也可以说猫是动物：动物 cat = new 猫();
这里猫在不同时刻表现出来了不同的形态，这就是多态

多态的前提和体现

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

代码测试：

public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}

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

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

输出结果：

多态中成员访问特点

代码测试：

public class Animal {

    public int age = 40;

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

public class Cat extends  Animal {      //继承关系
    public int weight = 10;
    public int age = 20;

    @Override
    public void eat() {                 //方法重写
        System.out.println("猫吃🐟");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();                   //父类引用指向子类
        a.eat();                                //成员方法运行看右边
        System.out.println(a.age);              //成员变量运行看左边
        //System.out.println(a.weight);         //报错，成员变量编译看左边，Animal没有weight
        //a.playgame();                         //报错，成员方法编译看左边，Animal没有playgame();
    }
}

成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边

为什么成员变量和成员方法的访问不一样呢？
因为成员方法有重写，而成员变量没有

多态的好处和弊端

代码测试：

public class Animal {

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

public class Cat extends  Animal {      //继承关系

    @Override
    public void eat() {                 //方法重写
        System.out.println("猫吃🐟");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃🥩");
    }
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

/*
    动物操作类
 */
public class AnimalOperator {
    /*
    public void useAnimal(Cat c) {
        c.eat();
    }
    public void useAnimal(Dog d) {
        d.eat();
    }*/
    public void useAnimal(Animal a){
        a.eat();                    //多个子类对象进来可以访问子类重写方法
        //a.lookDoor();             //不能访问子类的方法
    }
}

public class AnimalDemo {
    public static void main(String[] args) {

        AnimalOperator animalOperator = new AnimalOperator();

        Cat c = new Cat();
        animalOperator.useAnimal(c);
        Dog d = new Dog();
        animalOperator.useAnimal(d);

    }
}

运行结果：

• 多态的好处：提高了程序的可扩展性
  具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体子类型对象参与操作
• 多态的弊端：不能使用子类的特有功能

多态中的转型

• 向上转型
  从子到父
  父类引用指向子类对象
• 向下转型
  从父到子
  父类引用转为子类对象

代码测试：

public class AnimalDemo {
    public static void main(String[] args) {
        // 多态
        Animal a = new Cat();   //向上转型
        a.eat();
        //a.playGame();         //向上转型无法调用子类方法

        /*Cat c = new Cat();
        c.eat();
        c.playGame();*/

        Cat c = (Cat) a;        //向下转型 还是同一个对象
        c.eat();
        c.playGame();           
    }
}

运行结果：