我知道这和刚才那个人问的完全不同。解决这个问题的另一种方法是反思。我的意思是，这并没有从泛型中获益，但它让你在某种程度上模拟你想要执行的行为(让狗叫，让鸭子嘎嘎叫，等等)，而不考虑类型转换:

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

abstract class AnimalExample {
    private Map<String,Class<?>> friends = new HashMap<String,Class<?>>();
    private Map<String,Object> theFriends = new HashMap<String,Object>();

    public void addFriend(String name, Object friend){
        friends.put(name,friend.getClass());
        theFriends.put(name, friend);
    }

    public void makeMyFriendSpeak(String name){
        try {
            friends.get(name).getMethod("speak").invoke(theFriends.get(name));
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    } 

    public abstract void speak ();
};

class Dog extends Animal {
    public void speak () {
        System.out.println("woof!");
    }
}

class Duck extends Animal {
    public void speak () {
        System.out.println("quack!");
    }
}

class Cat extends Animal {
    public void speak () {
        System.out.println("miauu!");
    }
}

public class AnimalExample {

    public static void main (String [] args) {

        Cat felix = new Cat ();
        felix.addFriend("Spike", new Dog());
        felix.addFriend("Donald", new Duck());
        felix.makeMyFriendSpeak("Spike");
        felix.makeMyFriendSpeak("Donald");

    }

}

还有另一种方法，当你重写一个方法时，你可以缩小返回类型。在每个子类中，您必须重写callFriend以返回该子类。代价是callFriend的多次声明，但是可以将公共部分隔离到内部调用的方法中。对我来说，这似乎比上面提到的解决方案简单得多，并且不需要额外的参数来确定返回类型。

此外，您还可以通过这种方式要求该方法以给定类型返回值

<T> T methodName(Class<T> var);

更多示例请参见Oracle Java文档

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

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

子类化:

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

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

不。编译器无法知道jerry.callFriend("spike")将返回什么类型。此外，您的实现只是将强制转换隐藏在方法中，而没有任何额外的类型安全。考虑一下:

jerry.addFriend("quaker", new Duck());
jerry.callFriend("quaker", /* unused */ new Dog()); // dies with illegal cast

在这种情况下，创建一个抽象的talk()方法并在子类中适当地重写它会更好地为你服务:

Mouse jerry = new Mouse();
jerry.addFriend("spike", new Dog());
jerry.addFriend("quacker", new Duck());

jerry.callFriend("spike").talk();
jerry.callFriend("quacker").talk();

这个问题与Effective Java中的第29项非常相似——“考虑类型安全的异构容器”。拉兹的答案最接近布洛赫的答案。但是，为了安全起见，put和get都应该使用Class字面值。签名将变成:

public <T extends Animal> void addFriend(String name, Class<T> type, T animal);
public <T extends Animal> T callFriend(String name, Class<T> type);

在这两个方法中，您应该检查参数是否正常。有关更多信息，请参阅有效Java和类javadoc。