Java泛型：复制子类实例时捕获泛型类型

在下面的代码示例中，有没有一种方法可以避免这些注释

代码测试参数t是否是的实例，并返回另一个实例。它满足createCopy（）的一般约定，返回与其参数相同类型的对象，因此它是一个安全的操作。B的测试也是如此

我知道，但我不确定这是否以及如何在这种情况下有所帮助，尽管问题似乎非常相似

abstract class Base {
    public static <T extends Base> T createCopy(T t) {
        if (t instanceof A) {
            @SuppressWarnings("unchecked")
            T copy = (T) new A((A) t);
            return copy;
        }

        if (t instanceof B) {
            @SuppressWarnings("unchecked")
            T copy = (T) new B((B) t);
            return copy;
        }

        throw new IllegalStateException();
    }
}

class A extends Base {
    public A() { }
    public A(A a) { }
}

class B extends Base {
    public B() { }
    public B(B b) { }
}

抽象类基类{
公共静态T createCopy（T T）{
if（A的t实例）{
@抑制警告（“未选中”）
T copy=（T）新的A（（A）T）；
返回副本；
}
if（B的t实例）{
@抑制警告（“未选中”）
T copy=（T）新B（（B）T）；
返回副本；
}
抛出新的非法状态异常（）；
}
}
A类扩展基础{
公共A（）{}
公共A（A）{}
}
B类扩展了基本类{
公共B（）{}
公共B（B）{}
}

您可以将类传递给方法，但这仍然很难看：

abstract class Base {
    public static <T extends Base> T createCopy(final T t,
            final Class<T> klass) {
        if (t instanceof A) {
            final T copy = klass.cast(new A((A) t));
            return copy;
        }

        if (t instanceof B) {
            final T copy = klass.cast(new B((B) t));
            return copy;
        }

        throw new IllegalStateException();
    }
}

class A extends Base {
    public A() {
    }

    public A(final A a) {
    }
}

class B extends Base {
    public B() {
    }

    public B(final B b) {
    }
}

抽象类基类{
公共静态T createCopy（最终T，
期末班（klass）{
if（A的t实例）{
最终T拷贝=klass.cast（新A（（A）T））；
返回副本；
}
if（B的t实例）{
最终T拷贝=klass.cast（新B（（B）T））；
返回副本；
}
抛出新的非法状态异常（）；
}
}
A类扩展基础{
公共A（）{
}
公共A（最终A）{
}
}
B类扩展了基本类{
公共图书馆B（）{
}
公共B（期末B）{
}
}

调用

t.getClass（）

也不起作用。原因是T可以是a或B的子类型（这就是为什么您的代码不是真正的类型安全的）

编辑：

---

为什么您的代码不是真正的类型安全：想象一个扩展了

a

的类

AA

。如果使用此类的实例调用方法，它将创建一个

A

类型的对象，并尝试将其强制转换为

AA

，如果您认为注释“难看”，请删除它们。它们是可选的。然后我会得到一个类型安全警告。我想知道是否有办法避免这个警告，因为代码是类型安全的。如果我能让编译器知道的话。你是通过使用注释让编译器知道的。顺便问一下，为什么你要使用静态方法而不是非静态的抽象方法？@WilQu，是的，效果更好，谢谢！（Coffee++）有趣的答案，但为什么您认为我的代码不是真正的类型安全？它为A返回A，为B返回B，不是吗？@devconsole，是的，但对于A或B的子类型，它将失败（请参见我的编辑）