重载和重写（overload and override)

/*
 * study Override and 
 * 学习   覆盖(重写) 和  重载
 */
public class Test {
	
	//重载
	public void f(int a, int b){}
	//当函数名和参数相同时，不论返回值和方法修饰符是否相同，都不能编译过
	protected int f(int a, int b){ return a;}  //编译出错
	//包含抽象方法的类必须声明抽象类
	abstract void f(int a); //编译出错

}

 

public class Test {
   private void method(){};
}

class Sub extends Test{
	/*重写 :
	 * 1.子类修饰符必须大于或等于父类的修饰符，返回类型，方法名,参数必须相同
	 * 2.子类方法不能抛出比父类方法更多的异常，或者子类的异常是父类异常的子类或相同
	 * 3.父类的静态方法不能被子类覆盖成非静态，反过来也是
	 * 4.子类与父类间static函数重写的一些特别********这条要注意
	 */

	public int method(){  //编译报错
		
	}
	
	public int method(int a){ //正确，重载
		return a;		
	}
}

3.

/*
 * study Override and  Overload
 * 学习   覆盖(重写) 和  重载
 */
public class Test {
   public static void method(){}
}

class Sub extends Test{
   public void method(){}  //编译出错
}

class Base{
	void method(){}
}

class Sub1 extends Base{
	static void method(){} //编译出错
}

4.子类与父类间static函数重写的一些特别********这条要注意

/*
 * study Override and  Overload
 * 学习   覆盖(重写) 和  重载
 */
class Base{
	void method(){
		System.out.println("method of Base");
	}
	
	static void staticMethod(){
		System.out.println("staticMethod of Base");
	}
}

class Sub extends Base{
	void method(){
		System.out.println("method of Sub");
	}
	
	static void staticMethod(){
		System.out.println("staticMethod of Sub");
	}
}

public class Test {
    public static void main(String[] args) {
		Base b1 = new Sub();
		b1.method(); // method of Sub
		b1.staticMethod(); //这个注意了： staicMethod of Base
		
		Sub b2 = new Sub();
		b2.method(); //method of Sub
		b2.staticMethod(); // staticMethod of Sub
   }
}

5.父类的私有方法不能被子类覆盖 ******注意了喔

/*
 * study Override and  Overload
 * 学习   覆盖(重写) 和  重载
 */
class Base{
	private void method(){
		System.out.println("method of Base");
	}
	
	public void print(){
		method();
	}
	
}

class Sub extends Base{
	
	public void method(){
		System.out.println("method of Sub");
	}
	
	
	
}

public class Test {
    public static void main(String[] args) {
		Base b1 = new Sub();
		b1.print();  //method of Base
		/*
		 * 若果把Base的method改成 public void method()
		 * b1.print(); //method of Sub
		 */
		
   }
}

 

6.父类的非抽象方法可以被覆盖为抽象方法

public class Test{
	void method(){}
}

abstract class Sub extends Test{
	public abstract void method();  //合法
}