Wenn Sie einen fließenden Ansatz verwenden, können Sie das folgende Szenario haben:

public class Foo<T extends a>{

    public Foo<T> someMethod(){
          System.out.println("foo");
          return this;
    }

}


public class Bar<T extends b> extends Foo<T> {

         public Bar<T> barMethod(){

            System.out.println("bar");
            return this;
         }

}


public class a{}
public class b extends a{}

Eine Stärke einer fließenden Schnittstelle besteht darin, dass Sie Methodenaufrufe verketten können. Während Bar jedoch someMethod () geerbt hat, lautet der Rückgabetyp Foo not Bar, wodurch die folgende Kette unterbrochen wird:

new Bar<b>().someMethod().barMethod();

Eine Antwort könnte sein, @Overrides für jede geerbte Methode hinzuzufügen, so dass Bar die zusätzliche Methode hat:

 @Override
 public Bar<T> someMethod(){
          System.out.println("foo");
          return this;
    }

Aber in großen Klassen und erweiterten Klassenhierarchien kann dies sicherlich ein Durcheinander von Redundanzen beweisen ?! Gibt es einen geeigneten Rückgabetyp für fließende Methoden, bei dem jede Klasse, die ihn erbt, ein Objekt ihres spezifischen Typs zurückgibt (sodass wir Methoden ohne Casts verketten können)?

Ich habe es versucht:

        public <U extends Foo<T>> U someMethod(){
          System.out.println("foo");
          return this;
    }

Leider ohne Erfolg. Ich hoffe, dass jemand eine einfache und elegante Lösung für dieses Problem kennt. Das Projekt ist groß und muss daher nach Möglichkeit wartbar und erweiterbar sein.

Vielen Dank für jede Hilfe, die Sie in diesem Szenario leisten können.