Java 创建限制为自己的类的泛型接口

我想为这两个类创建一个泛型接口，但我不确定如何以正确的方式指定泛型

public class ThingA implements Thing {
    public ThingA createCopy(ThingA original);
}

public class ThingB implements Thing {
    public ThingB createCopy(ThingB original);
}

我今天就试过了

public interface Thing<V extends Thing<V>> {
    public V createCopy(V original);

}

公共接口的东西{
公开副本（原件）；
}

但我仍然可以做这样的事情，这是不允许的

public class ThingB implements Thing<ThingA> {
    public ThingA createCopy(ThingA original);
}

公共类ThingB实现的东西{
公共ThingA createCopy（ThingA原件）；
}

你在找什么

public interface Thing<V> {
    public V createCopy(V original);
}

公共接口的东西{
公开副本（原件）；
}

---

?？如果没有，您能否更详细地解释“为两个类创建泛型接口”对您意味着什么？

没有

这个
关键字泛型（也没有方法参数和返回值声明），因此您无法完全按照您的要求执行

换句话说，接口将允许确保类中的所有方法使用一致的类型，但不引用类类型本身。
这是不可能的。这不是泛型的作用。泛型用于类型安全，即避免类型转换。如果有人制作了一个类
ThingB
，它以某种方式实现了
东西
，那就太棒了。它是完全类型安全的。你为什么在乎？它是如何阻碍您的工作的？
如果您可以自由地使用扩展而不是实现，那么您可以这样做：

public interface Thing { ... }
public abstract class Copyable {
    public final Copyable copy() {
        Copyable clone = createCopy();
        if (clone.getClass() != getClass())
            throw new RuntimeException("Copy has wrong type!");
        return clone;
    }
    protected abstract Copyable createCopy();
}

然后像这样使用它：

public class Test extends Copyable implements Thing {
    public String content = null;

    @Override
    public Copyable createCopy() {
        Test clone = new Test();
        clone.content = this.content;
        return clone;
    }
}

/*code somewhere*/ {
    Test t1 = new Test();
    t1.content = "Hello world!";
    Test t2 = (Test)t1.copy();
    System.out.println(t2.content);
}

这样做的一个问题是，
可复制
不是一个接口。但是，正如示例中所示，可以轻松地使用它，但是在语言级别上不支持使用的类检查。换句话说，
createCopy
抽象方法并不局限于它复制的类，所有这一切都取决于扩展
Copyable
类的程序员或扩展它的类

积极的一面是，如果在对象上调用
.copy（）
，它必须返回与自身相同的对象。如果需要，可以返回
null
，而不是异常。那你要么成功要么一事无成

但是，老实说，我真的不明白为什么您的
createCopy
local方法有一个参数。
这可能是一种静态方法。。。尽管如此，我甚至无法想象代码块中会有什么内容：

static <X extends Thing> X copy(X object) { ... }

静态X拷贝（X对象）{…}

您可以将实践与静态泛型方法结合起来，结果会更友好一些：

public interface Thing extends Cloneable {
    public static <X extends Thing> X copy(X thing) {
        Object clone = thing.clone();
        if (clone.getClass() != getClass())
            throw new RuntimeException("Copy has wrong type!");
        return (X)clone;
    }
}

public class ThingA implements Thing {
    public Object clone() { ... }
}

/*code somewhere*/ {
    ThingA a1 = new ThingA();
    ThingA a2 = Thing.copy(a1);
}

公共接口扩展了可克隆性{
公共静态X拷贝（X东西）{
对象克隆=thing.clone（）；
如果（clone.getClass（）！=getClass（））
抛出新的RuntimeException（“复制的类型错误！”）；
返回（X）克隆；
}
}
公共类ThingA实现的东西{
公共对象克隆（）{…}
}
/*代码某处*/{
ThingA a1=新ThingA（）；
ThingA a2=Thing.copy（a1）；
}

尽管如此，克隆方法还是受到例外而不是语言限制的约束，但我认为这是迄今为止最好的解决方案。
这仍然允许他做他不想做的事情。泛型并不阻止您只使用一种类型的类，因为这与泛型的用途完全相反。