java 多态的学习和堆栈方法区画图 向上转型 向下转型

class Test2_Polymorphic {
	public static void main(String[] args) {
		Father f = new Son(); 
		//父类型引用指向子类型对象就是向上转型
		System.out.println(f.num); 
		//成员变量 编译看左边（父类） 运行看左边（父类）。
		f.print(); 
		/*成员方法  编译看左边（父类） 运行看右边（子类）。    
		编译的时候看父类是否有这个方法 如果有这个方法保证可以编译通过
		 调用的时候调用子类的方法（也称作动态绑定）*/
		f.test(); 
		/*静态方法
		编译看左边（父类），运行看左边（父类）。
		（静态和类相关，算不上重写，所以访问的还是左边的）
		*/ 
		//总结 只有非静态的成员方法，编译看左边，运行看右边。（也称作动态绑定）特例。
		

		/*基本数据类型提升和强制数据转换
		int i = 10；
		byte b = 20;
		i = b; //自动类型提升
		b = (byte)i;//强制类型转换
		*/
		// f.special(); 如果直接调用报错 因为编译的时候父类没有这个方法
		Son s = (Son)f;
		s.special();
		
	}

}

class Father {
	int num = 10;//成员变量
	public void print(){//成员方法
		System.out.println("Father");
	}

	public static void test(){ //静态方法
		System.out.println("Father static");
	}
}

class Son extends Father {
	int num = 20;
	public void print(){
		System.out.println("Son");
	}
	public static void test(){
		System.out.println("Son static");
	}
	public void special(){//成员方法 只有子有
		System.out.println("Son special"); 
	}
}

成员变量的图：

成员方法的图：

多态的弊端

多态的弊端就是不能直接调用子类的成员方法 （如果父类没有相同命名的成员方法）
上面例子直接调用 f.special(); 如果直接调用报错 因为编译的时候父类没有这个方法会报错
就是弊端的代码体现

多态的优点

1. 提高了代码的维护性（继承保证）。
2. 提高了代码的扩展性（由多态保证）

如何提高代码的扩展性 用一个例子表示

class Test2_Polymorphic {
	public static void main(String[] args) {
		method(new Cat());
	}
	public static void method(Cat c){
		c.eat();
	}
}

class Animal {
	public void eat(){
		System.out.println("Animal eat");
	}
}

class Cat extends Animal {
	public void eat(){
		System.out.println("Cat eat");
	}
	public static void catchMoust(){
		System.out.println("Cat catch Moust");
	}

}
class Dog extends Animal {
	public void eat(){
		System.out.println("Dog eat");
	}
	public static void lookHouse(){
		System.out.println("Dog lookHouse");
	}

}

上述只能添加进去Cat 的eat方法；如果想method(new Dog());
由于接受的参数是Cat 所以会报错。

最low的方法就是这样了 那如果还有很多类 岂不是要写很多遍 很麻烦。

class Test2_Polymorphic {
	public static void main(String[] args) {
		method(new Cat());

		method(new Dog());
	}
	public static void method(Cat c){
		c.eat();
	}

	public static void method(Dog d){
		d.eat();
	}
}

class Animal {
	public void eat(){
		System.out.println("Animal eat");
	}
}

class Cat extends Animal {
	public void eat(){
		System.out.println("Cat eat");
	}
	public static void catchMoust(){
		System.out.println("Cat catch Moust");
	}

}
class Dog extends Animal {
	public void eat(){
		System.out.println("Dog eat");
	}
	public static void lookHouse(){
		System.out.println("Dog lookHouse");
	}

}

扩展性的体现：

class Test2_Polymorphic {
	public static void main(String[] args) {
		method(new Cat());

		method(new Dog());
	}
	public static void method(Animal a){
		a.eat();
	}


}

class Animal {
	public void eat(){
		System.out.println("Animal eat");
	}
}

class Cat extends Animal {
	public void eat(){
		System.out.println("Cat eat");
	}
	public static void catchMoust(){
		System.out.println("Cat catch Moust");
	}

}
class Dog extends Animal {
	public void eat(){
		System.out.println("Dog eat");
	}
	public static void lookHouse(){
		System.out.println("Dog lookHouse");
	}

}