Cuando empleas un enfoque fluido, puedes tener el siguiente escenario:

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

Un punto fuerte de una interfaz fluida es que puede encadenar invocaciones de método, pero si bien Bar ha heredado algún Método (), el tipo de retorno es Foo no Bar, lo que rompería la siguiente cadena:

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

Una respuesta podría ser agregar @Overrides para cada método heredado, de modo que Bar tenga el método adicional:

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

Pero en las clases grandes, y en las jerarquías de clases extendidas, esto puede resultar un desastre de redundancia, ¿no? ¿Hay un tipo de retorno adecuado para los métodos fluidos por el cual cada clase que lo hereda devolverá un objeto de su tipo específico (para que podamos encadenar métodos sin moldes)?

Lo intenté:

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

Para desgracia, en vano. Espero que alguien sepa de una solución simple y elegante para este problema. El proyecto es grande y, por lo tanto, debe ser mantenible y extensible si es posible.

Gracias a cualquier ayuda que pueda proporcionar en este escenario.