【Java基础】- 多态

1. 多态

1.1 多态概念

同一对象在不同时刻的不同形态

多态需要有3个前提/体现

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

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 cat = new cat();
    }
}

1.2 多态中成员访问的特点

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

public class Cat extends Animal {
    public int age=20; //age为20
    public int weight=10;

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

    public void playGame(){
        System.out.println("猫玩游戏...");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal cat = new Cat();
        System.out.println(cat.age); // Animal里的age是40，Cat继承Animal里面的age是20;输出是40，是Animal里的值
        cat.eat(); //调用的是Cat类的eat方法
        //System.out.println(cat.playgame()}; // 不能调用Cat类里的新增方法playGame
    }
}

输出结果：
40
猫吃鱼...

Process finished with exit code 0   

为什么age是40？

    //父类引用指向子类对象
    Animal cat = new Cat();

因为:

在多态中，子类Cat继承父类Animal

成员变量age在Cat和Animal中都有

在子类Cat中重写了eat方法，新增了playGame方法

多态访问中，

成员变量:编译看左边的Animal类，执行也看左边的Animal类

成员变量:编译看左边的Animal类，执行看右边的Cat类。

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

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

1.3 多态的好处与短处

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(Cat cat){
        cat.eat();
    }
    public void useAnimal(Dog dog){
        dog.eat();
    }
}

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);

    }
}

上述代码中，Cat、Dog继承Animal类，重写了eat方法。

有一个操作类AnimalOperator，添加对应Cat、Dog的操作方法

如果，再添加一个类Pig继承Animal类，那么操作类AnimalOperator就要添加对应Pig的操作方法。

如果一直添加类x，继承Animal类，操作类AnimalOperator每次就要添加x对应操作方法。

这就很麻烦。使用多态既可以解决这个问题。

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 Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("猪吃剩饭...");
    }
}

public class AnimalOperator {
//    public void useAnimal(Cat cat){
//        cat.eat();
//    }
//    public void useAnimal(Dog dog){
//        dog.eat();
//    }

    public void useAnimal(Animal a){ // 父类作为引用类型，传入具体子类
        a.eat();
    }
}

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(c);
        ao.useAnimal(d);
        ao.useAnimal(p);
    }
}

输出：
猫吃鱼...
狗吃骨头...
猪吃剩饭...

使用多态后，操作类AnimalOperator 可以传任何继承Animal类的子类，不需要添加对应的操作类。

总结：

• 多态的好处：

  提高了程序的拓展性，在方法定义中，使用父类型作为参数，具体子类参与操作

• 多态的短处：

  不能使用子类新增的方法。（只能是重写父类的方法）