Java 多态

本文对Java 多态，继承，重载（overload），重写(override)技术做一个简单小结。

继承

继承指子类继承父类,或者子接口继承父接口。使用extends。

实现是指类实现接口方法，使用implements.

重载

重载指的是一个类中的几个方法，具有相同的函数名称，但是参数个数不同，或者类型不同的一系列方法。类中的方法可以是从父类继承过来的方法。

重写

重写是Java类实现多态技术的一个重要特征。也是本文着重介绍的。重写的方法可以使得类的方法动态绑定，或者叫延迟绑定。

重写具有以下特征：

1. 私有方法无动态绑定功能，可以父子类同时拥有同样方法，但本质上是两个不同函数。
2. final方法不能重写。
3. 静态方法没有动态绑定功能，可以父类和子类都同时定义，但使用时候是谁的句柄，就调用谁的函数。
4. 子类的作用访问不能小于父类范围，父类是public,子类不能为protected.
5. 子类重载函数不能抛出比父类更多的异常。

最后使用一个demo来表述下java的动态绑定。

public class HierarchyTest {
	public static void main(String args[])
	{
		//static function, no dynamic bind, output parent.
		Parent p = new Child(1,2,3);
		p.protectedStaticFunction();
		p.publicStaticFunction();
		System.out.println("************************");
		//var and static var, 
		p.dumpVars();
		
		System.out.println("************************");
		((Child)p).protectedStaticFunction();
		((Child)p).publicStaticFunction();
		
		System.out.println("************************");
		p.protectedFunction();
		p.publicFunction();
		
	}
}

class Parent
{
	private int privateVar;
	protected int protectedVar;
	public int publicVar;
	private static int privateStaticVar;
	protected static int protectedStaticVar;
	public static int publicStaticVar;
	
	private int privateFunction()
	{
		System.out.println("Parent privateFunction");
		return privateVar;
	}
	
	protected int protectedFunction()
	{
		System.out.println("Parent protectedFunction");
		return protectedVar;
	}
	
	public int publicFunction()
	{
		System.out.println("Parent publicFunction");
		return publicVar;
	}
	
	private static int privateStaticFunction()
	{
		System.out.println("Parent privateStaticFunction");
		privateStaticVar =0;
		return privateStaticVar;
	}
	
	protected static int protectedStaticFunction()
	{
		System.out.println("Parent protectedStaticFunction");
		return protectedStaticVar;
	}
	
	public static int publicStaticFunction()
	{
		System.out.println("Parent publicStaticFunction");
		return publicStaticVar;
	}
	
	
	public Parent(int privateVar,int protectedVar,int publicVar)
	{
		this.privateVar = privateVar;
		this.protectedVar =  protectedVar;
		this.publicVar = publicVar;
	}
	
	public void dumpVars()
	{
		return;
	}
}


class Child extends Parent
{
	public Child(int privateVar, int protectedVar, int publicVar) {
		super(privateVar, protectedVar, publicVar);
	}


	private int privateVar;
	protected int protectedVar;
	public int publicVar;
	private static int privateStaticVar;
	protected static int protectedStaticVar;
	public static int publicStaticVar;
	
	//private function for class
	private int privateFunction()
	{
		System.out.println("Child privateFunction");
		return privateVar;
	}
	
	//protected extends parent,also can be public, the scope can be enlarged, the exception can not be enlarged
	protected int protectedFunction()
	{
		System.out.println("Child protectedFunction");
		return protectedVar;
	}
	
	public int publicFunction()
	{
		System.out.println("Child publicFunction");
		return publicVar;
	}
	//it is ok, can be static or none static, because it is private. If it is public or friendly, the compiler will complain compile error
	private static int privateStaticFunction()
	{
		System.out.println("Child privateStaticFunction");
		privateStaticVar =0;
		return privateStaticVar;
	}
	//
	protected static int protectedStaticFunction()
	{
		System.out.println("Child protectedStaticFunction");
		return protectedStaticVar;
	}
	
	public static int publicStaticFunction()
	{
		System.out.println("Child publicStaticFunction");
		return publicStaticVar;
	}
	
	public void dumpVars()
	{
		System.out.println("Child privateVar="+ this.privateVar);
		System.out.println("Child protectedVar="+ this.protectedVar);
		System.out.println("Child publicVar="+ this.publicVar);
		System.out.println("Child privateStaticVar="+ this.privateStaticVar);
		System.out.println("Child protectedStaticVar="+ this.protectedStaticVar);
		System.out.println("Child publicStaticVar="+ this.publicStaticVar);

		//can not visit private var of parent
		//System.out.println("Parent privateVar="+ super.privateVar);
		System.out.println("Parent protectedVar="+ super.protectedVar);
		System.out.println("Parent publicVar="+ super.publicVar);
		//can not visit private static of parent
		//System.out.println("Parent privateStaticVar="+ super.privateStaticVar);
		System.out.println("Parent protectedStaticVar="+ super.protectedStaticVar);
		System.out.println("Parent publicStaticVar="+ super.publicStaticVar);
		
	}
	
}