Generic Java Generator

Question

Załóżmy, że potrzebuję jakiegoś DerivedBuilder do rozszerzenia niektórych BaseBuilder. Podstawowy program budujący ma pewną metodę, taką jak foo (która zwraca BaseBuilder). Wyprowadzony konstruktor ma metodę bar. Metoda bar powinna zostać wywołana po metodzie foo. W tym celu należy go mogę zastąpić foo metodę w DerivedBuilder tak:

@Override 
public DerivedBuilder foo() { 
    super.foo(); 
    return this; 
} 

Problemem jest to, że BaseBuilder ma wiele sposobów, takich jak foo i muszę zastąpić każdą z nich. Nie chcę, aby to zrobić, więc starałem się używać rodzajowych:

public class BaseBuilder<T extends BaseBuilder> { 
    ... 

    public T foo() { 
     ... 
     return (T)this; 
    } 
} 

public class DerivedBuilder<T extends DerivedBuilder> extends BaseBuilder<T> { 
    public T bar() { 
     ... 
     return (T)this; 
    } 
} 

Ale problemem jest to, że nadal nie można napisać

new DerivedBuilder<DerivedBuilder>() 
     .foo() 
     .bar() 

Nawet T tutaj jest DerivedBuilder. Co mogę zrobić, aby nie zastąpić wielu funkcji?

Answer 1

Twój problem jest definicja DerivedBuilder:

class DerivedBuilder<T extends DerivedBuilder>; 

A potem uruchamianiu go typu usunięte argumentu new DerivedBuilder<DerivedBuilder<...what?...>>().

Musisz w pełni zdefiniowany typ pochodzący coś takiego:

public class BaseBuilder<T extends BaseBuilder<T>> { 
    @SuppressWarnings("unchecked") 
    public T foo() { 
     return (T)this; 
    } 
} 

public class DerivedBuilder extends BaseBuilder<DerivedBuilder> { 
    public DerivedBuilder bar() { 
     return this; 
    } 
} 

Sprawdź ideone.com.

Answer 2

Z twojego pytania wiem, że metoda foo() powinna zostać wykonana przed paskiem metody().
Jeśli jest to prawidłowe, można zastosować wzór szablonu.
Utwórz abstrakcyjny pasek metod w BaseBuilder.
A nowa metoda mówi "szablon". Szablon metody definiuje sekwencję - najpierw wykonywane jest polecenie foo(), a następnie bar().
DerivedBuilder zapewni implementację paska metod.

public abstract class BaseBuilder { 

    public void foo(){ 
     System.out.println("foo"); 
    } 

    public abstract void bar(); 

    public void template(){ 
     foo(); 
     bar(); 
    } 
} 

public class DerivedBuilder extends BaseBuilder{ 

    @Override 
    public void bar() { 
     System.out.println("bar");  
    } 

    public static void main(String[] args) { 
     BaseBuilder builder = new DerivedBuilder(); 
     builder.template(); 
    } 
} 

Nadzieja to pomaga.

Answer 3

Zamiast odlewania return (T) this; Tutaj zrobiłem Class.cast(this).

Aby zrealizować:

BaseBuilder.build(ExtendedBuilder.class).foo().bar().foo().bar(); 

Każda klasa w hierarcha musi znać rzeczywistą końcową klasę dzieci, dlatego zdecydowałem się dokonać metoda fabrykabuild w klasie bazowej.

Obsada this do rzeczywistego dziecka jest również wykonywana w ostatecznej metodzie klasy bazowej, podając return me();.

class BaseBuilder<B extends BaseBuilder<B>> { 

    protected Class<B> type; 

    public static <T extends BaseBuilder<T>> T build(Class<T> type) { 
     try { 
      T b = type.newInstance(); 
      b.type = type; 
      return b; 
     } catch (InstantiationException | IllegalAccessException e) { 
      throw new IllegalStateException(e); 
     } 
    } 

    protected final B me() { 
     return type.cast(this); 
    } 

    B foo() { 
     System.out.println("foo"); 
     return me(); 
    } 
} 

class ExtendedBuilder extends BaseBuilder<ExtendedBuilder> { 

    ExtendedBuilder bar() { 
     System.out.println("bar"); 
     return me(); 
    } 
} 

Answer 4

Oprócz BeyelerStudios's answer, jeśli chcesz zagnieździć dalej, można po prostu użyć tego:

class Base<T extends Base<?>> { 
    public T alpha() { return (T) this; } 
    public T bravo() { return (T) this; } 
    public T foxtrot() { return (T) this; } 
} 

class Derived<T extends Derived<?>> extends Base<T> { 
    public T charlie() { return (T) this; } 
    public T golf() { return (T) this; } 
} 

class FurtherDerived<T extends FurtherDerived<?>> extends Derived<T> { 
    public T delta() { return (T) this; } 
    public T hotel() { return (T) this; } 
} 

class MuchFurtherDerived<T extends MuchFurtherDerived<?>> extends FurtherDerived<T> { 
    public T echo() { return (T) this; } 
} 

public static void main(String[] args) { 
    new MuchFurtherDerived<MuchFurtherDerived<?>>() 
     .alpha().bravo().charlie().delta().echo().foxtrot().golf().hotel() 
     .bravo().golf().delta().delta().delta().hotel().alpha().echo() 
     .echo().alpha().hotel().foxtrot(); 
}