三、java三大特性--多态

　　比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：

       酒 a = 剑南春

       酒 b = 五粮液

       酒 c = 酒鬼酒

       …

　　这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

　　要理解多态我们就必须要明白什么是“向上转型”。在继承中我们简单介绍了向上转型，这里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父类，剑南春（JNC）、五粮液（WLY）、酒鬼酒（JGJ）是子类。我们定义如下代码：

    JNC a = new JNC();

    对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛！但是这样呢？

    Wine a = new JNC();

    在这里我们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。由于JNC是继承与Wine，所以JNC可以自动向上转型为Wine，所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，它可以提供比父类更加强大的功能，如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。

    但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在与子类中的方法和属性它就望尘莫及了---1。

class Wine {
    public void fun1() {
        System.out.println("Wine 的Fun.....");
        fun2();
    }
    publi cvoid fun2() {
        System.out.println("Wine 的Fun2...");
    }
}
class JNC extends Wine {
    /**
     * @desc子类重载父类方法父类中不存在该方法，向上转型后，父类是不能引用该方法的
     * @param a
     * @return void
     */
    public void fun1(String a) {
        System.out.println("JNC 的 Fun1...");
        fun2();
    }
    /**
     * 子类重写父类方法指向子类的父类引用调用fun2时，必定是调用该方法
     */
    public void fun2() {
        System.out.println("JNC 的Fun2...");
    }
}
public class Test {
    public static void main(String[] args) {
        Wine a = new JNC();
        a.fun1();
    }
}

　　从程序的运行结果中我们发现，a.fun1()首先是运行父类Wine中的fun1().然后再运行子类JNC中的fun2()。

　　分析：在这个程序中子类JNC重载了父类Wine的方法fun1()，重写fun2()，而且重载后的fun1(String a)与 fun1()不是同一个方法，由于父类中没有该方法，向上转型后会丢失该方法，所以执行JNC的Wine类型引用是不能引用fun1(String a)方法。而子类JNC重写了fun2() ，那么指向JNC的Wine引用会调用JNC中fun2()方法。fun2()前其实隐藏了this,当a调用了fun1()后,这里的this就相当于a,在fun1()内部的fun2()可以看成是a.fun2(),由于a是指向子类的引用，调用时首先寻找子类是否含有fun2方法,如果有则调用子类中的fun2()。

　　所以对于多态我们可以总结如下：

　　指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

　　对于面向对象而已，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

多态的实现

实现条件

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

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

    继承：在多态中必须存在有继承关系的子类和父类。

    重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

    向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

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

    对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法（但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）。

实现形式

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

1、基于继承实现的多态

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

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;
    }
}
 
class JNC extends Wine {
    public JNC() {
        setName("JNC");
    }
    /**
     * 重写父类方法，实现多态
     */
    public String drink() {
        return "喝的是 " + getName();
    }
    /**
     * 重写toString()
     */
    public String toString() {
        return "Wine : " + getName();
    }
}
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、基于接口实现的多态

    继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

    在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

    继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

 经典实例

class A {
    public String show(D obj) {
        return "A and D";
    }
    public String show(A obj) {
        return "A and A";
    }
}
class B extends A {
    public String show(B obj) {
        return "B and B";
    }
    public String show(A obj) {
        return "B and A";
    }
}
class C extends B {
   
}
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));
    }
}

Output:
    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

解析：

继承结图	引用和对象之间的关系

　　this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)

　　按照上面的方法，可以正确得到其他的结果。

　　问题还要继续，现在我们再来看上面的分析过程是怎么体现出蓝色字体那句话的内涵的。它说：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用 变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。还是拿a2.show(b)来说吧。

　　a2是一个引用变量，类型为A，它引用的是B的一个对象，因此这句话的意思是由B来决定调用的是哪个方法。因此应该调用B的show(B obj)从而输出"B and B”才对。但是为什么跟前面的分析得到的结果不相符呢？！问题在于我们不要忽略了蓝色字体的后半部分，那里特别指明：这个被调用的方法必须是在超类中定义 过的，也就是被子类覆盖的方法。B里面的show(B obj)在超类A中有定义吗？没有！那就更谈不上被覆盖了。实际上这句话隐藏了一条信息：它仍然是按照方法调用的优先级来确定的。它在类A中找到了 show(A obj)，如果子类B没有覆盖show(A obj)方法，那么它就调用A的show(A obj)（由于B继承A，虽然没有覆盖这个方法，但从超类A那里继承了这个方法，从某种意义上说，还是由B确定调用的方法，只是方法是在A中实现而已）； 现在子类B覆盖了show(A obj)，因此它最终锁定到B的show(A obj)。这就是那句话的意义所在。