面向对象5-多态、instanceof用法、引用数据类型的转换

1、宠物饿了，需要主人给宠物喂食

        ---- 不同宠物吃的东西不一样

        ---- 不同宠物恢复后体力值不一样

        ---- 狗狗类

        增加狗狗吃东西的方法

        ---- 企鹅类

        增加企鹅吃东西的方法

        ---- 创建主人类

        编写给狗狗喂东西的方法

        编写给企鹅喂东西的方法

        ---- 编写测试方法

        调用主人类给狗狗喂东西的方法

        调用主人类给企鹅喂东西的方法

2、如果再领养XXX宠物，就需要给XXX喂食，怎么办？

        ---- 添加XXX类，继承Pet类，实现吃食方法

        ---- 修改Person类，添加给XXX喂食的方法

二、什么是多态？
三、如何实现多态？
四、instanceof运算符
1、课堂Demo【重点掌握】

Pet.java

package netclass05;
 

public abstract class Pet {
 
    //吃东西
    public abstract void feed();
 
    public void show(){
        System.out.println("show... ...");
    }
}
Dog.java

package netclass05;
 

public class Dog extends Pet{
 
    @Override
    public void feed() {
        System.out.println("狗在吃骨头... ...");
    }
 
    public void test(){
        System.out.println("test... ...");
    }
}
Penguin.java

package netclass05;
 

public class Penguin extends Pet{
    @Override
    public void feed() {
        System.out.println("企鹅正在吃鱼... ...");
    }
}
Cat.java

package netclass05;
 

public class Cat extends Pet{
    @Override
    public void feed() {
        System.out.println("猫正在吃苹果... ...");
    }
}
主人类：Person.java

package netclass05;
 

 
/*
 * 多态：
 *       对应同一个指令（调用同一个名称的方法），不同的对象给予不同的反应（不同的方法实现）
 *   规范(多态实现的前提)：
 *       1、必须要有继承关系
 *       2、子类方法必须重写父类的方法
 *       3、父类引用指向子类对象（子类实例）
 *   多态的目的：
 *       1、为了提高代码的扩展性和维护性
 *       2、方便代码逻辑的编写
 *   多态的两种表现形式：
 *       1、父类作为方法的参数
 *       2、父类作为方法的返回值类型
 *
 *   引用类型的转换跟基本数据类型的转换类似：
 *       1、当父类需要转成子类的时候，要进行强制转换，但是在强制转换之前一定要先判断父类引用指向的子类对象到底是谁，
 *            如果无法确定，在运行过程中可能出错
 *       2、当子类需要向父类转换的时候，直接自动转换，不需要进行任何的判断。
 *
 * */
public class Person {
 
//    public void feed(Dog dog){
//        dog.feed();
//    }
//
//    public void feed(Penguin p){
//        p.feed();
//    }
 
    public void feed(Pet pet){
        pet.feed();
    }
 
    public Pet getPet(String typeId){
        if(typeId.equals("0")){
            return new Dog();
        }else if(typeId.equals("1")){
            return new Penguin();
        }else{
            return new Cat();
        }
    }
 
    public static void main(String[] args) {
//        Person person = new Person();
//        Dog dog = new Dog();
//        person.feed(dog);
//        Penguin penguin = new Penguin();
//        person.feed(penguin);
 
        Person person = new Person();
        Pet dog = new Dog();
        person.feed(dog);
//        dog.test();
        dog.show();
        Pet penguin = new Penguin();
        person.feed(penguin);
        Cat cat = new Cat();
        person.feed(cat);
 
        Pet pet = person.getPet("1");
        if(pet instanceof Dog){
            System.out.println("领养的是狗");
        }else if(pet instanceof Penguin){
            System.out.println("领养的是企鹅");
        }else if(pet instanceof Cat){
            System.out.println("领养的是猫");
        }
    }
}
五、引用数据类型的转换
1、子类转换为父类：自动转换

        ---- 上转型对象不能操作子类新增的成员变量和方法。

        ---- 上转型对象可以操作子类继承或重写的成员变量和方法。

        ---- 如果子类重写了父类的某个方法，上转型对象调用该方法时，是调用的重写方法。

2、父类转换为子类：强制转换

        ---- 编译阶段不会出错，运行阶段会出错。

3、课堂Demo【重点掌握】

Father.java

package netclass05;
 

public class Father {
 
    public void print(){
        System.out.println("father print... ...");
    }
 
}
SubClass.java

package netclass05;
 

public class SubClass extends Father {
 
    @Override
    public void print(){
        System.out.println("subclass print... ...");
    }
 
    public static void main(String[] args) {
//        Father f = new SubClass();   //向上转型  自动转换
//        f.print();
//        SubClass sub = (SubClass) new Father();  //向下转型（强制转换）
//        sub.print();
        Father f = new Father();
        SubClass s = (SubClass) f;
        s.print();
    }
}
六、小结
1、类型转换

        ---- 向上转型——子类转换为父类，自动进行类型转换

        ---- 向下转型——父类转换为子类，结合instanceof运算符进行强制类型转换

2、实现多态的两种方式

        ---- 使用父类作为方法形参实现多态

        ---- 使用父类作为方法返回值实现多态

3、使用多态的好处

        多态可以减少类中代码量，可以提高代码的可扩展性和可维护性

4、引用变量的两种类型：

        ---- 编译时类型（模糊一点，一般是一个父类）

              由声明时的类型决定。

        ---- 运行时类型（运行时，具体是哪个子类就是哪个子类）

              由实际对应的对象类型决定。

5、多态的存在要有3个必要条件：

        要有继承，要有方法重写，父类引用指向子类对象