JavaSE 多态

1. 多态

1.1 多态概述

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

多态的前提和体现：

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

1.2 多态中成员访问特点

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

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

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

package Polymorphism01;

public class Animal {
    public int age = 40;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package Polymorphism01;

public class Cat extends Animal{
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

package Polymorphism01;
/*
    多态：
        同一个对象，在不同时刻表现出来的不同形态
    举例：猫
        我们可以说猫是猫：猫 cat = new 猫();
        我们也可以说猫是动物：动物 animal = new 猫();
        这里猫在不同的时刻表现出了不同的形态，这就是多态
    多态的前提和体现：
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args){
        //有父类引用指向子类对象
        Animal a = new Cat();   //多态

        //成员变量：编译看左边，执行看左边
        System.out.println(a.age);  //结果输出40
//        System.out.println(a.weight);   //报错

        //成员方法：编译看左边，执行看右边
        a.eat();    //结果输出猫吃鱼
//        a.playGame();   //报错
    }
}

1.3 多态的好处和弊端

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

• 弊端：不能使用子类的特有功能

package Polymorphism02;

public class Animal {

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

package Polymorphism02;

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

package Polymorphism02;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

package Polymorphism02;

public class Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }
}

package Polymorphism02;

public class AnimalOperator {
    /*
    public void useAnimal(Cat c){   //Cat c = new Cat();
        c.eat();
    }
    public void useAnimal(Dog d){   //Dog d = new Dog();
        d.eat();
    }
    */

    public void useAnimal(Animal a){
        //Animal a = new Cat();
        //Animal a = new Dog();

        a.eat();
    }
}

package Polymorphism02;

public class AnimalDemo {
    public static void main(String[] args){
        //创建动物操作类对象，调用方法
        AnimalOperator ao = new AnimalOperator();

        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);

        Pig p = new Pig();
        ao.useAnimal(p);
    }
}

1.4 多态中的转型

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

向下转型解决了多态不能使用子类特有功能的弊端

package Polymorphism03;

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

package Polymorphism03;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉迷藏");
    }
}

package Polymorphism03;
/*
    向上转型
        从子到父
        父类引用指向子类对象
    向下转型
        从父到子
        父类引用转为子类对象
 */
public class AnimalDemo {
    public static void main(String[] args){
        //多态
        Animal a = new Cat();   //向上转型
        a.eat();
//        a.playGame();   //报错

        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}