Java多态之向上转型-多态之向下转型

1-背景：

我忘记了，我回过头学servlet的目的就是掌握

2-过程：

多态之向上转型

多态就是方法的多态，不涉及属性

比如Animal a1 = new Dog();

Animal e1 = new Elephant();

父类的引用指向子类对象【这点不明白先去弄明白！】，实际开发中我们多用向上转型，但是向下转型也不是没有。

父类有一个属性id和一个eat方法
class Person {
    public int id = -1;
    public void eat() {
        System.out.println("人都要吃饭");
    }
}

子类
class Man extends Person {
    int id = 1;

    @Override
    public void eat() {
        System.out.println("男生吃饭大多粗鲁");
    }
}

class Woman extends Person {
    int id = 3;
    @Override
    public void eat() {
        System.out.println("女生吃饭大多文雅");
    }
}

public class UpTest {

    @Test
    public void test1() {
        func(new Man());
        func(new Woman());

    }
    public void func(Person p1) {
        // Person p1 = new Man();
        // Person p1 = new Woman();
        System.out.println(p1.id);
        p1.eat();
    }

    //如果没有多态性的话，只能这么写
//   public void func(Dog dog) {
//       dog.eat();
//       dog.shout();
//   }
//
//   public void func(Cat cat) {
//       cat.eat();
//       cat.shout();
//   }
}

结果如下【注意看文字内容】：

多态之向下转型

多态之向下转型（强制转型）--根据这个博客操作~~

向下转型就是子类引用指向父类对象，

比如：

Animal a1 = new Animal();

Dog d1 = new Dog();

Elephant1 = new Elephant1();

Elephant e1 = (Elephant) a1;【这样无问题】

但是为了避免d1 = (Elephant1)a1;这样的错误，即父类Animal可以强转为子类Elephant,但是Dog和Elephant这俩子类之间不能互相强制转换！！！！

我们决定引入instanceof关键字，

instanceof需要是子父类的关系才返回true

class Animal {

}

class Elephant extends Animal {
    public void magic() {
        System.out.println("象会大叫的魔法！");
    }
}

class Dog extends Animal {
    public void disk() {
        System.out.println("狗会接飞盘~~");
    }
}

class Master {
    public void playGame(Animal animal) {
        // 安全的向下转型是先把子类对象向上转型为父类，再将该父类强制转换为子类
        if (animal instanceof Elephant) {
            //向下转型为大象
            Elephant e1 = new Elephant();
            e1 = (Elephant) animal;
            e1.magic();
        }
        if (animal instanceof Dog) {
            //向下转型为狗
            Dog d1 = new Dog();
            d1 = (Dog) animal;
            d1.disk();

        }
    }
}

public class DownTest {
    @Test
    public void test1() {
        //直接将子类类型引用,指向父类类型会提示错误！！
        //java.lang.ClassCastException: com.atguigu.self.Animal cannot be cast to com.atguigu.self.Elephant
        //Elephant elephant1 = new Animal();
        // 改进一：编译不报错，但是运行报错
        //不安全的向下转型！！
        //Elephant cat = (Elephant)new Animal();

        //改进二：安全的向下转型[先把子类向上转型为父类，再将该父类强制转为子类]
        Animal a1 = new Elephant();
        Elephant e1 = (Elephant) a1;
        e1.magic();
    }


    @Test
    public void test2() {
        Master master = new Master();
        master.playGame(new Elephant());
        master.playGame(new Dog());

    }
}

结果如下【注意看视频，那个清晰~~】：

这是从内存角度的分析[看不懂不强求，慢慢来~~]

285.尚硅谷_面向对象(中)-向下转型的使用_哔哩哔哩_bilibili

3-结果

多态初学者搞不清楚很正常，静心找个视频从头来，

小心基础不牢-地动山摇！