面向对象4（多态，引用数据类型的转换）

一、多态

多态：
    对应同一指令(调用同一名称的方法)，不同的对象给予不同的反应(不同的方法实现)

    规则(多态实现的前提)：
        1.必须要有继承关系
        2.子类方法必须重写父类方法
        3.父类引用指向子类对象(子类实例)

    多态的目的：
        为了提高代码的扩展性和维护性
        方便代码逻辑的编写

    多态的两种表现形式：
        1.父类作为方法的参数
        2.父类作为方法的返回值类型

    引用类型的转换和基本类型的转换相似：
        1.当父类需要转成子类的时候，要进行强制转换，但是在强制转换之前一定要判断父类引用指向的子类到底是谁，
            如果无法确定，在运行过程中可能会出错
        2.当子类需要向父类转换的时候，直接自动转换，不需要进行任何的判断

代码演示：

方法法类：

package wangKe.kejian.day04;

/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/3/9 - 03 - 09 - 17:05
 * @Description: wangKe.kejian.day04
 * @version: 1.0
 */
public  abstract class Pet {
    //吃东西
    public abstract void feed();
}

父类：

package wangKe.kejian.day04;

/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/3/9 - 03 - 09 - 17:11
 * @Description: wangKe.kejian.day04
 * @version: 1.0
 */

public class Person {
    //    public  void feed(Dog dog){
//        dog.feed();
//    }
//    public void feed(Penguin penguin){
//        penguin.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();
        }
    }

    //main方法
    public static void main(String[] args) {

        Person person = new Person();

//        Dog dog =new Dog();
//        person.feed(dog);
//
//        Penguin penguin = new Penguin();
//        person.feed(penguin);

        Pet dog = new Dog();
        person.feed(dog);

        Pet penguin = new Penguin();
        person.feed(penguin);

        Pet cat = new Cat();
        cat.feed();

        Pet pet = person.getPet("1");
        if (pet instanceof Dog) {    //instanceof关键字作用是后者是否是前者的实例
            System.out.println("领养的是狗");
        } else if (pet instanceof Penguin) {
            System.out.println("领养的是企鹅");
        } else if (pet instanceof Cat) {
            System.out.println("领养的是猫");
        }
    }
}

子类：

package wangKe.kejian.day04;

/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/4/1 19:40
 * @Description: wangKe.kejian.day04
 * @version: 1.0
 */
public class Cat extends Pet {
    @Override
    public void feed() {
        System.out.println("猫正在吃苹果... ...");
    }
}

package wangKe.kejian.day04;

/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/3/9 - 03 - 09 - 17:06
 * @Description: wangKe.kejian.day04
 * @version: 1.0
 */
public class Dog extends Pet {
    @Override
    public void feed() {
        System.out.println("狗在吃骨头... ...");
    }
}

package wangKe.kejian.day04;

/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/3/9 - 03 - 09 - 17:09
 * @Description: wangKe.kejian.day04
 * @version: 1.0
 */
public class Penguin extends Pet{
    @Override
    public void feed() {
        System.out.println("企鹅正在吃鱼... ...");
    }
}

二、引用数据类型的转换

1、子类转换为父类：自动转换

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

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

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

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

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

代码演示：

package netclass05;
 
/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/1/12 - 01 - 12 - 17:12
 * @Description: netclass05
 * @version: 1.0
 */
public class Father {
 
    public void print(){
        System.out.println("father print... ...");
    }
 
}

package netclass05;
 
/**
 * @Auther: Shi Kaixuan
 * @Date: 2022/1/12 - 01 - 12 - 17:12
 * @Description: netclass05
 * @version: 1.0
 */
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();
    }
}