Czy mogę mieć abstrakcyjną klasę konstruktora w języku Java z łańcuchem metod bez wykonywania niebezpiecznych operacji?

Question

Próbuję mieć abstrakcyjną klasę podstawową dla niektórych klas budowniczych, dzięki czemu mogę z łatwością ponownie użyć kodu między implementacjami Buildera. Chcę, aby moi konstruktorzy obsługiwali metodę łańcuchową, dlatego metoda musi zwracać "tę" instancję najbardziej konkretnego typu. Pomyślałem, że prawdopodobnie mógłbym to zrobić z lekami generycznymi. Niestety nie udało mi się tego zrobić bez użycia niebezpiecznych operacji. Czy to możliwe?

Przykładowy kod tego, jak próbuję go (i jak działa) poniżej. Chciałbym uniknąć rzutowania na T w "foo()" (co powoduje niezaznaczone ostrzeżenie), czy można to zrobić?

public class Builders 
{ 
    public static void main(final String[] args) 
    { 
     new TheBuilder().foo().bar().build(); 
    } 
} 


abstract class AbstractBuilder<T extends AbstractBuilder<?>> 
{ 
    public T foo() 
    { 
     // set some property 
     return (T) this; 
    } 
} 


class TheBuilder extends AbstractBuilder<TheBuilder> 
{ 
    public TheBuilder bar() 
    { 
     // set some other property 
     return this; 
    } 

    public Object build() 
    { 
     return new Object(); 
    } 
} 

Answer 1

Chcesz zadeklarować T jak extends AbstractBuilder<T> w AbstractBuilder.

Użyj metody abstract protected, aby uzyskać this typu T.

abstract class AbstractBuilder<T extends AbstractBuilder<T>> { 
    protected abstract T getThis(); 

    public T foo() { 
     // set some property 
     return getThis(); 
    } 
} 


class TheBuilder extends AbstractBuilder<TheBuilder> { 
    @Override protected TheBuilder getThis() { 
     return this; 
    } 
    ... 
} 

Alternatywnie, spadek parametr typu rodzajowego, polegać na kowariantna rodzajów powrotów i dokonać czyszczenia kodu dla klientów (chociaż zwykle oni używać TheBuilder zamiast dużej mierze szczegóły implementacji klasy bazowej), jeżeli czyniąc wdrożenie bardziej szczegółowe.

Answer 2

Jedną z alternatyw jest, aby nie używać rodzajowych, ale użyć nadpisania:

abstract class AbstractBuilder 
{ 
    public AbstractBuilder foo() 
    { 
     // set some property 
     return this; 
    } 
} 

class TheBuilder extends AbstractBuilder 
{ 
    @Override public TheBuilder foo() 
    { 
     super.foo(); return this; 
    } 
    public TheBuilder bar() 
    { 
     // set some other property 
     return this; 
    } 

    public Object build() 
    { 
     return new Object(); 
    } 
} 

Answer 3

To powinno pomóc:

abstract class AbstractBuilder<T extends AbstractBuilder<?>> 
{ 
    public AbstractBuilder<T> foo() 
    { 
     // set some property 
     return (AbstractBuilder<T>) this; 
    } 

    abstract AbstractBuilder<T> bar(); 
    abstract Object build(); 
}