下面讲解一下Java中的多态机制，力求用最通俗易懂的语言，最精炼的话语，最生动的例子，深入浅出Java多态，帮助读者轻松掌握这个知识点。
什么是多态？
多态是指同一种行为具有多个不同表现形式的能力。
多态的分类
多态一般分为重载式多态和重写式多态：
多态实现的必要条件
向上转型和向下转型
instanceof 操作符来检查引用的对象是否确实是目标子类的实例。多态的成员访问特点
举个栗子：
// 水果类，拥有一个show()方法
public class Fruits {
public void show() {
System.out.println("我水果之父，打钱!");
}
}
// 苹果类，实现父类水果，并重写show()方法
public class Apple extends Fruits{
@Override
public void show() {
System.out.println("我苹果，打钱!");
}
public void color() {
System.out.println("我是红色的苹果。");
}
}
// 香蕉类，实现父类水果，并重写show()方法
class Banana extends Fruits {
@Override
public void show() {
System.out.println("我香蕉，打钱!");
}
public void color() {
System.out.println("我是黄色的香蕉。");
}
}
// 测试类
public class Test {
public static void main(String[] args) {
Fruits fruit = new Apple(); // 向上转型
fruit.show(); // 我苹果，打钱!
fruit = new Banana(); // 向上转型
fruit.show(); // 我香蕉，打钱!
}
}
这就是向上转型，Fruits fruit = new Apple();将子类对象Apple转化为父类对象Fruits，这个时候fruit引用指向的是子类对象，所以调用的方法是子类方法。
需要注意的是：向上转型时，子类单独定义的方法会丢失。比如，上面案例中的Apple类和Banana类都定义了自己的color方法，当进行了向上转型后，fruit引用指向Apple类的实例时是访问不到color方法的，fruit.color()会报错。
下面给出原因：
我们需要时刻记住多态的成员访问特点：编译时看左边，运行时看右边。
比如Fruits fruit = new Apple();，这行代码中的变量fruit在编译时和运行时的类型如下：
总结：在编译时，fruit的类型是Fruits，这决定了我们可以对fruit调用哪些方法。在运行时，fruit实际指向的对象是Apple类型，这决定了当我们调用fruit的方法时，实际执行的是哪个版本的方法（即Fruits类中的原始方法还是Apple类中的重写方法）。
上面讲的是向上转型，下面我们来讲一下向下转型：
// 测试类
public class Test {
public static void main(String[] args) {
Fruits fruit = new Apple(); // 向上转型
fruit.show(); // 我苹果，打钱!
fruit = new Banana(); // 向上转型
fruit.show(); // 我香蕉，打钱!
if (fruit instanceof Banana) {
Banana banana = (Banana) fruit; // 向下转型
banana.color(); // 我是黄色的香蕉。
}
}
}
注意：在进行向下转型之前，使用instanceof操作符进行检查是很重要的，否则，如果对象不是正确的类型，转型会抛出异常。
当使用instanceof关键字进行类型检查时，它会查看对象的运行时类型，而不是编译时类型。比如上面的例子中，fruit instanceof Banana这里fruit的引用在运行时指向一个Banana类型的对象，所以这个表达式的结果是true。简而言之，instanceof关键字总是基于对象的实际运行时类型来进行判断。
在向下转型中，子类引用指向父类对象（父类型，实例是子类的实例化），通常需要进行强制类型转换，但是这里有个需要注意的问题。
// 测试类
public class Test {
public static void main(String[] args) {
Fruits fruit = new Apple(); // 向上转型
Apple apple = (Apple) fruit; // 向下转型，强制类型转换
apple.color(); // 我是红色的苹果。
Banana banana = (Banana) fruit; // 报错：java.lang.ClassCastException
Fruits f1 = new Fruits();
Apple a1 = (Apple) f1; // 报错：java.lang.ClassCastException
}
}
为什么Apple apple = (Apple)fruit;没有报错可以转换成功呢？因为apple本身就是Apple对象，所以理所当然可以向下转型为Apple，因此自然也就不能转换成Banana，人可以干出指鹿为马的事情，但是编译器不行，不会指着苹果说是香蕉。
而f1是Fruits对象，它也不能被向下转型为任何子类对象，就好比你买了一个不知名的水果，你只知道它是一种水果，但是你不能直接说这个水果是苹果或者香蕉。
总结一下向下转型需要注意的问题：
最后来看一个多态的经典案例：
public class A { // A类
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
public class B extends A { // B类
public String show(B obj){
return ("B and B");
}
public String show(A obj) {
return ("B and A");
}
}
public class C extends B { // C类
}
public class D extends B { // D类
}
// 测试类
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)); // 1--A and A
System.out.println("2--" + a1.show(c)); // 2--A and A
System.out.println("3--" + a1.show(d)); // 3--A and D
System.out.println("4--" + a2.show(b)); // 4--B and A
System.out.println("5--" + a2.show(c)); // 5--B and A
System.out.println("6--" + a2.show(d)); // 6--A and D
System.out.println("7--" + b.show(b)); // 7--B and B
System.out.println("8--" + b.show(c)); // 8--B and B
System.out.println("9--" + b.show(d)); // 9--A and D
}
}
前三条输出语句还好理解，从第四条开始，为什么不是输出4–B and B而是4–B and A呢？
网上博客给的一句话：当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在父类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括，其实在继承中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
这句话有点长，很抽象，我用最通俗易懂的来理解：
在这里，a2 是一个类型为 A 的引用，但它实际上引用的是一个 B 类型的对象。因此，当我们调用 a2.show(b) 时，以下是发生的事情：
a2 的编译时类型，即 A。它会检查类 A 中是否有一个接受 B 类型参数的 show 方法。但是，类 A 中并没有明确接受 B 类型参数的 show 方法。因此，编译器会选择一个更为通用的版本，即 show(A obj)，因为 B 是 A 的子类。a2实际引用的对象类型，即B。由于B类重写了show(A obj)方法，因此JVM会调用B类中的这个版本，即B and A。换句话说，A a2 = new B();这行代码进行了向上转型，前面说过向上转型之后，子类单独定义的方法会丢失（即B类中的show(B obj)不能被调用），那么这个时候a2可以调用的方法就剩下A类中的show(D obj)、show(A obj)以及B类中的show(A obj)。然后再根据我们的口诀“编译时看左边，运行时看右边”，当运行时a2引用的就是B对象，故最终a2.show(b)就是在调用B类中的show(A obj)。
接下来再分析第五条a2.show(c)：
首先A a2 = new B();进行向上转型，那么，a2能调用的方法还是A类中的show(D obj)、show(A obj)以及B类中的show(A obj)，按照继承链中调用方法的优先级，a2是A类型的引用变量，所以继承链方法调用优先级中this.show(O)的this就代表了A，显然A类中的方法不满足这个要求，跳过，所以接下来是super.show(O)，A类没有父类（除了Object类），再次跳过，然后是this.show((super)O)，C继承于B，B继承于A，所以show(A obj)满足要求，由于a2变量引用的对象类型是B类型，而B类型又重写了该方法，所以最终调用的是B类中的show(A obj)，所以最后输出为B and A。
剩下的输出结果依次分析即可。
至此我们已经完整讲完Java多态机制，每天一个小知识点，每天进步一点点。