是个Java的编程人员就知道，在以后项目开发的时候，我们的多态性几乎天天用。
小编和读者今天就来深究一下多态性的一些细节。
首先我们要知道多态性的三个必要满足的条件：
- 有继承
- 有方法的重写
- 有父类引用指向子类对象
1.入门案列
java中的继承是面向对象程序设计的一大特征，子类继承了父类的所有方法和成员变量，如果不对方法进行重写或对成员变量进行重新赋值，那么子类可以直接调用父类中的方法或变量。同时，在实例化父类的时候，可以使用子类的构造器。
但是，在这种情况下，调用这个父类对象中的方法和变量时，到底是使用父类的呢还是子类的呢？我们首先来创建两个类：
接下来我们来分析以下代码：
public class A {
static String name = "A";
int age = 1;
public static void show(){
System.out.println("A show");
}
public void cat(){
System.out.println("A cat");
}
}
public class B extends A{
static String name = "B";
int age = 2;
public static void show(){
System.out.println("B show");
}
public void cat(){
System.out.println("B cat");
}
}
可以看到， A类中声明了静态成员变量name、成员变量age、方法cat()和静态方法show()，同时子类B中也重写了这两个两个方法。下面，我们用B的构造方法来实例化一个A，再实例化一个B对象。
根据以上代码，写出下面代码运行的结果：
B b= new B();
A a = new B();
System.out.println(B.name);
System.out.println(A.name);
System.out.println("----------------");
System.out.println(b.age);
System.out.println(a.age);
System.out.println("-----------------");
B.show();
A.show();
b.cat();
a.cat();
B
A
----------------
2
1
-----------------
B show
A show
B cat
B cat
可以看到，在输出两个对象中的各个变量时，A对象并没有因为构造函数使用了其子类而输出子类中的成员变量值(编译看左边)，但是，在调用成员变量的时候就不一样了，在调用cat()方法时，A输出和B一样的结果(运行看右边)。
2.Java中静态方法能否被重写？
上述在调用静态方法show ()的时候，两个对象又分别输出了其各自的结果。是不是可以理解静态方法运行看左边，普通方法运行看右边呢，回答：错误。
分析：
public class Test {
public static void main(String[] args) {
Father.staticMethod(); // 运行结果：Father staticMethod
/**
* 结论：
* 类执行了自己申明的静态方法。
* 该子类实际上只是将父类中的同名静态方法进行了隐藏，而非重写。
* */
Son.staticMethod(); // 运行结果：Son staticMethod
Father father = new Son();
/**
* 结论：
* 父类引用指向子类对象时，只会调用父类的静态方法。
* 父类和子类中含有的其实是两个没有关系的方法，它们的行为也并不具有多态性。
* */
father.staticMethod(); // 运行结果：Father staticMethod
}
}
class Father {
public static void staticMethod() {
System.out.println("Father staticMethod");
}
}
class Son extends Father {
public static void staticMethod() {
System.out.println("Son staticMethod");
}
}
总结：
- 在Java中静态方法可以被继承，但是不能被覆盖，即不能重写。
- 如果子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法，那么该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。
- 类引用指向子类对象时，只会调用父类的静态方法。所以，它们的行为也并不具有多态性。
3.深入理解多态
接下来我们来分析以下代码：（经典）
package objectandclass;
class A {
public void show(D obj){
System.out.println("A and D");
}
public void show(A obj){
System.out.println ("A and A");
}
}
class B extends A{
public void show(B obj){
System.out.println("B and B");
}
public void show(A obj){
System.out.println("B and A");
}
}
class C extends B{}
class D extends B{}
根据以上代码，写出下面代码运行的结果：
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
a1.show(b);
a1.show(c);
a1.show(d);
a2.show(b);
a2.show(c);
a2.show(d);
b.show(b);
b.show(c);
b.show(d);
答案如下：
① A and A
② A and A
③ A and D
④ B and A
⑤ B and A
⑥ A and D
⑦ B and B
⑧ B and B
⑨ A and D
①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B and B”呢？！！先来回顾一下多态性。
运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
当超类对象引用变量引用子类对象时，调用谁的方法被引用对象的类型来决定，而不是引用变量的类型来决定。但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。 （但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）
好了，先温习到这里，言归正传！实际上这里涉及方法调用的优先问题 ，优先级由高到低依次为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。让我们来看看它是怎么工作的。
比如④，a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。
再比如⑧，b.show©，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。
按照上面的方法，可以正确得到其他的结果。
问题还要继续，现在我们再来看上面的分析过程是怎么体现出蓝色字体那句话的内涵的。它说：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。还是拿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)。这就是那句话的意义所在。
4.总结
- 编译看左边
- 运行看右边
- 静态方法不具有多态性。当子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法，那么该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。
