java 多态的景况

java 多态的情况
参考
http://topic.****.net/u/20120415/21/524a6daa-e703-4382-8f42-8c3eb2b51d4f.html?16896 提的问题
参考
http://blog.****.net/thinkGhoster/article/details/2307001# thinkGhoster
对多态的分析

常见的Java 多态的概念需要基于继承与方法重写的概念。只有准确满足这两种情况（满足这个基本概念的要求），才会出现多态。
目前遇到的多态情况分为：
Case1: 父类引用指向子类对象

class A{
public void fun(){
System.out.println("A");
}  
}
class B extends A{
public void fun(){
System.out.println("B");
}
}

public class TestOverride {

	public static void main(String[] args) {
	A a = new B();
	a.fun();
}
}

运行结果为:B

上面例子中父类引用a指向了子类对象，然后调用了fun 方法，由于该方法被子类B 重写，所以运行时会调用B的fun 方法。


Case2：父类的方法调用了一个被子类重写的方法，这个时候还是会调用子类的方法，这个应该也是多态。具体例子：

class A{
public void fun(){
System.out.println("A");
}  
public void f(){
this.fun();
}
}
class B extends A{
public void fun(){
System.out.println("B");
}
}

public class TestOverride {

	public static void main(String[] args) {
	B b = new B();
	b.f();
}
}

运行结果为：B

注意：如果将父类的fun 方法设为private ，那么因为不能被继承，所以不会出现多态。具体例子：

class A{
private void fun(){
System.out.println("A");
}  
public void f(){
this.fun();
}
}
class B extends A{
public void fun(){
System.out.println("B");
}
}

public class TestOverride {

	public static void main(String[] args) {
	B b = new B();
	b.f();
}
}

运行结果为A

补充：多态的方法调用问题：引自**** thinkGhoster 的代码例子

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

}
class C extends B{} 
class D extends B{} 

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));   
        System.out.println(a1.show(c));   
        System.out.println(a1.show(d)); 
        System.out.println(a2.show(a2));   
        System.out.println(a2.show(b));
        System.out.println(a2.show(c));
        System.out.println(a2.show(d));   
        System.out.println(b.show(b));    
        System.out.println(b.show(c));    
        System.out.println(b.show(d));     
	}
}

运行结果：
A and A
A and A
A and D
B and A
B and A
B and A
A and D
B and B
B and C
A and D
这里涉及到知识(个人参考一些东西总结，不一定正确，如有疑问，请指正）：
方法调用时：
如果方法是private ,static ,final 的，那就进行静态绑定，在编译期就可以确定
否则：
例如上面的a2.show(c） 方法，运行时首先会确定a2引用变量的声明类型A，然后寻找合适的方法调用，这个遵循thinkGhoster 总结的原则:先查看A类中有没有精确匹配的方法签名，如果没有再到A的父类中查找有没有，如果还是没有，则从A类中寻找合理的模糊匹配，因为c所应用的对象也是A类型，所以就找到了public String show(A obj) 这个方法。如果还是没有找到模糊匹配，则还会到父类中去找模糊匹配（这个一定能找到，否则会在编译期就报错，表示找不到想要调用的方法），找到了之后，
如果引用变量的实际类型与声明类型不一致，这时还需要考虑多态的情况，及如果引用变量所指向的实际对象的类型重写了该方法，那么就会调用实际对象的类型的方法。