抽象类实现可克隆；抽象对象克隆（）

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，那么子类就可以工作。

除了扩展的抽象类，我怎么能做到“相同”？

Answer 1

这行得通吗？

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();
        }
    }

}

Answer 2

好吧，你有更广泛的问题。我必须说你搞砸了。这是一个相关的问题：强制继承链的每个类重写抽象方法

任何实现Clonable的抽象类的主要问题实际上都依赖于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();
    }

}

然后。。。

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();
        }
    }

}