“有没有一种方法可以在不使用instanceof的额外参数的情况下在运行时找出返回类型?”

作为另一种解决方案，您可以像这样利用访问者模式。使动物抽象，使其实现可访问:

abstract public class Animal implements Visitable {
  private Map<String,Animal> friends = new HashMap<String,Animal>();

  public void addFriend(String name, Animal animal){
      friends.put(name,animal);
  }

  public Animal callFriend(String name){
      return friends.get(name);
  }
}

可访问的意思是Animal的实现愿意接受一个访问者:

public interface Visitable {
    void accept(Visitor v);
}

而一个visitor实现能够访问动物的所有子类:

public interface Visitor {
    void visit(Dog d);
    void visit(Duck d);
    void visit(Mouse m);
}

例如，Dog的实现是这样的:

public class Dog extends Animal {
    public void bark() {}

    @Override
    public void accept(Visitor v) { v.visit(this); }
}

这里的技巧是，当Dog知道它是什么类型时，它可以通过传递“this”作为参数来触发访问者v的相关重载访问方法。其他子类将以完全相同的方式实现accept()。

想要调用子类特定方法的类必须像这样实现Visitor接口:

public class Example implements Visitor {

    public void main() {
        Mouse jerry = new Mouse();
        jerry.addFriend("spike", new Dog());
        jerry.addFriend("quacker", new Duck());

        // Used to be: ((Dog) jerry.callFriend("spike")).bark();
        jerry.callFriend("spike").accept(this);

        // Used to be: ((Duck) jerry.callFriend("quacker")).quack();
        jerry.callFriend("quacker").accept(this);
    }

    // This would fire on callFriend("spike").accept(this)
    @Override
    public void visit(Dog d) { d.bark(); }

    // This would fire on callFriend("quacker").accept(this)
    @Override
    public void visit(Duck d) { d.quack(); }

    @Override
    public void visit(Mouse m) { m.squeak(); }
}

我知道它的接口和方法比您所期望的要多得多，但是它是一种标准的方法，可以用精确的零instanceof检查和零类型强制转换来处理每个特定的子类型。而且这一切都是以一种标准语言不可知的方式完成的，因此它不仅适用于Java，而且适用于任何面向对象语言。

我在我的lib kontraktor中做了以下事情:

public class Actor<SELF extends Actor> {
    public SELF self() { return (SELF)_self; }
}

子类化:

public class MyHttpAppSession extends Actor<MyHttpAppSession> {
   ...
}

至少这在当前类内部和具有强类型引用时是有效的。多重继承工作，但真的很棘手:)

你可以这样定义callFriend:

public <T extends Animal> T callFriend(String name, Class<T> type) {
    return type.cast(friends.get(name));
}

那么就这样称呼它吧:

jerry.callFriend("spike", Dog.class).bark();
jerry.callFriend("quacker", Duck.class).quack();

这段代码的好处是不会生成任何编译器警告。当然，这实际上只是前泛型时代的强制转换的更新版本，并没有增加任何额外的安全性。

不可能的。如果只给一个String键，Map怎么知道它将得到Animal的哪个子类呢?

唯一可能的方法是每个Animal只接受一种类型的friend(那么它可以是Animal类的一个参数)，或者callFriend()方法获得了一个类型参数。但是，看起来您确实忽略了继承的要点:在独占地使用超类方法时，只能统一地对待子类。

是什么

public class Animal {
    private Map<String,<T extends Animal>> friends = new HashMap<String,<T extends Animal>>();

    public <T extends Animal> void addFriend(String name, T animal){
        friends.put(name,animal);
    }

    public <T extends Animal> T callFriend(String name){
        return friends.get(name);
    }
}

你可以这样实现它:

@SuppressWarnings("unchecked")
public <T extends Animal> T callFriend(String name) {
    return (T)friends.get(name);
}

(是的，这是法律代码;参见Java泛型:仅定义为返回类型的泛型类型。)

返回类型将从调用者推断出来。但是，请注意@SuppressWarnings注释:它告诉您这段代码不是类型安全的。您必须自己验证它，或者您可以在运行时获得classcastexception。

不幸的是，你使用它的方式(没有将返回值分配给临时变量)，唯一让编译器高兴的方法是像这样调用它:

jerry.<Dog>callFriend("spike").bark();

虽然这可能比强制转换要好一点，但正如David Schmitt所说，最好给Animal类一个抽象的talk()方法。