【Thinking in Java】七：多态

1 向上转型
写一个方法，它仅接收基类作为参数，而不是那些特殊的导出类，也就是说编写的代码只与基类打交道，这正式多态所允许的。

简单例子：


class Cycle {
	private String name = "Cycle";
	public static void travel(Cycle c) {
		println("Cycle.ride() " + c);
	}
	public String toString() {
		return this.name;
	}
}

class Unicycle extends Cycle {
	private String name = "Unicycle";
	public String toString() {
		return this.name;
	}	
}

public class Biking {
	public static void ride(Cycle c) {
		c.travel(c);
	}
	public static void main(String[] args) {
		Unicycle u = new Unicycle();	
	    ride(u);
	}

二多态实现

一个方法调用和一个方法主体关联起来被称作绑定。
编译时，无法知道父类引用指向子类对象，Java解决的方法是动态绑定，在运行时根据对象的类型进行绑定，后期绑定机制，需要在对象中存有某种‘类型信息’。

2.1多态不支持私有方法

class Father{
	private void  v(){
		System.out.println("super v");
	}
	public static void main(String[] args) {
		Father f = new Son();
		f.v();
	}
}

class Son extends Father{
	private void  v(){
		System.out.println("son v");
	}
}

output--> super v

2.2 多态不支持域和静态方法

class Father{
	public int field = 0;
	public static void main(String[] args) {
		Father f = new Son();
		System.out.println(f.field);
	}
}

class Son extends Father{
	public int field = 1;
}

output--> 0

静态方法这个大家可以参考上面的私有方法改写试一下。

静态方法是与类，而并非与单个的对象关联的。

三多态与构造器

class Father{
	public Father(){
		System.out.println("123");
	}

}

class Son {
	public Son(){
		System.out.println("1234");
	}

	{
		System.out.println("dksjk");
	}
	private Father f= new Father();
	static{
		System.out.println("222");
	}
	public static void main(String[] args) {
	 new Son();
	}
}

output--> 222 dksjk 123 1234
代码示例中没有继承，但是通过demo可以看出

如有继承，先调用基类

类中的调用顺序为静态代码块 -->按声明顺序调用成员初始化 -->构造函数

【Thinking in Java】七：多态

猜你喜欢