Verwendung des Schlüsselworts extend in Java Generics

[Jack.watts]

Gemäß der Java Generics-Dokumentation bezeichnet das Java-Schlüsselwort „extends“ in Kombination mit Generics eine Klasse, die diese Schnittstelle implementiert. Darauf aufbauend habe ich versucht, generische Klassen zu konstruieren, um dies besser nachvollziehen zu können. Hier ist ein Beispiel für meinen Code.
Code für die Schnittstelle:

package com.vipin.generics.doubtclear;

public interface DemoInterface1<T> {

    void display(T t);
}

Jetzt habe ich ein paar grundlegende Klassen geschrieben, die diese Schnittstelle implementieren:

package com.vipin.generics.doubtclear;

class myClass<T> implements DemoInterface1<T> {

    public myClass(T t) {

    }

    @Override
    public void display(T t) {
        System.out.println("Inside display method of myClass, object is ---> "+t);
    }
}

class myClass1<T> implements DemoInterface1<T> {

    public myClass1(T t) {

    }

    @Override
    public void display(T t) {
        System.out.println("Inside display method of myClass1, object is ---> "+t);
    }
}

Hier ist die Hauptklasse, die versucht, Objekte zu konstruieren:

public class DoubtClear1 {

    static <T extends DemoInterface1<T>> void myFunc(T t) {
        t.display(t);
    }

    public static void main(String[] args) {

        myClass<Integer> iObj = new myClass<Integer>(1);
        myClass1<Integer> iObj1 = new myClass1<Integer>(1);
        DoubtClear1.myFunc(iObj);

    }
}

Ich erstelle hauptsächlich myClass- und myClass1-Objekte. Wenn das Schlüsselwort "extends“ an Generics übergeben wird, kann myFunc() nach meinem Verständnis jede Objektreferenz akzeptieren, die die DemoInterface1-Schnittstelle implementiert. Das mache ich im Funktionsaufruf ==> DoubtClear1.myFunc(iObj);
Dies führt jedoch zu einem Kompilierungsfehler:

The method myFunc(T) in the type DoubtClear1 is not applicable for the arguments (myClass<Integer>)

Die Funktion myFunc(T) vom Typ DoubtClear1 gilt nicht für die Argumente (myClass). Das ist ziemlich verwirrend. Ich befolge die Anweisungen in der Dokumentation, aber es funktioniert nicht. Ich bin mir nicht sicher, ob ich dieses Konzept gut verstehe.

Generika sind meiner Meinung nach verwirrend und müssen kontinuierlich studiert werden, um wirklich zu verstehen, was das ist.

Jede Information zur Klärung dieser Frage wäre sehr willkommen.

[Tiwil]

Vielleicht hilft das https://openbook.rheinwerk-verlag.de/javainsel/11_001.html#u11 und insbesondere das https://openbook.rheinwerk-verlag.de/javainsel/11_005.html#u11.5.2

Ich gebe zu, dass Generics mich auch verwirren manchmal. Die Methode myFunc(T t) erwartet einen Typ, der DemoInterface1<T> implementiert. Was übergeben wird, ist aber eine Objektreferenz, die ganz konkret mit dem Typ Integer arbeitet und daher nicht das DemoInterface1<T> implementiert, sondern "nur" das DemoInterface1<Integer>

[maestro impostor]

Ich versuche das mal zu erklären, auch wenn es mir schwerfällt das vernünftig zu Verfassen.

public interface DemoInterface<T> {
    void display(T t);
}

Dein Interface hat eine Type Reference auf T.
T kann dabei jede Klasse (non primitive) sein, beispielsweise Integer:

public class DemoIntegerInterface implements DemoInterface<Integer> {
    @Override
    public void display(Integer integer) {
        System.out.println(integer);
    }
}

Heißt, dein T wird durch deine explizite Angabe von Integer ersetzt. Somit erwartet deine Display Methode ein Integer.

Jetzt nehmen wir mal für den einfachen Fall deine Funktion:

   static <T extends DemoInterface<T>> void fooFunction(T demoInterface) {
        demoInterface.display();
    }

Deine Displaymethode erwartet nun den Typen welcher von deinem DemoInterface referenziert wird.
Das ist aber in dem Fall *nicht* DemoInterface sondern der gebounded type. In dem Fall hier müsste ich also einen Integer übergeben.

    public static void foo() {
        DemoIntegerInterface demoInteger = new DemoIntegerInterface();
        fooFunction(1, demoInteger);
    }

    static <S, T extends DemoInterface<S>> void fooFunction(S value, T demoInterface) {
        demoInterface.display(value);
    }

In meiner fooFunction ist T ein Typ der DemoInterface implementiert und als Type Bound S hat.

 

Bezogen auf dein Beispiel ist genau das selbe

public class DemoInterfaceTwo<T> implements DemoInterface<T> {
    @Override
    public void display(T t) {
        System.out.println(t);
    }
}

  static <T extends DemoInterface<T>> void fooFunction(T demoInterface) {
        demoInterface.display(demoInterface);
    }

Die fooFunction würde nun erwarten das T ein Typ ist der DemoInterface mit sich selbst Parametrisiert extended.

Also ein DemoInterface von Demointerface (T ==> DemoInterface) in deinem Fall.

Wenn du bei deinem Beispiel bleiben willst dann musst du den Übergabeparameter ohne Bounding machen

static void fooFunction(DemoInterface<?> demoInterface)

Heißt die Methode erwartet einen Instanz von Demo Interface wo der Typ egal ist.

Oder

 static <T> void  fooFunction(DemoInterface<T> demoInterface)

 

Für dein Beispiel:

 

public interface DemoInterface1<T> {
        void display(T t);
    }
}

public class MyClass<T> implements DemoInterface1<T> {
    @Override
    public void display(T t) {

    }
}

  static <T extends DemoInterface<T>> void myFunc(T t) {
        t.display(t);
    }

    public static void foo() {
        MyClass<MyClass> test = new MyClass<>();
        myFunc(test);
    }

EDIT

Dein Ansatz würde funktionieren, wenn myFunc so aussehen würde: 

  static <T extends DemoInterface> void myFunc(T t) {
        t.display(t);
    }

Heißt - T ist irgendein typ der DemoIterface implementiert

<T extends DemoInterface<T>> => T ist ein Typ der DemoInterface implementiert mit dem Typen sich selbst

Bearbeitet 13. Dezember 2022 von maestro impostor

[RealPride]

Ich bin kein Coder/Developer, aber war trotzdem mal neugierig wie sich ChatGPT hier schlägt. Ihr könnt ja wohl eher was dazu sagen, hab jetzt deinen ganzen Beitrag copy+pasted, daraufhin kam diese Antwort:

Wenn man sich da stück für stück antastet, kann ChatGPT ein super Assistent, für Administratoren, Developer oder sonstiges auch sein. Man muss nur wissen, wie man die Fragen effektiv stellt. Jedoch ist mir aufgefallen dass sich auch hin und wieder da mal ein paar Fehler einschleichen.