面向对象的三大特征--多态

ゝ一世哀愁。 2023-10-07 18:25 29阅读 0赞

>     1，多态的形式：
>     *      对象类型  对象名称 =  new 子类构造器
>     *      接口     对象名称  =  实现类构造器
>     *
>     *  父类类型的范围 > 子类类型的范围
>     *
>     *2，多态的概念：
>     *      在同一类型的对象(Animal)，执行同一个行为(run())，在不同状态下的表现出不同的行为*        特征(狗跑，猫跑)
>     *
>     *3，多态的识别技巧
>     *      >对于方法的调用：编译看左边，运行看右边   编译左边（Animal中有没有run()）,运行*        右边（Dog,Cat中的run()）
>     *      >对于变量的调用：编译看作左边，运行也看左边 (调用Animal中的变量)
>     *4，多态的使用前提：
>     *      >必须存在继承或者实现关系
>     *      >>必须存在父类类型的变量引用子类类型的对象 Animal a = new Cat()；父类类型的变**        量(a) 引用(=) 子类类型的对象(new Cat())
>     *      >需要存在方法重写
>     *5，多态的优劣势：
>     *    优势：
>     *      1，在多态形势下，右边对象可以实现组件化切换，业务功能也随之改变
>     *          便于维护和扩展，可以实现类与类之间的解耦
>     *      2，实际开发的过程中，父类类型作为方法形式传参，传递子类对象给方法
>     *          可以传入一切子类对象进行方法的调用，更能体现出堕胎的扩展性与便利
>     *    劣势：
>     *      在多态形势下，不能直接调用子类特有功能，编译看左边，左边父类没有子类独有的功能，*        代码在编译阶段直接报错
>     *
>     *6，引用类型的类型转换:
>     *      1,引用类型的自动类型转换
>     *          >小范围的对象赋值给大范围的变量
>     *          >小范围的变量赋值给大范围的变量
>     *      2,引用类型的强制转换(调用子类非重新写父类的方法)
>     *          >引用类型强制转换语法
>     *              父类类型的变量或者对象必须强制类型转换为子类类型的变量，否则报错
>     *          >强制转换的格式
>     *              类型 变量名称 = (类型)(对象/变量)
>     *        注意：有继承/实现关系的两个类型就可以进行强制转换，编译阶段一定不会报错
>     *              但运行阶段可能出现ClassCastException类型转换异常
>     *        解决方法：在进行强制类型转换之前先判断变量的真是类型，再强制类型转换
>     *              变量 instanceof 类型：判断前面的变量是后面的类型或者其子类类型

public class DemoPolmorphic01 {
        public static void main(String[] args) {
            //父类类型 对象名称 = new 子类构造器
            Animal animalCat = new Cat();
            animalCat.run();//猫跑 编译看左边，运行看右边   编译左边（
            System.out.println(animalCat.name);//动物 编译看作左边，运行也看左边
            
            //1,引用类型的自动类型转换:小范围的对象赋值给大范围的变量
            Animal animalDog = new Dog();
            //a.LookDoor();错误
            
            //2,引用类型的自动类型转换：小范围的变量赋值给大范围的变量
            Cat a = new Cat();
            Animal a1 = a;
            
            go(animalDog);
            go(animalCat);
            
            //引用类型的强制类型转换 把动物类型的dog，转换成真正的狗类型(调用子类非重新写父类的方法)
            Dog d = (Dog) animalDog;//Animal dog = new Dog();
            d.eatGuTou();
            
            //多态下类型转换异常
            //Animal cat = new Cat();
            //Dog d = (Dog) cat; //编译阶段不会报错，运行阶段出现ClassCastException类型转换异常
            
            //类型判断
            if (animalCat instanceof Cat){//Animal animalCat = new Cat();
                Cat c1 = (Cat) animalCat;
                c1.eatFish();
            }else if(animalCat instanceof Dog){//Animal animalDog = new Dog();
                Dog d1 = (Dog) animalCat;
                d1.eatGuTou();
            }
        
        }
        
        public static void go(Animal d){//相比较 Dog d/Cat c
            System.out.println("go");
            d.run();
            System.out.println("end");
        }
    }
    
    class Animal{
        public String name = "动物";
        public void run(){
            System.out.println("动物");
        }
    }
    
    class Cat extends Animal{
        public String name = "喵喵";
        @Override
        public void run() {
            System.out.println("猫跑");
        }
        public void LookDoor(){
            System.out.println("看家");
        }
        public void eatFish(){
            System.out.println("吃鱼");
        }
    }
    
    class Dog extends Animal{
        public String name = "汪汪";
        @Override
        public void run() {
            System.out.println("猫跑");
        }
       public void eatGuTou(){
           System.out.println("吃骨头");
       }
    }