首先给多态下个定义：

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

多态性 就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

这一大串属于可能令人头痛，下面就以具体例子来解释一下。

public class Base {

    public int a = 8;
    public void base() {
        System.out.println("这是基类Base被重写的方法");
    }

    public void test() {
        System.out.println("这是基类Base没有被重写的方法");
    }

    public static void testStatic() {
        System.out.println("这是基类Base的static方法");
    }
}

public class SubClass extends Base{

    public int a = 88;
    @Override
    public void base() {
        System.out.println("这是子类SubClass重写的方法");
    }

    public void sub() {
        System.out.println("这是子类SunClass独有的方法");
    }

    public static void testStatic() {
        System.out.println("这是子类SubClass的static方法");
    }

    public static void main(String args[]) {
        Base base1 = new SubClass();
        base1.testStatic();          //这是基类Base的static方法
        System.out.println(base1.a);     //8
        base1.test();                          //这是基类Base没有被重写的方法
        base1.base();                        //这是子类SubClass重写的方法
    }
}

首先对下面这段话进行解释

程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定

Base base1 = new SubClass();

在编译时base1是Base类的对象，但是运行时，它所实际代表的对象是new SubClass()所产生的对象。也就是说，如果程序不运行，即编译的时候，base1就是Base类的对象，我们在写代码的时候只能把对base1调用Base类中定义的方法或者变量，如base()、test()等，强行调用sub()方法则会产生编译错误。

Error:(22, 14) java: 找不到符号
  符号:   方法 sub()
  位置: 类型为com.company.Base的变量 base1

程序在运行的时候确定调用的是哪个类的方法和变量

System.out.println(base1.a);     //8
base1.base();                        //这是子类SubClass重写的方法

如代码所示，调用base()方法的实际上调用的是subClass对象中的base()方法。因为base1在运行时引用的是subClass类的对象，所以调用方法的时候也是调用subClass中的方法。

实现条件

对上述多态性的例子进行总结，可以得出多态性实现的三个条件：

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

对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
白话版的就是：程序首先要编译，然后才能运行，编译就要求对象调用的方法是在超类中定义过的，然后运行的时候再根据子类来确定具体调用的方法。

经典例题

下面是来自https://blog.csdn.net/caomiao2006/article/details/53384988的一个经典例题。

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));     //A and A
        System.out.println("2--" + a1.show(c));      //A and A
        System.out.println("3--" + a1.show(d));      //A and D
        System.out.println("4--" + a2.show(b));      // B and A
        System.out.println("5--" + a2.show(c));      // B and A
        System.out.println("6--" + a2.show(d));      //A and D
        System.out.println("7--" + b.show(b));        //B and B
        System.out.println("8--" + b.show(c));        //B and B
        System.out.println("9--" + b.show(d));        //A and D
    }
}

要对上述现象进行解释，首先要明白在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
用白话解释就是子类中找不到的方法到超类中去找，超类中找不到就把传入的对象向上转型成超类的对象，然后在子类中继续去找，还找不到就把对象转成超类之后在子类的超类中去找。

下面对这几种输出分别进行解释。

System.out.println("1--" + a1.show(b));     //A and A

A类中没有show(B b) 方法，A类没有超类，因此把B向上转型成A类的对象，即跳到this.show((super)O)这一步，A类中有show(A a)方法，完成。

System.out.println("2--" + a1.show(c));      //A and A

与上面类似

System.out.println("3--" + a1.show(d));      //A and D

A类中有show(D d)方法，结束。

System.out.println("4--" + a2.show(b));      // B and A

此处为难点！！！

A a2 = new B();

A类中没有show（B b）方法，A类没有超类，因此跳到this.show((super)O)这一步，A类中有show（A a）方法，但是与此同时，B类中也有重写的show（A a）方法，按照被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法这个准则，因此这个时候就调用B类中重写的方法，即为B and A。

System.out.println("5--" + a2.show(c));      // B and A

与此类似

总结

多态可以减少代码的耦合性，加强代码的复用。但是多态导致不能够调用被引用对象中独有的方法，需要向下转型才可以。