[JAVA]多态的实现

太过爱你忘了你带给我的痛 2022-03-12 19:28 203阅读 0赞

## 1.实现条件 ##

其实，继承是在为多态的实现做了准备。子类Child继承父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类Father对象，也可以处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。

Java实现多态有三个必要条件：继承、重写、向上转型。

*  继承：在多态中必须存在有继承关系的子类和父类。
 *  重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
 *  向上转型：在多态中需要将**子类的引用赋给父类对象**，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，**被引用对象的类型**而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

--------------------

## 2.实现形式 ##

在Java中有两种形式可以实现多态。继承和接口。

### 2.1基于继承实现的多态 ###

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，**多个子类对同一方法的重写可以表现出不同的行为**。

public class Wine { 
        private String name;
        
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Wine(){ }
        
        public String drink(){ 
            return "喝的是 " + getName();
        }
        
        /** * 重写toString() */
        public String toString(){ 
            return null;
        }
    }
    
    //剑南春
    public class JNC extends Wine{ 
        public JNC(){ 
            setName("JNC");
        }
        
        /** * 重写父类方法，实现多态 */
        public String drink(){ 
            return "喝的是 " + getName();
        }
        
        /** * 重写toString() */
        public String toString(){ 
            return "Wine : " + getName();
        }
    }
    
    //酒鬼酒
    public class JGJ extends Wine{ 
        public JGJ(){ 
            setName("JGJ");
        }
        
        /** * 重写父类方法，实现多态 */
        public String drink(){ 
            return "喝的是 " + getName();
        }
        
        /** * 重写toString() */
        public String toString(){ 
            return "Wine : " + getName();
        }
    }
    
    public class Test { 
        public static void main(String[] args) { 
            //定义父类数组
            Wine[] wines = new Wine[2];
            //定义两个子类
            JNC jnc = new JNC();
            JGJ jgj = new JGJ();
            
            //父类引用子类对象
            wines[0] = jnc;
            wines[1] = jgj;
            
            for(int i = 0 ; i < 2 ; i++){ 
                System.out.println(wines[i].toString() + "--" + wines[i].drink());
            }
            System.out.println("-------------------------------");
    
        }
    }

OUTPUT:
    Wine : JNC--喝的是 JNC
    Wine : JGJ--喝的是 JGJ

在上面的代码中JNC、JGJ继承Wine，并且重写了drink()、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不同的对象可以执行相同的行为，但是他们都需要通过自己的实现方式来执行，这就要得益于**向上转型**了。

我们都知道所有的类都继承自超类Object，toString()方法也是Object中方法，当我们这样写时：

Object o = new JGJ();  // 向上转型
    
    System.out.println(o.toString());

输出的结果是Wine : JGJ。

Object、Wine、JGJ三者继承链关系是：JGJ—>Wine—>Object。所以我们可以这样说：当子类重写父类的方法被调用时，**只有对象继承链中的最末端的方法才会被调用**。但是注意如果这样写：

Object o = new Wine(); 
    
    System.out.println(o.toString());

输出的结果应该是Null，因为JGJ并不存在于该对象继承链中。

所以基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

--------------------

## 2.2 基于接口实现的多态 ##