向上转型

• 演示向上造型

• 其实向上造型是多态的一种实现方式

• 父类（接口）的引用可以指向子类的对象，展现出来的是父类（接口）的功能
• 子类的引用变量可以指向子类的对象，展现出来的是子类的功能

• 子类对象可以展现出多态的实现

• 格式：

• 父类类型 变量名 = new 子类的对象（）；
• 接口名称 对象名 = new 实现类名称（）；

• 变量名.方法名（） - 父类当中的

• 当多态出现以后，调用的方法是子类重写后的方法

• 多态的使用场景：

• 1.为变量复制的时候使用多态，达到父类的引用指向子类的对象，直接为变量赋值
• 2.调用方法的时候，为方法的参数进行赋值

• 3.方法的返回值，可以定义为父类的类型，但是返回的是子类的对象。当该方法被调用后，用父类的类型接收

• 多态的好处：

• 1.大大提高了程序的拓展性
• 2.提高了程序的复用性

解决造型异常的方案：
使用一个instanceof关键字来判断对象是不是属于这个类型
最后会返回true或者false，进行了对象的判断后就可以保证不出异常

父类 - 动物类：

/**
 * 父类 - 动物类
 *
 * 用于展示多态的抽象方法
 */
package Test13_Demo.Demo08;/*
    @create 2020--12--01--15:15
*/
public abstract class Animal {
    //普通方法
    public void eat() {
        System.out.println("吃饭");
    }
    //抽象方法
    public abstract void sleep();
}

狗类 - 子类（具体类）：

/**
 *
 * 狗类 - 子类（具体类）
 *
 * 用于展示多态的实现
 * 再父类的共性功能外，有自己学习工作的方法
 */
package Test13_Demo.Demo08;/*
    @create 2020--12--01--15:17
*/
import Test13_Demo.Demo07.Animal;
public class Dog extends Animal {
    @Override
    public void sleep() {
        System.out.println("睡在地上");
    }
    //拓展子类自己的方法
    //工作的方法
    public void work() {
        System.out.println("千里无极，万里追踪");
    }
    //重写父类方法
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

人类 - 子类（具体类）：

/**
 *
 * 人类 - 子类（具体类）
 *
 * 用于展示多态的实现
 * 再父类的共性功能外，有自己学习工作的方法
 */
package Test13_Demo.Demo08;/*
    @create 2020--12--01--15:17
*/
import Test13_Demo.Demo07.Animal;
public class Person extends Animal {
    @Override
    public void sleep() {
        System.out.println("睡在床上");
    }
    //拓展子类自己的方法
    public void study() {
        System.out.println("study");
    }
    //工作的方法
    public void work() {
        System.out.println("work");
    }
    //重写父类方法
    @Override
    public void eat() {
        System.out.println("吃饭");
    }
}

测试类：

/**
 *
 * 演示向上造型
 *
 * 其实向上造型是多态的一种实现方式
 * 父类（接口）的引用可以指向子类的对象，展现出来的是父类（接口）的功能
 * 子类的引用变量可以指向子类的对象，展现出来的是子类的功能
 * 子类对象可以展现出多态的实现
 *
 * 格式：
 * 父类类型 变量名 = new 子类的对象（）；
 * 变量名.方法名（） - 父类当中的
 *
 * 当多态出现以后，调用的方法是子类重写后的方法
 *
 * 多态的使用场景：
 * 1.为变量复制的时候使用多态，达到父类的引用指向子类的对象，直接为变量赋值
 * 2.调用方法的时候，为方法的参数进行赋值
 * 3.方法的返回值，可以定义为父类的类型，但是返回的是子类的对象。当该方法被调用后，用父类的类型接收
 *
 * 多态的好处：
 * 1.大大提高了程序的拓展性
 * 2.提高了程序的复用性
 */
package Test13_Demo.Demo08;/*
    @create 2020--12--01--15:21
*/
import Test13_Demo.Demo07.Animal;
import Test13_Demo.Demo07.Person;
public class SubClassType {
    public static void main(String[] args) {
        //创建子类对象
        Person p = new Person();
        p.eat();
        p.sleep();
        p.work();
        p.study();
        //使用向上造型
        Animal a = new Person();
        //调用的父类中的方法，但是结果是子类中重写后的结果
        a.eat();
        a.sleep();
        /*a.work(); 调用不到*/
        System.out.println("---------拓展----------");
        //调用feed方法
        feed(new Person());//传入Animal的子类对象
        feed(new Dog());//传入Animal的子类对象
        /*feed(new Animal();//Animal是一个抽象类不能实例化*/
    }
    //封装一个方法，用于灵活的调用所有的方法 - 传入参数是一个父类
    public static void feed(Animal a) { //a是animal的引用，可以接收animal中所有的子类对象
        //调用该动物吃饭的方法
        System.out.println("feed方法内动物吃饭的方法被调用了");
        a.eat();
    }
}