Mengapa super.super.method (); tidak diizinkan di Jawa?

Saya membaca pertanyaan ini dan berpikir bahwa itu akan dengan mudah diselesaikan (bukan karena itu tidak dapat dipecahkan tanpa) jika seseorang dapat menulis:

@Override
public String toString() {
    return super.super.toString();
}

Saya tidak yakin apakah itu berguna dalam banyak kasus, tetapi saya bertanya - tanya mengapa itu tidak berguna dan jika sesuatu seperti ini ada dalam bahasa lain.

apa yang kalian pikirkan?

EDIT: Untuk memperjelas: ya saya tahu, itu tidak mungkin di Jawa dan saya tidak benar-benar melewatkannya. Ini bukan apa-apa yang saya harapkan untuk bekerja dan terkejut mendapatkan kesalahan kompiler. Saya hanya punya ide dan suka mendiskusikannya.

Itu melanggar enkapsulasi. Anda seharusnya tidak dapat mem-bypass perilaku kelas induk. Masuk akal untuk kadang-kadang dapat mem-bypass perilaku kelas Anda sendiri (khususnya dari dalam metode yang sama) tetapi tidak dengan perilaku orang tua Anda. Sebagai contoh, misalkan kita memiliki basis "koleksi item", subkelas yang mewakili "koleksi item merah" dan subkelas yang mewakili "koleksi item merah besar". Masuk akal untuk memiliki:

public class Items
{
    public void add(Item item) { ... }
}

public class RedItems extends Items
{
    @Override
    public void add(Item item)
    {
        if (!item.isRed())
        {
            throw new NotRedItemException();
        }
        super.add(item);
    }
}

public class BigRedItems extends RedItems
{
    @Override
    public void add(Item item)
    {
        if (!item.isBig())
        {
            throw new NotBigItemException();
        }
        super.add(item);
    }
}

Tidak apa-apa - RedItems selalu dapat yakin bahwa item yang dikandungnya semuanya berwarna merah. Sekarang anggaplah kita berada dapat memanggil super.super.add ():

public class NaughtyItems extends RedItems
{
    @Override
    public void add(Item item)
    {
        // I don't care if it's red or not. Take that, RedItems!
        super.super.add(item);
    }
}

Sekarang kita bisa menambahkan apa pun yang kita suka, dan invarian di RedItemsrusak.

Apakah itu masuk akal?

Saya pikir Jon Skeet memiliki jawaban yang benar. Saya hanya ingin menambahkan bahwa Anda dapat mengakses variabel gelap dari superclasses superclasses dengan melemparkan this:

interface I { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1 { int x = 2; }
class T3 extends T2 {
        int x = 3;
        void test() {
                System.out.println("x=\t\t"          + x);
                System.out.println("super.x=\t\t"    + super.x);
                System.out.println("((T2)this).x=\t" + ((T2)this).x);
                System.out.println("((T1)this).x=\t" + ((T1)this).x);
                System.out.println("((I)this).x=\t"  + ((I)this).x);
        }
}

class Test {
        public static void main(String[] args) {
                new T3().test();
        }
}

yang menghasilkan output:

x = 3
super.x = 2
((T2) ini) .x = 2
((T1) ini) .x = 1
((I) ini) .x = 0

(contoh dari JLS )

Namun, ini tidak berfungsi untuk pemanggilan metode karena pemanggilan metode ditentukan berdasarkan tipe runtime objek.

Saya pikir kode berikut memungkinkan untuk menggunakan super.super ... super.method () dalam banyak kasus. (Bahkan jika itu buruk untuk melakukannya)

Pendeknya

1. buat instance sementara dari tipe leluhur
2. salin nilai bidang dari objek asli ke objek sementara
3. aktifkan metode target pada objek sementara
4. salin nilai yang dimodifikasi kembali ke objek asli

Penggunaan:

public class A {
   public void doThat() { ... }
}

public class B extends A {
   public void doThat() { /* don't call super.doThat() */ }
}

public class C extends B {
   public void doThat() {
      Magic.exec(A.class, this, "doThat");
   }
}


public class Magic {
    public static <Type, ChieldType extends Type> void exec(Class<Type> oneSuperType, ChieldType instance,
            String methodOfParentToExec) {
        try {
            Type type = oneSuperType.newInstance();
            shareVars(oneSuperType, instance, type);
            oneSuperType.getMethod(methodOfParentToExec).invoke(type);
            shareVars(oneSuperType, type, instance);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    private static <Type, SourceType extends Type, TargetType extends Type> void shareVars(Class<Type> clazz,
            SourceType source, TargetType target) throws IllegalArgumentException, IllegalAccessException {
        Class<?> loop = clazz;
        do {
            for (Field f : loop.getDeclaredFields()) {
                if (!f.isAccessible()) {
                    f.setAccessible(true);
                }
                f.set(target, f.get(source));
            }
            loop = loop.getSuperclass();
        } while (loop != Object.class);
    }
}

Saya tidak memiliki reputasi yang cukup untuk berkomentar sehingga saya akan menambahkan ini ke jawaban lain.

Jon Skeet menjawab dengan sangat baik, dengan contoh yang indah. Matt B ada benarnya: tidak semua superclasses memiliki supers. Kode Anda akan rusak jika Anda memanggil super dari super yang tidak memiliki super.

Pemrograman berorientasi objek (yang Java) adalah semua tentang objek, bukan fungsi. Jika Anda ingin pemrograman berorientasi tugas, pilih C ++ atau yang lainnya. Jika objek Anda tidak sesuai dengan kelas supernya, maka Anda perlu menambahkannya ke "kelas kakek-nenek", membuat kelas baru, atau menemukan super lain yang cocok dengannya.

Secara pribadi, saya menemukan keterbatasan ini sebagai salah satu kekuatan terbesar Jawa. Kode agak kaku dibandingkan dengan bahasa lain yang saya gunakan, tetapi saya selalu tahu apa yang diharapkan. Ini membantu dengan tujuan "sederhana dan akrab" Jawa. Dalam pikiran saya, memanggil super.super tidak sederhana atau akrab. Mungkin para pengembang merasakan hal yang sama?

Ada beberapa alasan bagus untuk melakukan ini. Anda mungkin memiliki subkelas yang memiliki metode yang diterapkan secara salah, tetapi metode induk diimplementasikan dengan benar. Karena itu milik perpustakaan pihak ketiga, Anda mungkin tidak dapat / tidak mau mengubah sumbernya. Dalam hal ini, Anda ingin membuat subkelas tetapi mengganti satu metode untuk memanggil metode super.super.

Seperti yang ditunjukkan oleh beberapa poster lain, dimungkinkan untuk melakukan ini melalui refleksi, tetapi harus mungkin untuk melakukan sesuatu seperti

(SuperSuperClass ini) .theMethod ();

Saya sedang menangani masalah ini sekarang - perbaikan cepatnya adalah dengan menyalin dan menempelkan metode superclass ke dalam metode sub-kelas :)

Selain poin yang sangat baik yang telah dibuat orang lain, saya pikir ada alasan lain: bagaimana jika superclass tidak memiliki superclass?

Karena setiap kelas secara alami meluas (setidaknya) Object, super.whatever()akan selalu merujuk pada metode dalam superclass. Tetapi bagaimana jika kelas Anda hanya meluas Object- apa yang akan super.superdirujuk kemudian? Bagaimana seharusnya perilaku itu ditangani - kesalahan kompiler, NullPointer, dll?

Saya pikir alasan utama mengapa ini tidak diperbolehkan adalah karena melanggar enkapsulasi, tetapi ini mungkin juga merupakan alasan kecil.

Saya pikir jika Anda menimpa metode dan ingin semua versi super-kelas itu (seperti, katakan untuk equals), maka Anda hampir selalu ingin memanggil versi superclass langsung terlebih dahulu, yang mana akan memanggil versi superclass pada gilirannya jika ia menginginkannya. .

Saya pikir itu jarang masuk akal (jika sama sekali. Saya tidak bisa memikirkan kasus di mana ia melakukannya) untuk memanggil versi superclass sewenang-wenang dari suatu metode. Saya tidak tahu apakah itu mungkin sama sekali di Jawa. Itu bisa dilakukan di C ++:

this->ReallyTheBase::foo();

Di tebak, karena tidak sering digunakan. Satu-satunya alasan saya bisa melihatnya menggunakannya adalah jika orang tua langsung Anda telah menimpa beberapa fungsi dan Anda mencoba mengembalikannya kembali ke aslinya.

Yang menurut saya bertentangan dengan prinsip-prinsip OO, karena orang tua langsung kelas harus lebih dekat dengan kelas Anda daripada kakek-nenek.

Lihatlah ini proyek Github, terutama variabel objectHandle. Proyek ini menunjukkan bagaimana memanggil metode kakek-nenek secara aktual dan akurat.

Untuk berjaga-jaga jika tautannya rusak, berikut adalah kodenya:

import lombok.val;
import org.junit.Assert;
import org.junit.Test;

import java.lang.invoke.*;

/*
Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.
Please don't actually do this... :P
*/
public class ImplLookupTest {
    private MethodHandles.Lookup getImplLookup() throws NoSuchFieldException, IllegalAccessException {
        val field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
        field.setAccessible(true);
        return (MethodHandles.Lookup) field.get(null);
    }

    @Test
    public void test() throws Throwable {
        val lookup = getImplLookup();
        val baseHandle = lookup.findSpecial(Base.class, "toString",
            MethodType.methodType(String.class),
            Sub.class);
        val objectHandle = lookup.findSpecial(Object.class, "toString",
            MethodType.methodType(String.class),
            // Must use Base.class here for this reference to call Object's toString
            Base.class);
        val sub = new Sub();
        Assert.assertEquals("Sub", sub.toString());
        Assert.assertEquals("Base", baseHandle.invoke(sub));
        Assert.assertEquals(toString(sub), objectHandle.invoke(sub));
    }

    private static String toString(Object o) {
        return o.getClass().getName() + "@" + Integer.toHexString(o.hashCode());
    }

    public class Sub extends Base {
        @Override
        public String toString() {
            return "Sub";
        }
    }

    public class Base {
        @Override
        public String toString() {
            return "Base";
        }
    }
}

Selamat Coding !!!!

Saya akan meletakkan tubuh metode super.super di metode lain, jika mungkin

class SuperSuperClass {
    public String toString() {
        return DescribeMe();
    }

    protected String DescribeMe() {
        return "I am super super";
    }
}

class SuperClass extends SuperSuperClass {
    public String toString() {
        return "I am super";
    }
}

class ChildClass extends SuperClass {
    public String toString() {
        return DescribeMe();
    }
}

Atau jika Anda tidak dapat mengubah kelas super-super, Anda dapat mencoba ini:

class SuperSuperClass {
    public String toString() {
        return "I am super super";
    }
}

class SuperClass extends SuperSuperClass {
    public String toString() {
        return DescribeMe(super.toString());
    }

    protected String DescribeMe(string fromSuper) {
        return "I am super";
    }
}

class ChildClass extends SuperClass {
    protected String DescribeMe(string fromSuper) {
        return fromSuper;
    }
}

Dalam kedua kasus tersebut,

new ChildClass().toString();

hasil untuk "Saya super super"

Tampaknya akan mungkin untuk setidaknya mendapatkan kelas dari superclass superclass, meskipun tidak harus contoh itu, menggunakan refleksi; jika ini mungkin berguna, silakan pertimbangkan Javadoc di http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Class.html#getSuperclass ()

public class A {

     @Override
     public String toString() {
          return "A";
     }

}


public class B extends A {

     @Override
     public String toString() {
          return "B";
     }

}

public class C extends B {

     @Override
     public String toString() {
          return "C";
     }

}


public class D extends C {

     @Override
     public String toString() {
          String result = "";
          try {
                result = this.getClass().getSuperclass().getSuperclass().getSuperclass().newInstance().toString();
          } catch (InstantiationException ex) {
                Logger.getLogger(D.class.getName()).log(Level.SEVERE, null, ex);
          } catch (IllegalAccessException ex) {
                Logger.getLogger(D.class.getName()).log(Level.SEVERE, null, ex);
          }
          return result;
     }

}

public class Main {

     public static void main(String... args) {
          D d = new D();
          System.out.println(d);

     }
}

run: A BUILD SUCCESSFUL (total waktu: 0 detik)

Memanggil super.super.method () masuk akal ketika Anda tidak dapat mengubah kode kelas dasar. Ini sering terjadi ketika Anda memperluas perpustakaan yang ada.

Tanyakan kepada diri Anda terlebih dahulu, mengapa Anda memperluas kelas itu? Jika jawabannya "karena saya tidak bisa mengubahnya" maka Anda dapat membuat paket dan kelas yang tepat di aplikasi Anda, dan menulis ulang metode nakal atau membuat delegasi:

package com.company.application;

public class OneYouWantExtend extends OneThatContainsDesiredMethod {

    // one way is to rewrite method() to call super.method() only or 
    // to doStuff() and then call super.method()

    public void method() {
        if (isDoStuff()) {
            // do stuff
        }
        super.method();
    }

    protected abstract boolean isDoStuff();


    // second way is to define methodDelegate() that will call hidden super.method()

    public void methodDelegate() {
        super.method();
    }
    ...
}

public class OneThatContainsDesiredMethod {

    public void method() {...}
    ...
}

Misalnya, Anda dapat membuat kelas org.springframework.test.context.junit4.SpringJUnit4ClassRunner di aplikasi Anda sehingga kelas ini harus dimuat sebelum yang asli dari toples. Kemudian tulis ulang metode atau konstruktor.

Perhatian: Ini adalah retasan absolut, dan sangat TIDAK disarankan untuk digunakan tetapi BEKERJA! Penggunaan pendekatan ini berbahaya karena kemungkinan masalah dengan pemuat kelas. Ini juga dapat menyebabkan masalah setiap kali Anda akan memperbarui perpustakaan yang berisi kelas yang ditimpa.

Saya memiliki situasi seperti ini ketika arsitekturnya membangun fungsionalitas umum dalam CustomBaseClass umum yang mengimplementasikan atas nama beberapa kelas turunan. Namun, kita perlu mengelak dari logika umum untuk metode khusus untuk kelas turunan tertentu. Dalam kasus seperti itu, kita harus menggunakan implementasi super.super.methodX.

Kami mencapai ini dengan memperkenalkan anggota boolean di CustomBaseClass, yang dapat digunakan untuk secara selektif menunda implementasi kustom dan menghasilkan implementasi kerangka kerja default jika diinginkan.

        ...
        FrameworkBaseClass (....) extends...
        {
           methodA(...){...}
           methodB(...){...}
        ...
           methodX(...)
        ...
           methodN(...){...}

        }
        /* CustomBaseClass overrides default framework functionality for benefit of several derived classes.*/
        CustomBaseClass(...) extends FrameworkBaseClass 
        {
        private boolean skipMethodX=false; 
        /* implement accessors isSkipMethodX() and setSkipMethodX(boolean)*/

           methodA(...){...}
           methodB(...){...}
        ...
           methodN(...){...}

           methodX(...){
                  if (isSkipMethodX()) {
                       setSKipMethodX(false);
                       super.methodX(...);
                       return;
                       }
                   ... //common method logic
            }
        }

        DerivedClass1(...) extends CustomBaseClass
        DerivedClass2(...) extends CustomBaseClass 
        ...
        DerivedClassN(...) extends CustomBaseClass...

        DerivedClassX(...) extends CustomBaseClass...
        {
           methodX(...){
                  super.setSKipMethodX(true);
                  super.methodX(...);
                       }
        }

Namun, dengan prinsip arsitektur yang baik diikuti dalam kerangka kerja serta aplikasi, kita dapat menghindari situasi seperti itu dengan mudah, dengan menggunakan pendekatan hasA, bukan pendekatan isA. Tetapi setiap saat itu tidak terlalu praktis untuk mengharapkan arsitektur yang dirancang dengan baik di tempat, dan karenanya perlu untuk menjauh dari prinsip-prinsip desain yang solid dan memperkenalkan hacks seperti ini. Hanya 2 sen saya ...

@ Jon Skeet Penjelasan yang bagus. IMO jika seseorang ingin memanggil metode super.super maka seseorang harus ingin mengabaikan perilaku orangtua langsung, tetapi ingin mengakses perilaku grand parent. Ini dapat dicapai melalui contoh Dari. Seperti kode di bawah ini

public class A {
    protected void printClass() {
        System.out.println("In A Class");
    }
}

public class B extends A {

    @Override
    protected void printClass() {
        if (!(this instanceof C)) {
            System.out.println("In B Class");
        }
        super.printClass();
    }
}

public class C extends B {
    @Override
    protected void printClass() {
        System.out.println("In C Class");
        super.printClass();
    }
}

Ini kelas pengemudi,

public class Driver {
    public static void main(String[] args) {
        C c = new C();
        c.printClass();
    }
}

Output dari ini akan menjadi

In C Class
In A Class

Perilaku printClass kelas B akan diabaikan dalam kasus ini. Saya tidak yakin apakah ini praktik yang ideal atau bagus untuk mencapai super.super, tetapi masih berfungsi.

Jika Anda pikir Anda akan membutuhkan superclass, Anda bisa mereferensikannya dalam variabel untuk kelas itu. Sebagai contoh:

public class Foo
{
  public int getNumber()
  {
    return 0;
  }
}

public class SuperFoo extends Foo
{
  public static Foo superClass = new Foo();
  public int getNumber()
  {
    return 1;
  }
}

public class UltraFoo extends Foo
{
  public static void main(String[] args)
  {
    System.out.println(new UltraFoo.getNumber());
    System.out.println(new SuperFoo().getNumber());
    System.out.println(new SuperFoo().superClass.getNumber());
  }
  public int getNumber()
  {
    return 2;
  }
}

Harus mencetak:

2
1
0

IMO, ini cara bersih untuk mencapai super.super.sayYourName()perilaku di Jawa.

public class GrandMa {  
    public void sayYourName(){  
        System.out.println("Grandma Fedora");  
    }  
}  

public class Mama extends GrandMa {  
    public void sayYourName(boolean lie){  
        if(lie){   
            super.sayYourName();  
        }else {  
            System.out.println("Mama Stephanida");  
        }  
    }  
}  

public class Daughter extends Mama {  
    public void sayYourName(boolean lie){  
        if(lie){   
            super.sayYourName(lie);  
        }else {  
            System.out.println("Little girl Masha");  
        }  
    }  
}  

public class TestDaughter {
    public static void main(String[] args){
        Daughter d = new Daughter();

        System.out.print("Request to lie: d.sayYourName(true) returns ");
        d.sayYourName(true);
        System.out.print("Request not to lie: d.sayYourName(false) returns ");
        d.sayYourName(false);
    }
}

Keluaran:

Request to lie: d.sayYourName(true) returns Grandma Fedora
Request not to lie: d.sayYourName(false) returns Little girl Masha

Saya pikir ini adalah masalah yang melanggar perjanjian warisan.
Dengan memperluas kelas Anda mematuhi / menyetujui perilakunya, fitur
Sementara saat menelepon super.super.method(), Anda ingin melanggar perjanjian kepatuhan Anda sendiri.

Anda tidak bisa memilih cherry dari kelas super .

Namun, mungkin ada situasi ketika Anda merasa perlu menelepon super.super.method()- biasanya tanda desain yang buruk, dalam kode Anda atau dalam kode yang Anda warisi!
Jika kelas super dan super super tidak dapat di-refactored (beberapa kode lawas), maka pilihlah komposisi daripada warisan.

Pemecahan enkapsulasi adalah ketika Anda @Override beberapa metode dengan memecah kode enkapsulasi. Metode yang dirancang untuk tidak diganti akan ditandai final .

Dalam C # Anda dapat memanggil metode leluhur seperti ini:

public class A
    internal virtual void foo()
...
public class B : A
    public new void foo()
...
public class C : B
    public new void foo() {
       (this as A).foo();
    }

Anda juga dapat melakukan ini di Delphi:

type
   A=class
      procedure foo;
      ...
   B=class(A)
     procedure foo; override;
     ...
   C=class(B)
     procedure foo; override;
     ...
A(objC).foo();

Tetapi di Jawa Anda dapat melakukan fokus seperti itu hanya dengan beberapa peralatan. Salah satu cara yang mungkin adalah:

class A {               
   int y=10;            

   void foo(Class X) throws Exception {  
      if(X!=A.class)
         throw new Exception("Incorrect parameter of "+this.getClass().getName()+".foo("+X.getName()+")");
      y++;
      System.out.printf("A.foo(%s): y=%d\n",X.getName(),y);
   }
   void foo() throws Exception { 
      System.out.printf("A.foo()\n");
      this.foo(this.getClass()); 
   }
}

class B extends A {     
   int y=20;            

   @Override
   void foo(Class X) throws Exception { 
      if(X==B.class) { 
         y++; 
         System.out.printf("B.foo(%s): y=%d\n",X.getName(),y);
      } else { 
         System.out.printf("B.foo(%s) calls B.super.foo(%s)\n",X.getName(),X.getName());
         super.foo(X);
      } 
   }
}

class C extends B {     
   int y=30;            

   @Override
   void foo(Class X) throws Exception { 
      if(X==C.class) { 
         y++; 
         System.out.printf("C.foo(%s): y=%d\n",X.getName(),y);
      } else { 
         System.out.printf("C.foo(%s) calls C.super.foo(%s)\n",X.getName(),X.getName());
         super.foo(X);
      } 
   }

   void DoIt() {
      try {
         System.out.printf("DoIt: foo():\n");
         foo();         
         Show();

         System.out.printf("DoIt: foo(B):\n");
         foo(B.class);  
         Show();

         System.out.printf("DoIt: foo(A):\n");
         foo(A.class);  
         Show();
      } catch(Exception e) {
         //...
      }
   }

   void Show() {
      System.out.printf("Show: A.y=%d, B.y=%d, C.y=%d\n\n", ((A)this).y, ((B)this).y, ((C)this).y);
   }
} 

output hasil objC.DoIt ():

DoIt: foo():
A.foo()
C.foo(C): y=31
Show: A.y=10, B.y=20, C.y=31

DoIt: foo(B):
C.foo(B) calls C.super.foo(B)
B.foo(B): y=21
Show: A.y=10, B.y=21, C.y=31

DoIt: foo(A):
C.foo(A) calls C.super.foo(A)
B.foo(A) calls B.super.foo(A)
A.foo(A): y=11
Show: A.y=11, B.y=21, C.y=31

Ini mudah dilakukan. Contohnya:

C subclass dari B dan B subclass dari A. Keduanya memiliki metode methodName () misalnya.

public abstract class A {

    public void methodName() {
        System.out.println("Class A");
    }

}

public class B extends A {

    public void methodName() {
        super.methodName();
        System.out.println("Class B");
    }

    // Will call the super methodName
    public void hackSuper() {
        super.methodName();
    }

}

public class C extends B {

    public static void main(String[] args) {
        A a = new C();
        a.methodName();
    }

    @Override
    public void methodName() {
        /*super.methodName();*/
        hackSuper();
        System.out.println("Class C");
    }

}

Jalankan kelas C Output akan menjadi: Kelas A Kelas C

Alih-alih output: Kelas A Kelas B Kelas C

public class SubSubClass extends SubClass {

    @Override
    public void print() {
        super.superPrint();
    }

    public static void main(String[] args) {
        new SubSubClass().print();
    }
}

class SuperClass {

    public void print() {
        System.out.println("Printed in the GrandDad");
    }
}

class SubClass extends SuperClass {

    public void superPrint() {
        super.print();
    }
}

Output: Dicetak di GrandDad

Kata kunci super hanyalah cara untuk memanggil metode dalam superclass. Dalam tutorial Java: https://docs.oracle.com/javase/tutorial/java/IandI/super.html

Jika metode Anda menimpa salah satu metode superclass-nya, Anda dapat memanggil metode yang ditimpa melalui penggunaan kata kunci super.

Jangan percaya bahwa itu adalah referensi dari objek super !!! Tidak, itu hanya kata kunci untuk memanggil metode dalam superclass.

Berikut ini sebuah contoh:

class Animal {
    public void doSth() {
        System.out.println(this);   // It's a Cat! Not an animal!
        System.out.println("Animal do sth.");
    }
}

class Cat extends Animal {
    public void doSth() {
        System.out.println(this);
        System.out.println("Cat do sth.");
        super.doSth();
    }
}

Saat Anda menelepon cat.doSth(), metode doSth()di kelas Animalakan dicetak thisdan itu adalah kucing.