java 多态 动态绑定

package com.bjpowernode.mybatis.test;

public class TestMethod {

	public static void main(String[] args) {

		/* 动态绑定
		 * 在调用成员方法时，会将方法和对象的实际内存进行绑定，调用实际内存中的方法。
		 * 
		 * 函数参数不用到动态绑定
		 * 所以test(a1)就调用第一个
		 * 
		 * 
		A a = new A();
		test(a);	//
		
		B b = new B();
		test(b);
		
		A a1 = new B();
		test(a1);
		
		*/
		A a = new A();
		System.out.println(a.getResult());
		
		B b = new B();
		System.out.println(b.getResult());
		
		A a1 = new B();
		System.out.println(a1.getResult());
		
	}
	
	public static void test( A a) {
		System.out.println("Type of the param is A");
	}
	
	public static void test( B b) {
		System.out.println("Type of the param is B");
	}

}
/*
class A {
	
	private int i = 10;
	
	public int getResult() {
		return i + 10;
	}
}
class B extends A {
	
	private int i = 20;
	
	public int getResult() {
		return i + 20;
	}
}
执行结果
 *  20
 *	40
 *	40
 * 最基本的动态调用
 * 多态: 一个对象,在环境不同的条件下,会表现出不同的行为
 * 动态绑定: 在调用成员方法时，会将方法和对象的实际内存进行绑定，调用实际内存中的方法。
 * 	     注意: 只局限于成员方法
 * */


/*
class A {
	
	private int i = 10;
	
	public int getResult() {
		return i + 10;
	}
}
class B extends A {
	
	private int i = 20;
	
}
这种情况呢?子类没有继承父类的成员方法,而继承了父类的成员变量呢?
 *执行结果:
 *	20
 *	20
 *	20
 * A a = new B();
 * 1. 子类没有重写父类的方法,但是会继承下来,所以B中有一个叫getResuult()的方法,只是看不到,
 * 2. 这个方法实际内存地址是A类对象的,在运行期调用方法时,JVM发现B对象中这个方法的地址与类B不匹配,
 * 		而是与类A对象的地址象吻合,那么他就会调用类A中的getResult方法,上面说过了,成员变量i不参加动态绑定
 * 		所以即使B对象中有i也不会用他的,而是用A对象的.
 * 3.出现这种情况的前提是B对象没有重写A对象的方法.
 * */

/*
class A {
	
	private int i = 10;
	
	public int getResult() {
		return getI() + 10;
	}
	
	public int getI() {
		return i;
	}
}
class B extends A {
	
	private int i = 20;
}

这种情况呢? 虽然子类没有重写父类的成员方法,而是重写了get方法?
 * 执行结果:
 *  20
 *	30
 *  30
 * 为什么出现这种情况?
 * 还是那句话: 只有成员方法参加多态的运行. 不管你是在哪调用的,即使你在成员方法中调用
 * 			一个方法,只要是子类重写了,那么就多态.
 * 根据上一个例子: 它调用父类的getResult时,内部有一个getI(),这时候要多态了,发现子类
 * 				重写了,那么就调用子类的,返回20
 */
/*
class A {
	
	private int i = 10;
	
	public int getResult() {
		return getI() + 10;
	}
	
	public int getI() {
		return i;
	}
}
class B extends A {
	
	private int i = 20;
	
}
这种情况就更明了了.
 * 执行结果:
 *  20
 *	20
 *	20
 * 
 * */

class A {
	
	private int i = 10;
	
	public int getResult() {
		return getI() + 10;
	}
	
	public int getI() {
		return i;
	}
}
class B extends A {
	
	private int i = 20;
	
	public int getResult() {
		return getI() + 20;
	}
}
/*
* 执行结果:
*  20
*  30
*  30
* 
* */