java多态的理解

 1.多态的概念

       多态性是指允许不同类的对象对同一消息作出响应，多态性包括参数化多态性和包含多态性，多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

前提：

（1）要有继承关系
（2）子类要重写父类的方法
（3）父类的引用指向子类的对象（向上转型：子类自动转换为父类）

实质：父类引用指向子类对象

 

2.多态的使用

格式：

父类名称 对象名 = new 子类名称（）；

或者

 接口名称 对象名 = new 实现类名称（）；

 

3.简单示例（引用：https://www.zhihu.com/question/30082151?sort=created）

3.1 创建几个类，如下图

 

 Cat类和Dog类继承Animal类

3.2 代码

Animal类

package 多态;

public class Animal {

    int num = 10;
    static int age=20;
    
    public void eat()
    {
        System.out.println("动物吃饭");
    }
    
    public static void sleep()
    {
        System.out.println("动物睡觉");
    }
    
    public  void run()
    {
        System.out.println("动物在奔跑");
    }
    
}

Cat类

package 多态;

public class Cat extends Animal{

    int num = 80;
    static int age = 90;
    
    String name="tomcat";
    
    //重写父类的方法
    public void eat() {
        System.out.println("猫吃饭");
    }
    
    //重写父类的静态方法
        public static void sleep() {
        System.out.println("猫在睡觉" );
        }
        
        
        public void catchMouse() {
        System.out.println("猫在抓老鼠"); 
        }
    
    
    
}

Dog类

package 多态;

public class Dog extends Animal{

    String name="dongdong";
    
    public void eat()
    {
        System.out.println("dongdong在吃饭");
    }
}

Demo_Test类

package 多态;
public class Demo_Test {

    
    public static void main(String[] args) {
        /*多态条件1：要有继承关系
         * 多态条件2：子类要重写父类的方法
         * 多态条件3：父类的引用指向子类的对象（向上转型：子类自动转换为父类）
         */
        Animal animal = new Cat();

        //结论1：非静态方法，编译看左边(父类)，运行看右边(子类)。动态绑定
        animal.eat(); 
        
        //结论2：静态方法，编译看左边(父类)，运行看左边(父类)。
        animal.sleep();
        
    
        
        //结论3：成员变量，编译看左边(父类)，运行看左边(父类)。
        System.out.println(animal.num);
        System.out.println(animal.age);
        
        //多态的弊端：不能使用子类特有的成员属性和子类特有的成员方法。
        animal.run();//可以访问父类的方法
        //animal.catchMouse();//这个父类指向子类对象的引用无法访问子类特有的方法
        
        //如果父类的引用需要访问子类的属性和方法
        //多态优点1：减少了多余对象的创建
        Cat cat2 = (Cat)animal;//（向下转型：需要强制转换）  
        
        /*
        cat2.eat();
        cat2.sleep();
        cat2.catchMouse();
        cat2.run();
        */

        //子类对象替代父类引用为形参的方法
        GeneralEat(new Cat());
        GeneralEat(new Dog());
        
      
    }
    /*多态的优点2：减少了方法的编写，方法的形式参数为父类引用，
     * 实参可以是父类的所有子类对象,提高了程序的扩展性*/
    public static void GeneralEat(Animal a) 
        {
            a.eat();
            
            if(a instanceof Cat)
            {
                Cat cat = (Cat)a;
                cat.eat();
            }
            
            if(a instanceof Dog)
            {
                Dog dog = (Dog)a;
                dog.eat();
            }
        }
        
        //上面的GeneralEat()方法相当于以下2个方法的作用，且扩展更灵活
        public static void GeneralEat(Cat cat) 
        {
            cat.eat();
        }
        
        public static void GeneralEat(Dog dog) 
        {
            dog.eat();
        }
        
}

运行结果：

 

 

 

参考文章：

https://www.zhihu.com/question/30082151?sort=created

https://www.cnblogs.com/AceIsSunshineRain/p/5058375.html