Java中super關鍵字的用法詳解

推薦學習：《》

super

super是一個關鍵字，全部小寫。
super和this對比著學習，都是"this/super."出現在實體方法，「this/super()"出現在構造方法當中
this:
（1）this能出現在實體方法和構造方法中。
（2）this的語法是：「this.」、「this()」
（3）this不能使用在靜態方法中。
（4）this. 大部分情況下是可以省略的。
（5）this.什麼時候不能省略呢？ 在區分區域性變數和範例變數的時候不能省略。

public void setName(String name){
                    this.name = name;
                }

（6）this() 只能出現在構造方法第一行，通過當前的構造方法去呼叫「本類」中其它的構造方法，目的是：程式碼複用！

super:
（1）super能出現在實體方法和構造方法中。
（2）super的語法是：「super.」、「super()」
（3）super不能使用在靜態方法中。
（4）super. 大部分情況下是可以省略的。
（5）super.什麼時候不能省略呢？
（6）super() 只能出現在構造方法第一行，通過當前的構造方法去呼叫「父類別」中的構造方法，目的是：建立子類物件的時候，先初始化父類別型特徵。

super()
表示通過子類的構造方法呼叫父類別的構造方法。
模擬現實世界中的這種場景：要想有兒子，需要先有父親。
重要的結論：當一個構造方法第一行：
既沒有this()又沒有super()的話，預設會有一個super();
表示通過當前子類的構造方法呼叫父類別的無引數構造方法。
所以必須保證父類別的無引數構造方法是存在的。
注意：this()和super() 不能共存，它們都是隻能出現在構造方法第一行。
無論是怎樣折騰，父類別的構造方法是一定會執行的。（百分百的）

super初步理解

例1：父類別和子類都是無參構造

public class Test01{
	public static void main(String[] args){
		//根據無參構造方法建立物件，肯定會呼叫無參構造方法！
        //只要物件建立出來就會呼叫構造方法，並且先呼叫父類別的構造方法，在呼叫子類的構造方法
		new B(); 
	}
}

class A{
	public A(){ //無參構造方法
		System.out.println("呼叫A的無參構造方法！");
	}
}
class B extends A{
	public B(){ //無參構造方法
		//super();//預設這裡有一個super()通過子類呼叫父類別的無參構造方法；可省略！
		System.out.println("呼叫B的無參構造方法！");
	}
}
//結果：我們只建立B物件；結果確實先呼叫A類的構造方法，才呼叫B類的構造方法
/*
	呼叫A的無參構造方法！
	呼叫B的無參構造方法！
*/

例2：父類別是有參構造、子類是無參構造

對父類別是有參構造、子類是無參構造；要想子類呼叫父類別的構造方法，必須寫上super關鍵字，並帶上對應引數；這樣才會呼叫父類別的有參構造方法！

public class Test01{
	public static void main(String[] args){
		//根據無參構造方法建立物件，肯定會呼叫無參構造方法！
		new B();
	}
}

class A{
	// 一個類如果沒有手動提供任何構造方法，系統會預設提供一個無引數構造方法。
	// 一個類如果手動提供了一個構造方法，那麼無引數構造系統將不再提供。
	public A(int i){ //有參構造方法
		System.out.println("呼叫A的有參構造方法！");
	}
}
class B extends A{
	public B(){ //無參構造方法
		// 父類別是有參構造方法，此時預設是是super()就會有問題，
           因為super()只能呼叫父類別無參的無參構造方法
		// 所以此時的super就不能省略；並且寫上時要寫上引數，
            呼叫父類別的有參構造方法，例如：super(100)
		super(100);
		System.out.println("呼叫B的無參構造方法！");
	}
}
//結果：我們只建立B物件；結果確實先呼叫A類的構造方法，才呼叫B類的構造方法
/*
	呼叫A的有參構造方法！
	呼叫B的無參構造方法！
*/

例3：this()和super()不能共存(重點理解)

public class Test01{
	public static void main(String[] args){
		//根據無參構造方法建立物件，肯定會呼叫無參構造方法！
		new B();
	}
}

class A{ //預設繼承Object類，class A extends Object
	// 建議手動的將一個類的無引數構造方法寫出來。
	public A(){ //無參構造方法
		//這裡也預設有super()，呼叫的是Object的無參構造方法
		System.out.println("呼叫A的無參構造方法！");
	}
	public A(int i){ //有參構造方法
		//這裡也預設有super()，呼叫的是Object的無參構造方法
		System.out.println("呼叫A的有參構造方法！");
	}
}
class B extends A{
	public B(){ //無參構造方法
        //通過this去呼叫B的有參構造方法；而B的有參構造方法預設也有super()!
		this("張三"); 
		System.out.println("呼叫B的無參構造方法！");
	}
	public B(String name){ //有參構造方法
		//預設也有super()，去呼叫A的無參構造
		System.out.println("呼叫B的有參構造方法！");
	}
}
//最終結果
/*
呼叫A的無參構造方法！
呼叫B的有參構造方法！
呼叫B的無參構造方法！
*/

例4：套娃例題理解

在java語言中不管是是new什麼物件，最後老祖宗的Object類的無引數構造方法一定會執行。（Object類的無引數構造方法是處於「棧頂部」）

棧頂的特點：最後呼叫，但是最先執行結束。後進先出原則。
大家要注意：
以後寫程式碼的時候，一個類的無引數構造方法還是建議大家手動的寫出來。
如果無引數構造方法丟失的話，可能會影響到「子類物件的構建」。

就是壓棧彈棧的過程：最先進去的方法會壓到棧底部，最後出來；最後進去的會被壓棧到最頂部，最先出來；並且因為super()關鍵字的原因，最終父類別一定是棧的頂部，最先出來

public class SuperTest02{
	public static void main(String[] args){
		new C();

	}
}
//----------對於父類別A實際上也會呼叫老祖宗Object類的無參構造
/*
class Object{
	public Object(){	
	}
}
*/

class A { //class A extends Object
	public A(){ //-------最後呼叫的；最先結束！
		System.out.println("1"); //1
	}
}

class B extends A{
	public B(){
		System.out.println("2"); 
	}
	public B(String name){
		//super();預設有
		System.out.println("3"); // 2
	}
}

class C extends B{
	public C(){ // -------最先呼叫的；最後結束！
		this("zhangsan");
		System.out.println("4");//5
	}
	public C(String name){
		this(name, 20);
		System.out.println("5");//4
	}
	public C(String name, int age){
		super(name);
		System.out.println("6");//3
	}
}

super(實參)的用法

在恰當的時間使用：super(實際參數列);
注意：在構造方法執行過程中一連串呼叫了父類別的構造方法，父類別的構造方法又繼續向下呼叫它的父類別的構造方法，但是實際上物件只建立了一個！

思考：「super(實參)」到底是幹啥的？
super(實參)的作用是：初始化當前物件的父類別型特徵。並不是建立新物件。實際上物件只建立了1個。
super關鍵字代表什麼？
（1）super關鍵字代表的就是「當前物件」的那部分父類別型特徵！

（2）我繼承了我父親的一部分特徵：
例如：眼睛、面板等；super代表的就是「眼睛、面板等」。
「眼睛、面板等」雖然是繼承了父親的，但這部分是在我身上呢。

public class SuperTest03{
	public static void main(String[] args){

		CreditAccount ca1 = new CreditAccount(); //呼叫無參構造
		System.out.println(ca1.getActno() + "," +
        ca1.getBalance() + "," + ca1.getCredit()); //null,0.0,0.0

		CreditAccount ca2 = new CreditAccount("1111", 10000.0, 0.999);//呼叫有參構造
		System.out.println(ca2.getActno() + "," + 
        ca2.getBalance() + "," + ca2.getCredit()); //1111,10000.0,0.999

	}
}

// 賬戶
class Account extends Object{
	// 屬性
	private String actno;
	private double balance;

	// 構造方法
	public Account(){ //對於無參構造，預設會呼叫super()；並且給實列變數賦上預設初始值
		//super();
		//this.actno = null;
		//this.balance = 0.0;
	}
	public Account(String actno, double balance){
		// super();
		this.actno = actno;
		this.balance = balance;
	}

	// setter and getter
	public void setActno(String actno){
		this.actno = actno;
	}
	public String getActno(){
		return actno;
	}
	public void setBalance(double balance){
		this.balance = balance;
	}
	public double getBalance(){
		return balance;
	}
}

// 信用賬戶
class CreditAccount extends Account{

	// 屬性：信譽度（誠信值）
	// 子類特有的一個特徵，父類別沒有。
	private double credit;

//重點在這裡-------------------------------寫上有參構造方法
	// 分析以下程式是否存在編譯錯誤？？？？
	public CreditAccount(String actno, double balance, double credit){

		// 直接存取不行，繼承過來的私有的屬性，只能通過setter和getter方法進行存取
		/*
		this.actno = actno;
		this.balance = balance;
		*/

		// 以上兩行程式碼在恰當的位置，正好可以使用：super(actno, balance);
		// 通過子類的構造方法呼叫父類別的構造方法。
		super(actno, balance); //呼叫父類別的構造方法
		this.credit = credit;
	}


	// 提供無引數的構造方法
	public CreditAccount(){ //對於無參構造，預設會呼叫super()；並且給實列變數賦上預設初始值

		//super();
		//this.credit = 0.0;
	}

	// setter and getter方法
	public void setCredit(double credit){
		this.credit = credit;
	}
	public double getCredit(){
		return credit;
	}
	
}

記憶體圖（重點掌握）

對於這個記憶體圖，我們要先理解：

（1）要建立CreditAccount物件，呼叫無參構造方法，預設有super()會呼叫它的父類別Account；Account的無參構造又預設有super()會呼叫它的父類別Object；

（2）根據棧的特點：後進先出，先開闢Object空間、然後開闢Account空間並把裡面的範例變數actno和balance進行初始化、最終才開闢CreditAccount物件的空間並把範例變數credit進行初始化；並且有this指向當前物件的地址；有super指向當前物件的父類別特徵！

super.使用

this表示當前物件。
super表示的是當前物件的父類別型特徵。（super是this指向的那個物件中的一塊空間。）

super和this都不能出現在靜態方法中！

public class SuperTest04{
	public static void main(String[] args){
		Vip v = new Vip("張三");
		v.shopping();
	}
}
class Customer{
	String name;
	public Customer(){}
	public Customer(String name){
		super();
		this.name = name;
	}
}
class Vip extends Customer{
	public Vip(){}
	public Vip(String name){
		super(name);
	}
	// super和this都不能出現在靜態方法中。
	public void shopping(){
		// this表示當前物件。
		System.out.println(this.name + "正在購物!");
		// super表示的是當前物件的父類別型特徵。（super是this指向的那個物件中的一塊空間。）
		System.out.println(super.name + "正在購物!");
		System.out.println(name + "正在購物!");
	}
}

記憶體圖

this實際上包含著super；this不能使用在static裡，所以super更不能！

super.什麼時候不能省略(掌握)

「this.」和「super.」大部分情況下都是可以省略的。
this. 什麼時候不能省略？

 public void setName(String name){
            this.name = name;
        }

super. 什麼時候不能省略？
java中允許在子類中出現和父類別一樣的同名變數/同名屬性。
父中有，子中又有，如果想在子中存取「父的特徵」，super. 不能省略。

java是怎麼來區分子類和父類別的同名屬性的？
this.name：當前物件的name屬性
super.name：當前物件的父類別型特徵中的name屬性。

public class SuperTest05{
	public static void main(String[] args){
		Vip v = new Vip("張三");
		v.shopping();
	}
}

class Customer {
	String name; //-----------------父類別中也有name
	public Customer(){}
	public Customer(String name){
		super();
		this.name = name;
	}

	public void doSome(){
		System.out.println(this.name + " do some!");
		System.out.println(name + " do some!");
		//錯誤: 找不到符號-----Object裡面沒有name
		//System.out.println(super.name + " do some!");
	}
}

class Vip extends Customer{

	// 假設子類也有一個同名屬性
	// java中允許在子類中出現和父類別一樣的同名變數/同名屬性。
	String name; //-----------------子類中也有name

	public Vip(){
	}
	public Vip(String name){
		super(name); //給父類別初始化了，子類並沒有進行初始化是null
		// this.name = null;
	}
	public void shopping(){
		/*
			java是怎麼來區分子類和父類別的同名屬性的？
				this.name：當前物件的name屬性
				super.name：當前物件的父類別型特徵中的name屬性。
		*/
        //----預設存取的是當前物件的name；加super存取的是父類別的name
		System.out.println(this.name + "正在購物!"); // null 正在購物
		System.out.println(super.name + "正在購物!"); // 張三正在購物
		System.out.println(name + "正在購物!"); //null 正在購物
	}
}

記憶體圖

super使用時後面必須有一個.

this輸出「參照」的時候，會自動呼叫參照的toString()方法；而super使用後面必須跟一個.，但是super.不是參照，不會自動呼叫toString()方法！

super 不是參照。super也不儲存記憶體地址，super也不指向任何物件。
super 只是代表當前物件內部的那一塊父類別型的特徵。

this和super都不能使用在static靜態方法中。

public class SuperTest06 {

	// 實體方法
	public void doSome(){
		System.out.println(this);//實際上呼叫的是this.toString()方法
		// 輸出「參照」的時候，會自動呼叫參照的toString()方法。
		//System.out.println(this.toString());

		//編譯錯誤: 需要'.'
		//System.out.println(super);
	}

// this和super不能使用在static靜態方法中。
	/*
	public static void doOther(){
		System.out.println(this);
		System.out.println(super.xxx);
	}
	*/

	// 靜態方法，主方法
	public static void main(String[] args){
		SuperTest06 st = new SuperTest06();
		st.doSome();

	}
}

使用super呼叫父類別方法

在父和子中有同名的屬性，或者說有相同的方法，
如果此時想在子類中存取父中的資料，必須使用「super.」加以區分。

super.屬性名 【存取父類別的屬性】；super.方法名(實參) 【存取父類別的方法】；在子類的範例屬性/方法當中呼叫父類別的範例屬性/方法
super(實參) 【呼叫父類別的構造方法】

public class SuperTest07{
	public static void main(String[] args){
		/*
			Cat move!
			Cat move!
			Animal move!
		*/
		Cat c = new Cat();
		c.yiDong();
	}
}

class Animal{
	public void move(){ //父中有
		System.out.println("Animal move!");
	}
}

class Cat extends Animal{
	// 對move進行重寫。
	public void move(){ //子中也有
		System.out.println("Cat move!");
	}

	// 在子類的實體方法當中呼叫父類別的實體方法
	public void yiDong(){
		this.move();//Cat move!---呼叫自己的
		move();//Cat move!---呼叫自己的
		// super. 不僅可以存取屬性，也可以存取方法。
		super.move();//Animal move!---呼叫父類別的
	}
}

最後小結：super關鍵字

super能出現在實體方法和構造方法中。
super的語法是：「super.」、「super()」
super不能使用在靜態方法中。
super. 大部分情況下是可以省略的。
super.什麼時候不能省略呢？
父類別和子類中有同名屬性，或者同樣的方法，想在子類中存取父類別的，super. 不能省略。
super() 只能出現在構造方法第一行，通過當前的構造方法去呼叫「父類別」中的構造方法，目的是：建立子類物件的時候，先初始化父類別型特徵。
super的使用：
（1）super.屬性名 【存取父類別的屬性】
（2）super.方法名(實參) 【存取父類別的方法】
（3）super(實參) 【呼叫父類別的構造方法】

推薦學習：《》

以上就是Java中super關鍵字的用法詳解的詳細內容，更多請關注TW511.COM其它相關文章！