Java---多态

1. 多态概述

 1. 多态：同一个对象，在不同时刻表现出来的不同形态。

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

 3. 多态的前提和体现：(1) 有继承/实现关系。 (2) 有方法重写。 (3) 有父类引用指向子类对象。

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

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

public class Demo {
    public static void main(String[] args) {
        Animal cat=new Cat();
        cat.eat(); //输出：猫吃鱼
    }
}

2. 多态访问特点

 1. (1) 访问成员变量：编译看左边，访问看左边。 (2) 访问成员方法：编译看左边，访问看右边。

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

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

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

public class Demo {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal cat=new Cat();
        System.out.println(cat.age); //输出：40。证明访问成员变量运行时也看左边
        //System.out.println(cat.weight); 会报错，因为编译时看左边

        cat.eat(); //输出：猫吃鱼
        //cat.playgame; 会报错
    }
}

3. 多态访问好处和弊端

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

 2. 多态的弊端：不能使用子类特有的功能。

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 class AnimalOperator {
    public void useAnimal(Animal a){
        a.eat();
    }
}

public class Demo {
    public static void main(String[] args) {
        AnimalOperator ao=new AnimalOperator();
        Cat c=new Cat();
        ao.useAnimal(c);  //输出：猫吃鱼
        Dog d=new Dog();
        ao.useAnimal(d);  //输出：狗吃骨头
    }
}

4. 多态中的转型

 转型分两类。(1) 向上转型：从子到父，父类引用指向子类对象。 (2) 向下转型：从父到子，父类引用转为子类对象。

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

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

public class Demo {
    public static void main(String[] args) {
        //这就是向上转型
        Animal a=new Cat();
        a.eat(); //输出：猫吃鱼
        //a.playgame; 会报错

        //向下转型
        Cat cat=(Cat) a;
        cat.eat();     //输出：猫吃鱼
        cat.playgame();//输出：猫追迷藏
    }
}

5. 小案例应用

public class Animal {
    private int age;
    private String name;
    public Animal(){}
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

public class Cat extends Animal{
    public Cat(){}
    public Cat(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playgame(){
        System.out.println("猫追迷藏");
    }
}

public class Demo {
    public static void main(String[] args) {
        //这就是向上转型
        Animal a=new Cat("加菲猫",5);
        System.out.println(a.getName()+" "+a.getAge()); // 输出：加菲猫 5
    }
}