Java-多态

多态的实例： 

package test8_polymorphic_demo2;

public class Test {
    public static void main(String[] args) {
        //创建对象（多态方式）
        //Fu f=new Zi();
        Animal a=new Dog();
        //动物    狗
        //调用成员变量：编译看左边，运行也看左边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有，编译失败。
        //运行也看左边：java运行代码的时候，世纪获取的就是左边父类中成员变量的值
        System.out.println(a.name);//动物   (就近原则)
        //调用成员方法：编译看左边，运行看右边
        a.show();//打印子类中的Dog--show();



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

        //成员变量：在子类的对象中，会把父类的成员变量也继承下的。父：name  子：name
        //成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。
    }


}


class Animal{
    String name="动物";

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

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

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

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

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

• 在多态形式下，有点对象可以实现解耦合，便于拓展和维护。

         

Person p=new Student();
//不想让学生对象来做，让教师对象来做，可以 改为 ：
Person p=new Teacher();

p.work();//业务逻辑发生改变时，后续代码无需修改

 1.多态的优势

        方法中，使用 父类型作为参数，可以接受所有子类 对象

2.多态的弊端是什么？

        不能使用子类的特有功能

3.引用数据类型的类型转换，有几种方式？

        自动类型转换、强制类型转换

Person p=new Student();
Student s=(Student) p;

 

4.强制类型转换能解决什么问题？

•  可以转换成真正的子类类型，从而调用子类独有功能。
•  转换类型与真实对象类型不一致会报错
•  转换的时候用instanceof关键字进行判断

//进行类型判断并转换（JDK新特性）
        if(a instanceof Dog d){
                          //JDK14以前：if(a instanceof Dog){Dog d=(Dog) a;}然后再进行方法调用
            d.lookHome();
        }else if(a instanceof Cat c){
            c.catchHouse();
        }else{
            System.out.println("没有这个类型，无法转换");
        }

具体实例看下方的代码（根据注释进行理解

package test8_polymorphic_demo3;

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

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

        //解决方案：
        //变回子类类型就可以了
        //细节 ：转换的时候不能瞎转，如果转成其他类的类型，就会报错。
        Dog dog=(Dog)a;//Cat c=(Cat)a;这种是错误的，用Animal类定义的Dog对象，怎么能转为猫类呢

        dog.lookHome();
        //进行类型判断并转换（JDK新特性）
        if(a instanceof Dog d){//JDK14以前：if(a instanceof Dog){Dog d=(Dog) a;}然后再进行方法调用
            d.lookHome();
        }else if(a instanceof Cat c){
            c.catchHouse();
        }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 catchHouse(){
        System.out.println("小猫捉老鼠");
    }
}

）：