這篇文章主要講解了“Java中super關(guān)鍵字怎么使用”，文中的講解內(nèi)容簡單清晰，易于學(xué)習(xí)與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“Java中super關(guān)鍵字怎么使用”吧！

成都創(chuàng)新互聯(lián)公司是一家專業(yè)提供宜城企業(yè)網(wǎng)站建設(shè),專注與網(wǎng)站設(shè)計(jì)、成都網(wǎng)站設(shè)計(jì)、成都h5網(wǎng)站建設(shè)、小程序制作等業(yè)務(wù)。10年已為宜城眾多企業(yè)、政府機(jī)構(gòu)等服務(wù)。創(chuàng)新互聯(lián)專業(yè)的建站公司優(yōu)惠進(jìn)行中。

super

super是一個(gè)關(guān)鍵字，全部小寫。
super和this對比著學(xué)習(xí)，都是"this/super."出現(xiàn)在實(shí)例方法，“this/super()"出現(xiàn)在構(gòu)造方法當(dāng)中
     this:
        （1）this能出現(xiàn)在實(shí)例方法和構(gòu)造方法中。
        （2）this的語法是：“this.”、“this()”
        （3）this不能使用在靜態(tài)方法中。
        （4）this. 大部分情況下是可以省略的。
        （5）this.什么時(shí)候不能省略呢？ 在區(qū)分局部變量和實(shí)例變量的時(shí)候不能省略。

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

（6）this() 只能出現(xiàn)在構(gòu)造方法第一行，通過當(dāng)前的構(gòu)造方法去調(diào)用“本類”中其它的構(gòu)造方法，目的是：代碼復(fù)用！

super:
            （1）super能出現(xiàn)在實(shí)例方法和構(gòu)造方法中。
            （2）super的語法是：“super.”、“super()”
            （3）super不能使用在靜態(tài)方法中。
            （4）super. 大部分情況下是可以省略的。
            （5）super.什么時(shí)候不能省略呢？
            （6）super() 只能出現(xiàn)在構(gòu)造方法第一行，通過當(dāng)前的構(gòu)造方法去調(diào)用“父類”中的構(gòu)造方法，目的是：創(chuàng)建子類對象的時(shí)候，先初始化父類型特征。

super()
        表示通過子類的構(gòu)造方法調(diào)用父類的構(gòu)造方法。
        模擬現(xiàn)實(shí)世界中的這種場景：要想有兒子，需要先有父親。    
重要的結(jié)論：當(dāng)一個(gè)構(gòu)造方法第一行：
            既沒有this()又沒有super()的話，默認(rèn)會有一個(gè)super();
            表示通過當(dāng)前子類的構(gòu)造方法調(diào)用父類的無參數(shù)構(gòu)造方法。
            所以必須保證父類的無參數(shù)構(gòu)造方法是存在的。
注意：this()和super() 不能共存，它們都是只能出現(xiàn)在構(gòu)造方法第一行。
無論是怎樣折騰，父類的構(gòu)造方法是一定會執(zhí)行的。（百分百的）

super初步理解

例1：父類和子類都是無參構(gòu)造

public class Test01{
	public static void main(String[] args){
		//根據(jù)無參構(gòu)造方法創(chuàng)建對象，肯定會調(diào)用無參構(gòu)造方法！
        //只要對象創(chuàng)建出來就會調(diào)用構(gòu)造方法，并且先調(diào)用父類的構(gòu)造方法，在調(diào)用子類的構(gòu)造方法
		new B(); 
	}
}

class A{
	public A(){ //無參構(gòu)造方法
		System.out.println("調(diào)用A的無參構(gòu)造方法！");
	}
}
class B extends A{
	public B(){ //無參構(gòu)造方法
		//super();//默認(rèn)這里有一個(gè)super()通過子類調(diào)用父類的無參構(gòu)造方法；可省略！
		System.out.println("調(diào)用B的無參構(gòu)造方法！");
	}
}
//結(jié)果：我們只創(chuàng)建B對象；結(jié)果確實(shí)先調(diào)用A類的構(gòu)造方法，才調(diào)用B類的構(gòu)造方法
/*
	調(diào)用A的無參構(gòu)造方法！
	調(diào)用B的無參構(gòu)造方法！
*/

例2：父類是有參構(gòu)造、子類是無參構(gòu)造

對父類是有參構(gòu)造、子類是無參構(gòu)造；要想子類調(diào)用父類的構(gòu)造方法，必須寫上super關(guān)鍵字，并帶上對應(yīng)參數(shù)；這樣才會調(diào)用父類的有參構(gòu)造方法！

public class Test01{
	public static void main(String[] args){
		//根據(jù)無參構(gòu)造方法創(chuàng)建對象，肯定會調(diào)用無參構(gòu)造方法！
		new B();
	}
}

class A{
	// 一個(gè)類如果沒有手動提供任何構(gòu)造方法，系統(tǒng)會默認(rèn)提供一個(gè)無參數(shù)構(gòu)造方法。
	// 一個(gè)類如果手動提供了一個(gè)構(gòu)造方法，那么無參數(shù)構(gòu)造系統(tǒng)將不再提供。
	public A(int i){ //有參構(gòu)造方法
		System.out.println("調(diào)用A的有參構(gòu)造方法！");
	}
}
class B extends A{
	public B(){ //無參構(gòu)造方法
		// 父類是有參構(gòu)造方法，此時(shí)默認(rèn)是是super()就會有問題，
           因?yàn)閟uper()只能調(diào)用父類無參的無參構(gòu)造方法
		// 所以此時(shí)的super就不能省略；并且寫上時(shí)要寫上參數(shù)，
            調(diào)用父類的有參構(gòu)造方法，例如：super(100)
		super(100);
		System.out.println("調(diào)用B的無參構(gòu)造方法！");
	}
}
//結(jié)果：我們只創(chuàng)建B對象；結(jié)果確實(shí)先調(diào)用A類的構(gòu)造方法，才調(diào)用B類的構(gòu)造方法
/*
	調(diào)用A的有參構(gòu)造方法！
	調(diào)用B的無參構(gòu)造方法！
*/

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

public class Test01{
	public static void main(String[] args){
		//根據(jù)無參構(gòu)造方法創(chuàng)建對象，肯定會調(diào)用無參構(gòu)造方法！
		new B();
	}
}

class A{ //默認(rèn)繼承Object類，class A extends Object
	// 建議手動的將一個(gè)類的無參數(shù)構(gòu)造方法寫出來。
	public A(){ //無參構(gòu)造方法
		//這里也默認(rèn)有super()，調(diào)用的是Object的無參構(gòu)造方法
		System.out.println("調(diào)用A的無參構(gòu)造方法！");
	}
	public A(int i){ //有參構(gòu)造方法
		//這里也默認(rèn)有super()，調(diào)用的是Object的無參構(gòu)造方法
		System.out.println("調(diào)用A的有參構(gòu)造方法！");
	}
}
class B extends A{
	public B(){ //無參構(gòu)造方法
        //通過this去調(diào)用B的有參構(gòu)造方法；而B的有參構(gòu)造方法默認(rèn)也有super()!
		this("張三"); 
		System.out.println("調(diào)用B的無參構(gòu)造方法！");
	}
	public B(String name){ //有參構(gòu)造方法
		//默認(rèn)也有super()，去調(diào)用A的無參構(gòu)造
		System.out.println("調(diào)用B的有參構(gòu)造方法！");
	}
}
//最終結(jié)果
/*
調(diào)用A的無參構(gòu)造方法！
調(diào)用B的有參構(gòu)造方法！
調(diào)用B的無參構(gòu)造方法！
*/

例4：套娃例題理解

在java語言中不管是是new什么對象，最后老祖宗的Object類的無參數(shù)構(gòu)造方法一定會執(zhí)行。（Object類的無參數(shù)構(gòu)造方法是處于“棧頂部”）

棧頂?shù)奶攸c(diǎn)：最后調(diào)用，但是最先執(zhí)行結(jié)束。后進(jìn)先出原則。
大家要注意：
        以后寫代碼的時(shí)候，一個(gè)類的無參數(shù)構(gòu)造方法還是建議大家手動的寫出來。
        如果無參數(shù)構(gòu)造方法丟失的話，可能會影響到“子類對象的構(gòu)建”。

就是壓棧彈棧的過程：最先進(jìn)去的方法會壓到棧底部，最后出來；最后進(jìn)去的會被壓棧到最頂部，最先出來；并且因?yàn)閟uper()關(guān)鍵字的原因，最終父類一定是棧的頂部，最先出來

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

	}
}
//----------對于父類A實(shí)際上也會調(diào)用老祖宗Object類的無參構(gòu)造
/*
class Object{
	public Object(){	
	}
}
*/

class A { //class A extends Object
	public A(){ //-------最后調(diào)用的；最先結(jié)束！
		System.out.println("1"); //1
	}
}

class B extends A{
	public B(){
		System.out.println("2"); 
	}
	public B(String name){
		//super();默認(rèn)有
		System.out.println("3"); // 2
	}
}

class C extends B{
	public C(){ // -------最先調(diào)用的；最后結(jié)束！
		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(實(shí)參)的用法

在恰當(dāng)?shù)臅r(shí)間使用：super(實(shí)際參數(shù)列表);
   注意：在構(gòu)造方法執(zhí)行過程中一連串調(diào)用了父類的構(gòu)造方法，父類的構(gòu)造方法又繼續(xù)向下調(diào)用它的父類的構(gòu)造方法，但是實(shí)際上對象只創(chuàng)建了一個(gè)！

思考：“super(實(shí)參)”到底是干啥的？
       super(實(shí)參)的作用是：初始化當(dāng)前對象的父類型特征。并不是創(chuàng)建新對象。實(shí)際上對象只創(chuàng)建了1個(gè)。
  super關(guān)鍵字代表什么？
        （1）super關(guān)鍵字代表的就是“當(dāng)前對象”的那部分父類型特征！

（2）我繼承了我父親的一部分特征：
                例如：眼睛、皮膚等；super代表的就是“眼睛、皮膚等”。
               “眼睛、皮膚等”雖然是繼承了父親的，但這部分是在我身上呢。

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

		CreditAccount ca1 = new CreditAccount(); //調(diào)用無參構(gòu)造
		System.out.println(ca1.getActno() + "," +
        ca1.getBalance() + "," + ca1.getCredit()); //null,0.0,0.0

		CreditAccount ca2 = new CreditAccount("1111", 10000.0, 0.999);//調(diào)用有參構(gòu)造
		System.out.println(ca2.getActno() + "," + 
        ca2.getBalance() + "," + ca2.getCredit()); //1111,10000.0,0.999

	}
}

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

	// 構(gòu)造方法
	public Account(){ //對于無參構(gòu)造，默認(rèn)會調(diào)用super()；并且給實(shí)列變量賦上缺省初始值
		//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{

	// 屬性：信譽(yù)度（誠信值）
	// 子類特有的一個(gè)特征，父類沒有。
	private double credit;

//重點(diǎn)在這里-------------------------------寫上有參構(gòu)造方法
	// 分析以下程序是否存在編譯錯誤？？？？
	public CreditAccount(String actno, double balance, double credit){

		// 直接訪問不行，繼承過來的私有的屬性，只能通過setter和getter方法進(jìn)行訪問
		/*
		this.actno = actno;
		this.balance = balance;
		*/

		// 以上兩行代碼在恰當(dāng)?shù)奈恢?，正好可以使用：super(actno, balance);
		// 通過子類的構(gòu)造方法調(diào)用父類的構(gòu)造方法。
		super(actno, balance); //調(diào)用父類的構(gòu)造方法
		this.credit = credit;
	}


	// 提供無參數(shù)的構(gòu)造方法
	public CreditAccount(){ //對于無參構(gòu)造，默認(rèn)會調(diào)用super()；并且給實(shí)列變量賦上缺省初始值

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

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

內(nèi)存圖（重點(diǎn)掌握）

對于這個(gè)內(nèi)存圖，我們要先理解：

（1）要創(chuàng)建CreditAccount對象，調(diào)用無參構(gòu)造方法，默認(rèn)有super()會調(diào)用它的父類Account；Account的無參構(gòu)造又默認(rèn)有super()會調(diào)用它的父類Object；

（2）根據(jù)棧的特點(diǎn)：后進(jìn)先出，先開辟Object空間、然后開辟Account空間并把里面的實(shí)例變量actno和balance進(jìn)行初始化、最終才開辟CreditAccount對象的空間并把實(shí)例變量credit進(jìn)行初始化；并且有this指向當(dāng)前對象的地址；有super指向當(dāng)前對象的父類特征！

super.使用

this表示當(dāng)前對象。
super表示的是當(dāng)前對象的父類型特征。（super是this指向的那個(gè)對象中的一塊空間。）

super和this都不能出現(xiàn)在靜態(tài)方法中！

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都不能出現(xiàn)在靜態(tài)方法中。
	public void shopping(){
		// this表示當(dāng)前對象。
		System.out.println(this.name + "正在購物!");
		// super表示的是當(dāng)前對象的父類型特征。（super是this指向的那個(gè)對象中的一塊空間。）
		System.out.println(super.name + "正在購物!");
		System.out.println(name + "正在購物!");
	}
}

內(nèi)存圖

this實(shí)際上包含著super；this不能使用在static里，所以super更不能！

super.什么時(shí)候不能省略(掌握)

“this.”和“super.”大部分情況下都是可以省略的。
this. 什么時(shí)候不能省略？     

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

super. 什么時(shí)候不能省略？
       java中允許在子類中出現(xiàn)和父類一樣的同名變量/同名屬性。
       父中有，子中又有，如果想在子中訪問“父的特征”，super. 不能省略。

java是怎么來區(qū)分子類和父類的同名屬性的？
      this.name：當(dāng)前對象的name屬性
       super.name：當(dāng)前對象的父類型特征中的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{

	// 假設(shè)子類也有一個(gè)同名屬性
	// java中允許在子類中出現(xiàn)和父類一樣的同名變量/同名屬性。
	String name; //-----------------子類中也有name

	public Vip(){
	}
	public Vip(String name){
		super(name); //給父類初始化了，子類并沒有進(jìn)行初始化是null
		// this.name = null;
	}
	public void shopping(){
		/*
			java是怎么來區(qū)分子類和父類的同名屬性的？
				this.name：當(dāng)前對象的name屬性
				super.name：當(dāng)前對象的父類型特征中的name屬性。
		*/
        //----默認(rèn)訪問的是當(dāng)前對象的name；加super訪問的是父類的name
		System.out.println(this.name + "正在購物!"); // null 正在購物
		System.out.println(super.name + "正在購物!"); // 張三正在購物
		System.out.println(name + "正在購物!"); //null 正在購物
	}
}

內(nèi)存圖

super使用時(shí)后面必須有一個(gè).

this輸出“引用”的時(shí)候，會自動調(diào)用引用的toString()方法；而super使用后面必須跟一個(gè).，但是super.不是引用，不會自動調(diào)用toString()方法！

super 不是引用。super也不保存內(nèi)存地址，super也不指向任何對象。
super 只是代表當(dāng)前對象內(nèi)部的那一塊父類型的特征。

this和super都不能使用在static靜態(tài)方法中。

public class SuperTest06 {

	// 實(shí)例方法
	public void doSome(){
		System.out.println(this);//實(shí)際上調(diào)用的是this.toString()方法
		// 輸出“引用”的時(shí)候，會自動調(diào)用引用的toString()方法。
		//System.out.println(this.toString());

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

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

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

	}
}

使用super調(diào)用父類方法

在父和子中有同名的屬性，或者說有相同的方法，
如果此時(shí)想在子類中訪問父中的數(shù)據(jù)，必須使用“super.”加以區(qū)分。

super.屬性名    【訪問父類的屬性】；super.方法名(實(shí)參) 【訪問父類的方法】；在子類的實(shí)例屬性/方法當(dāng)中調(diào)用父類的實(shí)例屬性/方法
super(實(shí)參)  【調(diào)用父類的構(gòu)造方法】

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進(jìn)行重寫。
	public void move(){ //子中也有
		System.out.println("Cat move!");
	}

	// 在子類的實(shí)例方法當(dāng)中調(diào)用父類的實(shí)例方法
	public void yiDong(){
		this.move();//Cat move!---調(diào)用自己的
		move();//Cat move!---調(diào)用自己的
		// super. 不僅可以訪問屬性，也可以訪問方法。
		super.move();//Animal move!---調(diào)用父類的
	}
}

最后小結(jié)：super關(guān)鍵字

super能出現(xiàn)在實(shí)例方法和構(gòu)造方法中。
  super的語法是：“super.”、“super()”
  super不能使用在靜態(tài)方法中。
  super. 大部分情況下是可以省略的。
  super.什么時(shí)候不能省略呢？
     父類和子類中有同名屬性，或者同樣的方法，想在子類中訪問父類的，super. 不能省略。
  super()只能出現(xiàn)在構(gòu)造方法第一行，通過當(dāng)前的構(gòu)造方法去調(diào)用“父類”中的構(gòu)造方法，目的是：創(chuàng)建子類對象的時(shí)候，先初始化父類型特征。
  super的使用：
       （1）super.屬性名                【訪問父類的屬性】
       （2）super.方法名(實(shí)參)      【訪問父類的方法】
       （3）super(實(shí)參)                【調(diào)用父類的構(gòu)造方法】

感謝各位的閱讀，以上就是“Java中super關(guān)鍵字怎么使用”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對Java中super關(guān)鍵字怎么使用這一問題有了更深刻的體會，具體使用情況還需要大家實(shí)踐驗(yàn)證。這里是創(chuàng)新互聯(lián)，小編將為大家推送更多相關(guān)知識點(diǎn)的文章，歡迎關(guān)注！