多态

什么是多态
同一个对象，在不同时刻表现出来的不同形态
多态的前提条件
要有继承/实现关系
要有方法重写
要有父类引用指向子类对象
需求：
定义一个Animal类，提供成员变量和成员方法
定义一个Cat类，提供成员变量和成员方法，并重写父类方法
多态形式创建对象，查看成员访问特点
Animal类

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

Cat类

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

创建对象

/*
    多态：
        同一个对象，在不同时刻表现出来的不同形态

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

    多态的前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal c = new Cat();
    }
}

多态的好处
提高了代码的扩展性。
定义方法时，如果将父类型作为参数，在使用方法时，可以传递任意子类对象
多态的弊端
不能使用子类特有的成员

需求：
定义一个Animal父类，提供eat方法
定义Dog、Cat、Pig三个子类，分别重写eat方法
定义AnimalOperator类，提供use方法。将Animal作为参数
定义测试类，创建不同子类对象，并调用use方法

Animal父类

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
    public void look() {
        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("猪吃白菜");
    }

    @Override
    public void look() {
        System.out.println("我不看");
    }
}

public class AnimalOperator {
    public void useAnimal(Animal an) {
        an.eat();
        an.look();
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        //创建动物操作类的对象，调用方法
        AnimalOperator an = new AnimalOperator();
        Cat c = new Cat();
        an.useAnimal(c);
        Dog d = new Dog();
        an.useAnimal(d);
        Pig p = new Pig();
        an.useAnimal(p);
    }
}

执行结果：
看过来
狗吃骨头
看过来
猪吃白菜
我不看

多态的向上转型和向下转型
多态中的向上转型
父类引用指向子类对象其实就是向上转型。例如：
Animal a = new Dog();
多态中的向下转型
将父类型的引用转换成具体的子类对象。转换格式：
子类 对象名 = (子类)父类引用;

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 AnimalDemo {
    public static void main(String[] args) {
        //多态   父类引用指向子类对象
        Animal a =new Cat();// 向上转型
        a.eat();
//        向下转型
//                从父到子
//        父类引用转为子类对象
        Cat c =(Cat)a;
        c.playGame();
        c.eat();

    }
}

猫吃鱼
猫捉迷藏
猫吃鱼

练习
猫狗案例多态版重要步骤
1.定义Animal类，提供name和age成员变量。eat方法
2.定义Cat类，继承Animal类，重写eat方法
3.定义Dog类，继承Animal类，重写eat方法
4.通过多态创建对象，并给属性赋值，调用方法

public class Animal {
    private String name;
    private  int age;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    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 class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

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

/*
测试类
 */
public class Demo {
    public static void main(String[] args) {
        //多态 创建猫对象
        Animal a =new Cat("加肥猫",5);
        System.out.println(a.getName()+","+a.getName());
        a.eat();
        System.out.println("========");

        //多态 创建狗对象
        Animal a1 =new Dog("哈士奇",3);
        a1.eat();
        System.out.println(a1.getName()+a1.getAge());
        /*
        加肥猫,加肥猫
		猫吃鱼
		========
		狗吃骨头
		哈士奇3
        */
    }
}