（java总结）多态

怼烎@ 2023-05-29 03:29 21阅读 0赞

package Demo16;
    /*
    代码中体现了多态性，其实就是一句话，父类引指向子类对象。
    格式：
    父类名称 对象名 = new 子类名称();
    或者：
    接口名称 对象名 = new 实现类名称();
    
     */
    public class DemoMulti {
        
        public static void main(String[] args) {
        
            //使用多态的写法
            //左侧父类的引用，指向右侧子类的对象
    
            Fu obj = new Zi();
    
            obj.method();
            obj.methodFu();
        }
    }

package Demo16;
    
    public class Fu {
        
        public void method(){
        
            System.out.println("父类方法");
        }
    
    
        public void methodFu(){
        
            System.out.println("父类特有方法");
        }
    }

package Demo16;
    
    public class Zi extends Fu{
        
        @Override
        public void method(){
        
            System.out.println("子类方法");
        }
    
    }

package Demo16;
    /*
    访问成员变量的两种方式
    1、直接通过对象名称访问成员变量，看等号左边是谁，优先用谁。
    2、直接通过成员方法访问
    */
    public class DemoMultifield {
        
        public static void main(String[] args) {
        
            //使用多态的写法，父类引用指向子类对象
            Fu01 obj = new Zi01();
            System.out.println(obj.num);
    
        }
    }

package Demo16;
    
    public class Fu01 {
        
        int num = 10;
    }

package Demo16;
    
    public class Zi01 extends Fu01 {
        
        int num = 20;
    }

package Demo17;
    
    public abstract class Animal {
        
        public abstract void eat();
    }

package Demo17;
    
    public class Cat extends Animal {
        
        @Override
        public void eat() {
        
            System.out.println("猫吃鱼");
        }
    
        public void catchMouse(){
        
            System.out.println("猫捉老鼠！");
        }
    }

package Demo17;
    /*
    对象的向上转型，其实就是堕多态的写法：
    格式：父类名称 对象名 = new 子类名称();
    含义：右侧创建一个子类对象，把它当作父类来看待使用。
    向上转型一定是安全的，没有问题，但是有一个弊端，
    对象向上转型一旦成功，那么就五大调用子类元本特有的内容
    Animal animal = new Cat();
    创建了一只猫，当作动物看待
    
    对象的向下转型，其实就是一个还原的动作。
    格式： 子类名称 对象名 = (子类名称)父类对象;
    含义： 将父类对象，还原成本来的子类对象
    Animal animal = new Cat();//本来是猫，向上转型成功
    Cat cat = (Cat) animal;//本来是猫，已经被当作成动物了，还原回来成为本来的猫
    注意事项：
    a、必须保证对象本来创建的时候就是猫，才能向下转型成为猫
    b、如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。
     */
    public class DemoMain {
        
        public static void main(String[] args) {
        
    //        //这是正常的
    //        Cat cat = new Cat();
    //        cat.catchMouse();
    //
    //
            //对象的向上转型，就是父类引用指向子类对象
            Animal animal = new Cat();
            animal.eat();
            //animal.catchMouse();//错误写法
    
            //向下转型，进行还原动作
            Cat cat = (Cat) animal;
        }
    }

package Demo17;
    /*
    如何才能知道一个父类引用的对象
     */
    public class DemoInstanceof {
        
        public static void main(String[] args) {
        
    
            //多态的方式创建对象，本来是一只猫，向上转型
            Animal animal = new Cat();
            animal.eat();
    
            //如果希望需要调用子类特有的方法，需要向下转型，
            //判断一下父类引用animal本来是不是Dog
            if(animal instanceof Cat){
        
                Cat cat = (Cat) animal;
                cat.catchMouse();
            }
    
    
        }
    }