抽象類實現Cloneable; abstract對象clone（）

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

好的，你有更廣泛的問題。 我必須說你搞砸了。 以下是相關問題： 強制繼承鏈的每個類重寫抽象方法

實現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
    }
}

比在這里張貼的任何東西都好多了。

以前的GUESSINS：

也許你的想法不是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();
        }
    }

}

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

}