Jak rozszerzyć klasę, która wraca to w swoich metodach

Question

Pytanie jest proste, ale nie jestem pewien, że to możliwe, aby to zrobić ...

jeśli mamy klasę jak

class A { 
    private int foo; 

    public A(int bar) { 
     this.foo = bar; 
    } 

    public A setFoo(int bar) { 
     this.foo = bar; 
     return this; 
    } 

    public int getFoo() { 
     return this.foo; 
    } 

    public void doSomething() { 
     this.foo++; 
    } 
} 

widzimy, że jest to po prostu klasa z prywatnym członkiem i seter/getter. Ciekawostką jest, że w celu umożliwienia łączenia metod, setter wraca this.

Więc możemy robić rzeczy tak:

A a = new A(0); 
a.setFoo(1).doSomething(); 

Problem polega na tym, kiedy staram się rozszerzyć, że klasa dodać niektóre funkcje wykonawcze interfejs podobny do tego

class B extends A implements I { 
    public B(int bar) { 
     this.super(bar); 
    } 

    public void methodI() { 
     // whatever 
    } 
} 

To wydaje się ok, dopóki Zaczynam go używać w ten sposób:

B b = new B(1); 
b.setFoo(2).methodI(); 

Ponieważ setFoo jest rzeczywiście retu rning wystąpienie A, a nie instancja B, aw A methodI nie istnieje ...

Jakiekolwiek obejście? Dzięki.

Nawiasem mówiąc, po prostu napisał podstawowy kod wystarczy, aby zrozumieć, ale jeśli chcesz wiedzieć więcej, jestem po prostu staramy się rozszerzyć niektóre z podstawowych klas libgdx (jak Math.Vector2, Math.Vector3) do implementuj Poolable.

Answer 1

Klasa B może zastąpić metodę setFoo i zmienić wartość r eturn type to B, ponieważ B jest bardziej szczegółową wersją A. Nadpisywana metoda może mieć bardziej specyficzny typ zwracania. na przykład

class B extends A implements I { 
    public B(int bar) { 
     this.super(bar); 
    } 

    public void methodI() { 
     // whatever 
    } 

    @Override 
    public B setFoo(int bar) { 
     this.foo = bar; 
     return this; 
    } 
} 

Answer 2

Wystarczy setFoo() void powrotny, a następnie można zrobić:

B b = new B(1); b.setFoo(2); b.methodI();

Answer 3

Należy użyć rodzajowych tutaj:

public class A<T extends A<?>> { 

    public T self() { 
     return (T) this; 
    } 

    private int foo; 

    public A(int bar) { 
     this.foo = bar; 
    } 

    public T setFoo(int bar) { 
     this.foo = bar; 
     return self(); 
    } 

    public int getFoo() { 
     return this.foo; 
    } 

    public void doSomething() { 
     this.foo++; 
    } 

} 

public class B<T extends B<?>> extends A<T> implements I { 

    public B(int bar) { 
     this.super(bar); 
    } 

    public void methodI() { 
     // whatever 
    } 
} 

Teraz będzie można korzystać z takich łańcuchu połączeń :

B b = new B(1); 
b.setFoo(2).methodI(); 

Answer 4

Zrobiłem to również wcześniej. Nie myśl, że jest proste rozwiązanie. Rozważmy nadrzędnymi wszystkie metody ustawiające:

class B extends A implements I { 
    @Override 
    public A setFoo(int bar) { 
     super.setFoo(bar); 
     return this; 
    } 
} 

Answer 5

Dla kompletności (tzn ja nie uważam tego za lepszą rozwiązanie niż wymienione powyżej, po prostu może być właściwe) i na pewno nie jest to odpowiedź na tytule pytanie, ale możliwe rozwiązanie twojego problemu.

Można rozważyć zastosowanie metod oferowanych przez Javę 8. Jest to szczególnie przydatne w celu dodania funkcjonalności do istniejących klas.

// From LibGDX Pool.Poolable 
interface Poolable { 

    public void reset(); 
} 

// Class A untouched. 
class A { 

    private int foo; 

    public A(int bar) { 
     this.foo = bar; 
    } 

    public A setFoo(int bar) { 
     this.foo = bar; 
     return this; 
    } 

    public int getFoo() { 
     return this.foo; 
    } 

    public void doSomething() { 
     this.foo++; 
    } 
} 

// Extend Poolable to add the functionality. 
interface PoolableVector extends Poolable { 

    default void reset() { 
     // Not sure what you want to do here. 
    } 
} 

// A Poolable A trivially made. 
class B extends A implements PoolableVector { 

    public B(int b) { 
     super(b); 
    } 

}