Methodenverkettung + Vererbung passen nicht gut zusammen?

Diese Frage wurde in einem C++-Kontext gestellt, aber ich bin neugierig auf Java. Die Bedenken bezüglich virtueller 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
}

Gibt es in dieser Art von Klassenhierarchie einen Weg zurück? this auf eine Weise, die den Objekttyp nicht (effektiv) umwandelt?

Wenn Sie ungeprüfte Cast-Warnungen von Ihrem Compiler vermeiden möchten (und @SuppressWarnings (“unchecked”) nicht möchten), müssen Sie etwas mehr tun:

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

abstract class Pet <T extends Pet<T>>

Zweitens die (T) this cast in setName ist ebenfalls deaktiviert. Um dies zu vermeiden, verwenden Sie die „getThis“-Technik im Excellent Generika-FAQ von Angelika Langer:

Der “getThis”-Trick bietet eine Möglichkeit, den genauen Typ dieser Referenz wiederherzustellen.

Dies führt zu folgendem Code, der ohne Warnungen kompiliert und ausgeführt wird. Wenn Sie Ihre Unterklassen erweitern möchten, gilt die Technik immer noch (obwohl Sie wahrscheinlich Ihre Zwischenklassen generisieren müssen).

Der resultierende Code lautet:

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();
  }
}

Wie wäre es mit diesem 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>
{
    /* ... */
}

Nein nicht wirklich. Sie könnten dies umgehen, indem Sie kovariante Rückgabetypen verwenden (danke an McDowell für den korrekten Namen):

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

(Kovariante Rückgabetypen gibt es nur in Java 5 und höher, falls Sie das interessiert.)

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

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
    }

}

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();
    }

}