Java多态大白话

多态简介

多态:
  指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定
   而在程序运行期间才确定
==========================================================================================
即一个引用变量倒底会指向哪个类的实例对象
  该引用变量发出的方法调用到底是哪个类中实现的方法
  必须由程序运行期间才能决定
  只有当程序运行时才确定具体的类
  采用这种方式，即可实现不改变源代码时，使对象拥有不同的行为
==========================================================================================
  使一个程序具有多种行为形态,我们将这种情况称之为"多态"
 

多态实现的条件

如:
  子类Child继承父类Father
  我们可编写一个指向子类的父类类型引用
   该引用既可以处理父类Father对象
    也可以处理子类Child对象
    当相同的消息发送给子类或父类对象时
      该对象就会根据自身的引用而运行不同的行为
      这就是多态

Java实现多态有三个必要条件:
 继承、重写、向上转型
  继承:在多态中必须存在有继承关系的子类和父类。
  重写:子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
  向上转型:在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
 当满足上述三个条件
   才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象
   从而达到运行不同的行为

多态的实现示例

基于继承实现的多态

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

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

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

      当父类是抽象类
      则子类必须要实现父类中所有的抽象方法
     这样该父类所有的子类一定存在统一的对外接口
     但其内部的具体实现可以不同

基于接口实现的多态
  继承:
    是通过重写父类的同一方法的几个不同子类来体现的
	 那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。
  在接口的多态中
     指向接口的引用必须是指定这实现了该接口的一个类的实例程序
	 在运行时，根据对象引用的实际类型来执行对应的方法。
  继承都是单继承
     只能为一组相关的类提供一致的服务接口
	 但是接口可以是多继承多实现
	 它能够利用一组相关或者不相关的接口进行组合与扩充
	 能够对外提供一致的服务接口
	 所以它相对于继承来说有更好的灵活性。

多态经典示例

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{

}

public class D extends B{

}

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

//运行以上代码,将输出以下信息
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D