程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> super和this,superthis

super和this,superthis

編輯:JAVA綜合教程

super和this,superthis


關於super和this有一個奇怪的現象: 例1:
class grandfather{
    String name="grandfather";
}
class father extends grandfather{
    String name="father";
    void show(){
        System.out.println("father.show-->"+this.name+"--"+super.name);
    }
}
class son extends father{  
    void rs(){
        super.show();
        this.show();
    }
}
public class super_this2 {
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
} 
運行結果: father.show-->father--grandfather father.show-->father--grandfather 使用super.show()和使用this.show()輸出的結果是一樣的。存在這種現象的還有這種現象還有super.getClass()和this.getClass()等。
例2:
public class super_this2{
    public static void main(String[] args) {
        new super_this2().test();
    }
    public void test(){
        System.out.println(super.getClass());
        System.out.println(this.getClass());
    }
} 
運行結果: 
class super_this2 class super_this2   現在我們分析這個現象。 1.在例1的子類中覆蓋show() 例3:
class grandfather{
    String name="grandfather";
}
class father extends grandfather{
    String name="father";
    void show(){
        System.out.println("father.show-->"+this.name+"--"+super.name);
    }
}
class son extends father{
    void show(){
        System.out.println("son.show-->"+this.name+"--"+super.name);
    }
    void rs(){
        super.show();
        this.show();
    }
}
public class super_this2{
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
}  
運行結果:
father.show-->father--grandfather son.show-->father--father 這說明 A.super.方法/變量調用的確實是父類的方法/變量;this.方法/變量調用的確實是當前對象的方法/變量   2.而如果子類沒有覆蓋show()時,子類輸出結果和父類一樣,比如例1,再比如下面的例子: 例4:
public class Test2 {
    public static void main(String[] args) {
        ch c=new ch();
        c.m6();
        c.m7();
        c.m8();    
    }
   static class fa{
        final void m6(){
            System.out.println("father's m6");
        }
        static void m7(){
            System.out.println("father's m7");
        }
        void m8(){
            System.out.println("father's m8");
        }
    }
    static class ch extends fa{
        void m8(){
            System.out.println("child's m8");
        } 
    }  
}
運行結果: father's m6 father's m7 child's m8 這裡,m6,m7,m8都被繼承了,然後m6,m7沒有被覆蓋,輸出的是父類的結果。m8被重寫輸出子類的結果。
這說明: B.如果子類沒有重寫或隱藏父類的某個方法和變量,那麼子類調用繼承的方法或變量來自父類。
所以A和B綜合的結果是:AB.super.方法/變量調用的確實是父類的方法/變量;this.方法/變量調用的確實是當前對象的方法/變量,但如果this所在對象沒有重寫或隱藏父類的方法或變量,那麼它調用的繼承來的方法或變量來自父類 3.如果在例1的son類中添加 String name="son"; 例5:
class grandfather{
    String name="grandfather";
}
class father extends grandfather{
    String name="father";
    void show(){
        System.out.println("father.show-->"+this.name+"--"+super.name);
    }
}
class son extends father{
    String name="son";//隱藏father類的name屬性
    void rs(){
        super.show();
        this.show();
    }
}
public class super_this2{
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
}  
運行結果和例1一樣: father.show-->father--grandfather father.show-->father--grandfather  
但如果像下面這樣不隱藏而直接修改name屬性: 例6:
class grandfather{
    String name="grandfather";
}
class father extends grandfather{
    String name="father";//
    void show(){
        System.out.println("father.show-->"+this.name+"--"+super.name);
    }
}
class son extends father{
//    String name="son"; // 去掉
    public son(){
        name="son";//不隱藏父類的name , 在構造方法中直接修改
    }
    void rs(){
        super.show();
        this.show();
    }
}
public class super_this2{
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
}  
運行結果:
father.show-->son--grandfather father.show-->son--grandfather  
這說明: C.隱藏變量不會對父類變量產生影響,但是對繼承來的變量進行修改會對父類的變量產生直接影響。
現在你把例6的father類中的 String name="father"去掉試試:
class grandfather{
    String name="grandfather";
}
class father extends grandfather{
//    String name="father";// 去掉
    void show(){
        System.out.println("father.show-->"+this.name+"--"+super.name);
    }
}
class son extends father{
//    String name="son"; // 去掉
    public son(){
        name="son";
    }
    void rs(){
        super.show();
        this.show();
    }
}
public class super_this2{
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
}
運行結果: father.show-->son--son father.show-->son--son 原因正如C所說的,String name="father"隱藏了爺爺類的String name="grandfather",所以後面修改name="son"不會對爺爺類產生影響,現在去掉隱藏後,對繼承的name屬性的修改就會影響爺爺類的name屬性。   4.提2個問題:(1)方法體裡面的this和super與調用它們對象是什麼關系,(2)this和super與方法體裡面的this和super是什麼關系? 即這裡son對象調用了superthissuperthis調用了superthis,那麼對象ssuperthis是什麼關系?supersuper,this是什麼關系?thissuper,this是什麼關系?
class grandfather{
    String name="grandfather";
    public String toString(){
        return "grandfather toString";
    }
    public static String toString2(){
        return "grandfather static toString";
    }
}
class father extends grandfather{
    String name="father";
    void show(){
        System.out.println("father.show-->"+this.name+"--"+super.name);
        System.out.println("father.show-->"+this.toString()+"--"+super.toString());
        System.out.println("father.show-->"+this.toString2()+"--"+super.toString2());
    }
    public String toString(){
        return "father toString";
    }
    public static String toString2(){
        return "father static toString";
    }
}
class son extends father{
String name="son";
    void rs(){
        super.show();
        System.out.println("===========================");
        this.show();
    }
    public String toString(){
        return "son toString";
    }
    public static String toString2(){
        return "son static toString";
    }
}
public class super_this2{
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
}
運行結果
father.show-->father--grandfather father.show-->son toString--grandfather toString father.show-->father static toString--grandfather static toString =========================== father.show-->father--grandfather father.show-->son toString--grandfather toString father.show-->father static toString--grandfather static toString  
  D.外部的super和this只能決定程序調用的是父類的還是子類的,不會對它們方法體裡面的super和this產生影響,super指所在類的父類,使用super將決定調用所在類的父類的方法,this則分兩種情況,1.變量和靜態方法(static),priavate方法,fianl方法,作為構造方法使用,編譯期就確定this為所在類的對象,2.其他方法this在運行期間確定為運行的對象。所以綜合AB結果是:ABD.外部的super和this只能決定程序調用的是父類的還是子類的,不會對它們方法體裡面的super和this產生影響,super指所在類的父類,使用super將決定調用所在類的父類的方法,即super.方法/變量調用的是所在類父類的方法/變量;this則分三種情況,1.變量和靜態方法(static),priavate方法,fianl方法以及它作為構造方法使用時,編譯期就確定this所在類的對象,2.其他方法在運行期間確定為運行的對象。3.確定this所指對象後,如果該對象沒有重寫或隱藏父類的方法或變量,那麼它調用的繼承來的方法或變量來自父類。   總之super和this的法就是找到它們所指的對象,然後調用這個對象的方法,ABD說的就是super和this所指的對象,然後怎麼調用這個對象的方法。 套用在上面的例子: 1.super和this只能決定程序調用的是父類的還是子類的show(),superthis不影響superthis。show()是普通方法,所以this確定為son對象,所以this.show()指son的show()方法,但是son沒有覆蓋show()方法,所以這個show()來自father,然後super所在類的父類也是father,所以super.show()也來自father。即superthis都調用了父類的show()方法。 2.然後this.name和this.toString2()都是編譯期間就確定this為所在的對象,所以name和toString2是fanther的屬性和方法,父類也存在name和toString2();this.String()是普通方法,確定為運行的對象son 所以輸出: father.show-->father--grandfather father.show-->son toString--grandfather toString father.show-->father static toString--grandfather static toString 3.在1中superthis都調用了父類的show()方法,2super.show()和this.show()都按照2裡面的方式一樣運行,所以super.show()和this.show()輸出結果一樣(superthis不影響superthis)。   總結: 外部的super和this只能決定程序調用的是父類的還是子類的,不會對它們方法體裡面的super和this產生影響,super指所在類的父類,使用super將決定調用所在類的父類的方法,即super.方法/變量調用的是所在類父類的方法/變量;this則分三種情況,1.變量和靜態方法(static),priavate方法,fianl方法以及它作為構造方法使用時,編譯期就確定this所在類的對象,2.其他方法在運行期間確定為運行的對象。3.確定this所指對象後,如果該對象沒有重寫或隱藏父類的方法或變量,那麼它調用的繼承來的方法或變量來自父類。
.隱藏變量不會對父類變量產生影響,但是對繼承來的變量進行修改會對父類的變量產生直接影響。
  最後看一道題:
class father{
    void show(){
        System.out.println("father getClass-->"+this.getClass()+"--"+super.getClass());
        System.out.println("father getSuperclass-->"+this.getClass().getSuperclass()+"--"+super.getClass().getSuperclass());
    }
}
class son extends father{
    void rs(){
        super.show();
        System.out.println("===========================");
        this.show();
    }
}
public class super_this3{
    public static void main(String[] args) {
        son s=new son();
        s.rs();
    }
}  
father getClass-->class son--class son father getSuperclass-->class father--class father =========================== father getClass-->class son--class son father getSuperclass-->class father--class father 主要是因為super.getClass()返回的是son.class,然後son.class.getName()輸出son。 getClass是final方法,this.getClass肯定來自父類。getClass的源碼:
Java_java_lang_Object_getClass(JNIEnv *env, jobject this)
{
    if (this == NULL) {
        JNU_ThrowNullPointerException(env, NULL);
        return 0;
    } else {
        return (*env)->GetObjectClass(env, this);
    }
}
this指正在運行的對象。所以getClass返回son.class   文章原創,謝絕轉載,歡迎指正。  

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved