所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须由程序运行期间才能决定。因为在程序运行时才能确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下：

酒 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。

public class Animal {
    public void sleep() {
        System.out.println("父类：动物都是要睡觉");
    }
}
public class Cat extends Animal {
    public void sleep() {
        System.out.println("子类：猫跟动物的睡姿是不一样的");
    }
    public void action(String name) {
        System.out.println("子类: 猫能爬树");
    }
}
public static void main(String args[]) {

    Cat cat = new Cat();
    cat.sleep();
    cat.action();

    Animal a2 = new Cat();
    a2.sleep();
    a2.action();
}

改程序运行错误,报错信息:

Test.java:20: 错误: 找不到符号
                a2.action();
                ^
  符号:   变量 a2
  位置: 类 Test
1 个错误

上面的代码父类a2，在调用action()方法的时候，由于父类没有action()方法，调用不了。

多态的总结

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

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

Java实现多态存在三个必要条件：

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

只有满足上述三个条件，我们才能够在同一个继承结构中使用同一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
对于 Java 而言，多态实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须具有超类中定义过的也就是说呗子类覆盖的方法。

多态的机制

多态的机制分为两种：

编译时多态（又称静态多态）
运行时多态（又称动态多态）

我们通常所说的多态指的都是运行时多态，也就是编译时不确定究竟调用哪个具体方法，一直延迟到运行时才能确定。这也是为什么有时候多态方法又被称为延迟方法的原因。

多态的实现

在Java中有可以使用继承和接口来实现多态。

基于继承（extends）实现的多态

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

public class Animal {
    public void sleep() {
        System.out.println("父类：动物都是要睡觉");
    }
        public void action() {
        System.out.println("动物的行为");
    }
}
public class Cat extends Animal {
    public void sleep() {
        System.out.println("子类：猫跟动物的睡姿是不一样的");
    }
    public void action(String name) {
        System.out.println("子类: 猫能爬树");
    }
}
public static void main(String args[]) {
    Animal a2 = new Cat();
    a2.sleep();
    a2.action();
}

在上面的代码中父类引用子类对象,调用的是子类重写的方法,进行输出

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

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

基于接口实现的多态

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

多态的优点

消除类型之间的耦合关系
可替换性(substitutability): 多态对已存在代码具有可替换性.
可扩充性
接口性
灵活性
简化性

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，在去调用子类的同同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

经典实例

class A{
    public String show(D obj){ 
        return ("A and D"); 
    }
    public String show(A obj){ 
        return ("A abd 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(a1.show(b)); ① A and A
System.out.println(a1.show(c)); ② A and A
System.out.println(a1.show(d)); ③ A and D
System.out.println(a2.show(b)); ④ B and A
System.out.println(a2.show(c)); ⑤ B and A
System.out.println(a2.show(d)); ⑥ A and D
System.out.println(b.show(b));  ⑦ B and B
System.out.println(b.show(c));  ⑧ B and B
System.out.println(b.show(d));  ⑨ A and D

Java多态