Java 繼承與重寫

1.類的繼承

1）繼承

　　父類：全部子類所共有的屬性和行爲

　　子類：子類所特有的屬性和行爲

• 經過extends關鍵字來實現類的繼承
• 子類（Sub class）能夠繼承父類（Super class）的成員變量及成員方法，同時也能夠定義本身的成員變量和成員方法
• Java語言不支持多重繼承，一個類只能繼承一個父類（單一繼承），但一個父類能夠有多個子類
• 繼承具備傳遞性，子類的子類能夠繼承父類的父類的成員變量及成員方法

2）繼承中構造方法（super關鍵字）

• Java規定：構造子類以前必須先構造父類
• 子類的構造方法中必須經過super關鍵字調用父類的構造方法，這樣能夠妥善的初始化繼承自父類的成員變量
• 若是子類的構造方法中沒有調用父類的構造方法，Java編譯器會自動的加入對父類無參構造方法的調用（若是該父類沒有無參的構造方法，則會出現編譯錯誤）
• super（）調父類構造必須位於子類構造的第一句
• super指代當前對象的父類對象

super的用法：

• super.成員變量名：訪問父類的成員變量
• super.方法名()：調用父類的方法
• super()：調用父類的構造方法

案例1：調用父類無參構造

public class Person {
	String name;
	char gender;
}


public class Student extends Person {
//	super ();  //編譯錯誤，必須位於子類構造方法的第一句
	double score;
	Student(double score){
		super();  //編譯器默認會自動加上
		this.score = score;
		super.name = "Tom";
	}
}

 

案例2：調用父類有參構造

public class Person {
	String name;
	char gender;
	Person(String name,char gender){
		this.name = name;
		this.gender = gender;
	}
}



public class Student extends Person {
//	super ();  //編譯錯誤，必須位於子類構造方法的第一句
	double score;
	Student(String name,char gender,double score){
//		super();  //編譯錯誤，父類中沒有無參構造
		super(name,gender);  //調用父類有參構造
		this.score = score;
		super.name = "Tom";
	}
}

　　

3）向上造型

• 一個子類的對象能夠向上造型爲父類的類型。即定義父類型的引用能夠指向子類的對象
• 父類的引用能夠指向子類的對象，但經過父類的引用只能訪問父類所定義的成員，不能訪問子類擴展的部分（能點出什麼看引用）

案例3：向上造型

public class Person {
	String name;
	char gender;
	Person(String name,char gender){
		this.name = name;
		this.gender = gender;
	}
}


public class Student extends Person {
	double score;
	Student(String name,char gender,double score){
		super(name,gender);  //調用父類有參構造
		this.score = score;
		super.name = "Tom";
	}
	
	public static void main(String[] args) {
		Person p = new Student("Tom",'男',80);    //向上造型
		p.score = 100;        //編譯錯誤，Java編譯器會根據引用的類型（Person)，而不是對象的類型（Student）來檢查調用的方法是否匹配。
	}
}

　　

2.方法的重寫（Override）

• 發生在父子類中，方法簽名相同，方法體不一樣：子類能夠重寫（覆蓋）繼承自父類的方法，即方法名和參數列表與父類的方法相同，但方法的實現不一樣（方法體不一樣）
• 重寫方法被調用時，看對象的類型：當子類對象的重寫方法被調用時（不管是經過子類的引用調用仍是經過父類的引用調用），運行的是子類的重寫後的版本
• 子類在重寫父類的方法時，能夠經過super關鍵字調用父類的版本，這樣的語法一般用於子類的重寫方法在父類方法的基礎之上進行功能擴展。

1）.重寫原則

　　重寫遵循「兩同兩小一大」原則：

　　1）兩同：

　　　　1.1）方法名相同

　　　　1.2）參數列表相同

　　2）兩小：

　　　　2.1）子類方法的返回值類型要小於或等於父類

　　　　　　2.1.1）void時，必須相同

　　　　　　2.1.2）基本數據類型時，必須相同

　　　　　　2.1.3）引用類型時，小於或等於

　　　　2.2）子類方法拋出的異常要小於或等於父類的----異常以後

　　3）一大：

　　　　3.1）子類方法的訪問權限要大於或等於父類的----訪問控制修飾符以後

 

class Aoo{
	void show(){}
	double test(){return 0.0;}
	Boo sayHi(){return null;}
	public Aoo say(){return null;}
}
class Boo extends Aoo{
	//int show(){return 1;} //編譯錯誤，void時必須相同
	//int test(){return 0;} //編譯錯誤，基本類型時必須相同
	//Aoo sayHi(){return null;} //編譯錯誤，引用類型必須小於或等於
	public Boo say(){return null;}
}

 

案例4：方法重寫

public class Student {
	public static void main(String[] args) {
		Goo o = new Goo();
		o.f();
		Foo oo = new Goo();
		oo.f();
	}
	}

class Foo{
	public void f(){
		System.out.println("Foo.f()");
	}
}
class Goo extends Foo{
	public void f(){
		System.out.println("Goo.f()");
	}
}

//當子類對象的重寫方法被調用時（不管經過子類的引用仍是經過父類的引用），運行的都是子類重寫後的方法。

/*
運行結果：
Goo.f()
Goo.f()
*/

 

案例5：方法重寫，super調用父類版本

public class Student {
	public static void main(String[] args) {
		Goo o = new Goo();
		o.f();
		Foo oo = new Goo();
		oo.f();
	}
	}

class Foo{
	public void f(){
		System.out.println("Foo.f()");
	}
}
class Goo extends Foo{
	public void f(){
		super.f();      //調用父類的方法
		System.out.println("Goo.f()");
	}
}

//子類重寫方法中的super.f(); 調用了父類的版本，這樣的語法一般用於子類的重寫方法再父類方法的基礎之上進行功能擴展。

/*
運行結果：
Foo.f()
Goo.f()
Foo.f()
Goo.f()
*/

　　

 2）重寫和重載的區別

• 重寫（Override）：1.發生在父子類中，（方法簽名相同）方法名稱相同，參數列表相同，方法體不一樣   2.遵循「運行期」綁定，重寫方法被調用時，看對象的類型
• 重載（Overload）：1.發生在同一類中，方法名稱相同，參數列表不一樣，方法體不一樣  2.遵循「編譯期」綁定，看引用的類型綁定方法

案例6：重寫與重載區別

public class OverrideAndOverload {
	public static void main(String[] args){
		Super obj = new Sub(); //向上造型
		Goo goo = new Goo();
		goo.g(obj);
	}
}
class Super{
	public void f(){
		System.out.println("super.f()");
	}
}
class Sub extends Super{
	public void f(){   //方法重寫
		System.out.println("sub.f()");
	}
}
class Goo{
	public void g(Super obj){
		System.out.println("g(Super)");
		obj.f();
	}
	public void g(Sub obj){  //方法重載
		System.out.println("g(Sub)");
		obj.f();
	}
}

以上代碼運行結果：

g(Super)
sub.f()