Kiedy używasz płynnego podejścia, możesz mieć następujący scenariusz:

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{}

Siła płynnego interfejsu polega na tym, że można łączyć wywołania metod, ale podczas gdy Bar odziedziczył someMethod (), typem zwracanym jest Foo not Bar, który łamałby następujący łańcuch:

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

Jedną odpowiedzią może być dodanie @Overrides dla każdej dziedziczonej metody, tak że Bar ma dodatkową metodę:

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

Ale w dużych klasach i rozszerzonych hierarchiach klas może to z pewnością świadczyć o bałaganie nadmiarowości ?! Czy istnieje odpowiedni typ powrotu do płynnych metod, w którym każda klasa, która go dziedziczy, zwróci obiekt określonego typu (abyśmy mogli łączyć metody bez rzutów)?

Próbowałem:

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

Do niestety bezskutecznie. Mam nadzieję, że ktoś wie o prostym i eleganckim rozwiązaniu tego problemu. Projekt jest duży, więc musi być możliwy do utrzymania i rozszerzenia, jeśli to możliwe.

Dziękujemy za wszelką pomoc, jaką możesz zapewnić w tym scenariuszu.