在代码中理解什么是多态

public class Test {
    public static void main(String[] args) {
        //创建对象(多态方式)
        //Fu f = new Zi();
        Animal a = new Dog();
        //调用成员变量:编译看左边,运行也看左边
        //编译看左边:javac编译代码的时候,会看左边的父类中有没有这个变量,如果有,编译成功,如果没有,编译失败
        //运行也看左边:java运行代码的时候,实际获取的就是左边父类中的成员变量的值
        System.out.println(a.name);//动物

        //调用成员方法:编译看左边,运行看右边你
        //编译看左边:javac编译代码的时候,会看左边的父类中有没有这个方法,如果有,编译成功,如果没有,编译失败
        //运行看右边:java运行代码的时候,实际上运行的是子类中的方法.
        a.show();//Dog --- show方法


        //理解:
        //Animal a = new Dog();
        //现在用a去调用变量和方法的?是的
        //而啊是Animal类型的,所以默认都会从Animal这个类中去找

        //成员变量:在子类的对象中,会把父类的成员变量也继承下来的.父:name 子:name
        //成员方法:如果子类对方法进行了重写,name在虚方法表中是会把父类的方法进行覆盖的.


    }

}


class Animal{
    String name = "动物";

    public void show(){
        System.out.println("Animal --- show方法");
    }
}


class Dog extends Animal{
    String name = "狗";

    @Override
    public void show(){

        System.out.println("Dog --- show方法");
    }
}


class Cat extends Animal{
    String name ="猫";

    @Override
    public void show(){

        System.out.println("Cat --- show方法");
    }
}

总结:
      1.多态的优势
           方法中,使用父类型作为参数,可以接收所有子类对象
      2.多态的弊端
           不能使用子类的特有功能
      3.引用数据类型的类型转换有几种方式?
           自动类型转换,强制类型转换
           Person p = new Student();
           Student s = (Student)p;

      4.强制类型转换能解决什么问题?
           可以转换成真正的子类类型,从而调用子类独有功能
           转换类型与真实对象类型不一致会报错
           转换的时候用过instanceof关键字进行判断

public class Test {
    public static void main(String[] args) {
        //创建对象
        Animal a = new Dog();
        //编译看左边,运行看右边
        a.eat();

        //多态的弊端
        //不能调用子类的特有功能(Dog里面的lookHome和Cat里面的)
        //a.lookHome
        //报错的原因?
        //当调用成员方法的时候,编译看左边,运行看右边
        //那么在编译的时候会先检查左边的父类中有没有这个方法,如果没有直接报错


        //解决方案
        //变回子类类型就可以了
         // b = 10;
         //byte c =(byte) b;
        //细节:转换的时候不能瞎转,如果转成其他类型,就报错
        //Dog d = (Dog) a;
        //d.lookHome();

        //Cat c = (Cat) a;
        //c.catchMouse();

        /*if (a instanceof Dog){      //a :变量名 Dog :类名   a这个变量所记录的对象是不是dog类型
            Dog d = (Dog) a;
            d.lookHome();
        }else if(a instanceof Cat){
            Cat c = (Cat) a;
            c.catchMouse();
        }else{
            System.out.println("没有这种类型,无法转换");
        }*/



        //新特性
        //先判断a是否为Dog类型,如果是,则强转成Dog类型,转换之后变量名为d
        //如果不是,则不强转,结果直接是false
        if (a instanceof Dog d){

            d.lookHome();
        }else if(a instanceof Cat c){

            c.catchMouse();
        }else{
            System.out.println("没有这种类型,无法转换");
        }




    }
}

class Animal{

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


class Dog extends Animal{

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

    public void lookHome(){
        System.out.println("狗看家");
    }
}

class Cat extends Animal{

    @Override
    public void eat(){
        System.out.println("猫吃小鱼干");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

/*
* 总结:
*       1.多态的优势
*           方法中,使用父类型作为参数,可以接收所有子类对象
*       2.多态的弊端
*           不能使用子类的特有功能
*       3.引用数据类型的类型转换有几种方式?
*           自动类型转换,强制类型转换
*           Person p = new Student();
*           Student s = (Student)p;
*
*       4.强制类型转换能解决什么问题?
*           可以转换成真正的子类类型,从而调用子类独有功能
*           转换类型与真实对象类型不一致会报错
*           转换的时候用过instanceof关键字进行判断
*
*       面试题:多态当中,如果想要使用子类独有功能,该怎么办
*
*         回答:在多态当中,是不能使用子类独有功能的,如果一定要用,我们要做强转,
*              在强转的时候,转换类型与真实对象类型不一致会报错,所有转换的时候用过instanceof关键字进行判断
*
* */

面试题:多态当中,如果想要使用子类独有功能,该怎么办

         回答:在多态当中,是不能使用子类独有功能的,如果一定要用,我们要做强转,
             在强转的时候,转换类型与真实对象类型不一致会报错,所有转换的时候用过instanceof关键字进行判断