Methodenketten + Vererbung spielen nicht gut zusammen?

Question

This question has been asked in a C++ context aber ich bin neugierig auf Java. Die Bedenken über virtuelle Methoden gelten nicht (glaube ich), aber wenn Sie diese Situation haben:

abstract class Pet 
{ 
    private String name; 
    public Pet setName(String name) { this.name = name; return this; }   
} 

class Cat extends Pet 
{ 
    public Cat catchMice() { 
     System.out.println("I caught a mouse!"); 
     return this; 
    } 
} 

class Dog extends Pet 
{ 
    public Dog catchFrisbee() { 
     System.out.println("I caught a frisbee!"); 
     return this; 
    } 
} 

class Bird extends Pet 
{ 
    public Bird layEgg() { 
     ... 
     return this; 
    } 
} 


{ 
    Cat c = new Cat(); 
    c.setName("Morris").catchMice(); // error! setName returns Pet, not Cat 
    Dog d = new Dog(); 
    d.setName("Snoopy").catchFrisbee(); // error! setName returns Pet, not Dog 
    Bird b = new Bird(); 
    b.setName("Tweety").layEgg(); // error! setName returns Pet, not Bird 
} 

In dieser Art von Klassenhierarchie, ist es eine Möglichkeit, this in einer Weise zurückzugeben, die nicht (effektiv) upcast den Objekttyp?

Answer 1

Wenn Sie nicht markiert Guss Warnungen von Ihrem Compiler (und wollen nicht @SuppressWarnings („ungeprüft“)) vermeiden wollen, dann müssen Sie ein tun wenig mehr:

Zunächst einmal Ihre Definition von Pet muss selbstbezogen sein, weil Pet immer ein generischer Typ ist:

abstract class Pet <T extends Pet<T>> 

Zweitens ist die (T) this Umwandlung in setName ebenfalls deaktiviert. Um dies zu vermeiden, verwenden Sie die „getThis“ Technik in den ausgezeichneten Generics FAQ by Angelika Langer:

Der „getThis“ Trick bietet eine Möglichkeit, den genauen Typen der diese Referenz erholen.

Dies führt zu dem folgenden Code, der kompiliert und ohne Warnungen ausgeführt wird. Wenn Sie Ihre Unterklassen erweitern möchten, ist die Technik immer noch gültig (obwohl Sie wahrscheinlich Ihre Zwischenklassen generisch machen müssen).

Der resultierende Code ist:

public class TestClass { 

    static abstract class Pet <T extends Pet<T>> { 
    private String name; 

    protected abstract T getThis(); 

    public T setName(String name) { 
     this.name = name; 
     return getThis(); } 
    } 

    static class Cat extends Pet<Cat> { 
    @Override protected Cat getThis() { return this; } 

    public Cat catchMice() { 
     System.out.println("I caught a mouse!"); 
     return getThis(); 
    } 
    } 

    static class Dog extends Pet<Dog> { 
    @Override protected Dog getThis() { return this; } 

    public Dog catchFrisbee() { 
     System.out.println("I caught a frisbee!"); 
     return getThis(); 
    } 
    } 

    public static void main(String[] args) { 
    Cat c = new Cat(); 
    c.setName("Morris").catchMice(); 
    Dog d = new Dog(); 
    d.setName("Snoopy").catchFrisbee(); 
    } 
} 

Answer 2

Nein, nicht wirklich. Sie könnten durch die Verwendung kovarianten Rückgabetypen (dank McDowell für den richtigen Namen) um es:

@Override 
public Cat setName(String name) { 
    super.setName(name); 
    return this; 
} 

(Covariant Rückgabetypen sind nur in Java 5 und höher, wenn das ein Problem für Sie.)

Answer 3

Wie diesen alten Trick:

abstract class Pet<T extends Pet> 
{ 
    private String name; 
    public T setName(String name) { this.name = name; return (T) this; }   
} 

class Cat extends Pet<Cat> 
{ 
    /* ... */ 
} 

class Dog extends Pet<Dog> 
{ 
    /* ... */ 
} 

Answer 4

Es ist ein bisschen gewunden, aber Sie dies mit Generika tun können:

abstract class Pet< T extends Pet > { 
    private String name; 

    public T setName(String name) { 
     this.name = name; 
     return (T)this; 
    } 

    public static class Cat extends Pet<Cat> { 
     public Cat catchMice() { 
      System.out.println("I caught a mouse!"); 
      return this; 
     } 
    } 

    public static class Dog extends Pet<Dog> { 
     public Dog catchFrisbee() { 
      System.out.println("I caught a frisbee!"); 
      return this; 
     } 
    } 

    public static void main (String[] args){ 
     Cat c = new Cat(); 
     c.setName("Morris").catchMice(); // error! setName returns Pet, not Cat 
     Dog d = new Dog(); 
     d.setName("Snoopy").catchFrisbee(); // error! setName returns Pet, not Dog 
    } 

} 

Answer 5

public class Pet<AnimalType extends Pet> { 

private String name; 
    public AnimalType setName(String name) { 
     this.name = name; return (AnimalType)this; 
    }   
} 

und

public class Cat extends Pet<Cat> { 

    public Cat catchMice() {return this;} 

    public static void main(String[] args) { 
     Cat c = new Cat().setName("bob").catchMice(); 
    } 

}