抽象类实现可克隆接口；抽象对象克隆()方法。

Question

假设我有这个类：

public abstract class AbstractFoo implements Cloneable {

    public abstract Object clone();

}

还有子类：

public class Foobar extends AbstractFoo {

    @Override
    public Object clone() {
        try {
            Foobar c = (Foobar) super.clone();
            /* some operations */
            return c;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}

我知道这是不可能的，但我想你能理解我的意思。如果Foobar实现了Cloneable接口而没有继承AbstractFoo类，那么子类将会起作用。我认为我想要但不被允许的是这样的：

Foobar c = (Foobar) super.super.clone();

如果Foobar实现了Cloneable接口且未继承AbstractFoo，那么子类将正常工作。

但如果要使用扩展的抽象类来完成“相同”的操作，应该如何操作呢？

- Tobias Johansson

---

我不明白。你期望super.clone();做什么？你希望它做什么？ - Sotirios Delimanolis

你能解释一下你想做什么以及哪些地方出了问题吗？另外，更具描述性的标题也会很有用。 - Jeroen Vannevel

如果Foobar实现了Cloneable并且没有扩展AbstractFoo，则此代码将起作用。但如果我要使用扩展的抽象类，该怎么做呢？ - Tobias Johansson

你期望 super.clone(); 做什么？ - Sotirios Delimanolis

没有扩展类，只有实现Cloneable接口 - 一个克隆。 - Tobias Johansson

Answer 1

好的，你面临着更广泛的问题。我必须说你很惨。以下是相关问题：强制继承链中的每个类覆盖抽象方法

任何实现Cloneable的抽象类主要依赖于Object.clone()，因此这是一个普遍无解的问题，但是......

建议的解决方案：

我从这里得到了一个想法：Java中强制使用可克隆接口

public interface Modifiable<T extends Modifiable<T>> extends Cloneable {
    T clone();
}

public class Foo implements Modifiable<Foo> {
    public Foo clone() { //this is required
        return null; //todo: real work
    }
}

比这里发布的任何东西都好。

先前的猜测：

也许你的想法不是100%清晰，但这种方法适用吗？

public abstract class AbstractFoo implements Cloneable {

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

And then...

public class Foobar extends AbstractFoo {

    @Override
    public Object clone() {
        try {
            Foobar c = (Foobar) super.clone();
            /* some operations */
            return c;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}

嗯...如果您需要强制后代实现克隆...实际上我不喜欢这个想法的味道，但在这种情况下为什么不做类似于这样的事情呢？

public abstract class AbstractFoo implements Cloneable {

    public Object clone() throws CloneNotSupportedException {
        return cloneMe();
    }

    abstract protected Object cloneMe();

}

最后......可能有点糟糕，但你还是在问这个问题；-）。

public class Foobar extends AbstractFoo {

    @Override
    public Object cloneMe() {
        try {
            Foobar c = (Foobar) super.clone();
            /* some operations */
            return c;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}

- Roman Nikitchenko

---

是的，那会起作用。问题在于我想要一个实现了 public abstract Object clone() 的 Cloneable 抽象类。因此，这个抽象类将强制子类实现 clone() 方法。我猜这不可能吗？ - Tobias Johansson

由于类是抽象的，所以没有人会注意到差异（如果方法是抽象的）。嗯？ - Roman Nikitchenko

区别在于子类不会被强制实现一个 clone() 方法。 - Tobias Johansson

更新适合你吗？我的理解是你试图发明自行车......但在Java中它是周期性需要的 :-). - Roman Nikitchenko

请使用Modifiable<T>和原始链接检查解决方案 - 这对您应该很合适。虽然不完全符合您的要求，但实际上非常好。 - Roman Nikitchenko

Answer 2

这个可行吗？

public abstract class AbstractFoo implements Cloneable {

    public abstract Object clone();

    // Enables subclasses to call "super.super.clone()"
    public Object superDotClone() throws CloneNotSupportedException {
        return super.clone();
    }

}

使用子类：

public class Foobar extends AbstractFoo {

    @Override
    public Object clone() {
        try {
            Foobar c = (Foobar) super.superDotClone();
            /* some operations */
            return c;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }

}

- Tobias Johansson

---

哎呀..看起来很相似，但我正在考虑哪个解决方案（这个或我的）更脏。实际上，这个问题是关于强制子类覆盖已经实现的东西。 - Roman Nikitchenko

我更喜欢我的方法，因为我希望AbstractFoo实现一个请求clone()方法的接口。 - Tobias Johansson