程式師世界 >> 編程語言 >> 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對象調用了super和this，super和this調用了super和this，那麼對象s與super和this是什麼關系？super和super,this是什麼關系？this和super,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(),super和this不影響super和this。show()是普通方法，所以this確定為son對象，所以this.show()指son的show()方法,但是son沒有覆蓋show()方法，所以這個show()來自father,然後super所在類的父類也是father，所以super.show()也來自father。即super和this都調用了父類的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中super和this都調用了父類的show()方法，2super.show()和this.show()都按照2裡面的方式一樣運行，所以super.show()和this.show()輸出結果一樣（super和this不影響super和this）。總結：外部的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 文章原創，謝絕轉載，歡迎指正。