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，子类将起作用。

我该怎么做？＃34;同样的＆＃34;但是扩展抽象类？

Answer 1

好的，你有更广泛的问题。我必须说你搞砸了。这是相关的问题： Force every class of an inheritance chain to override an abstract method

实现Cloneable的任何抽象类的主要问题实际上都依赖于Object.clone()。所以没有解决方案通常是问题但是......

建议的解决方案：

我从这里得到一个想法：Mandatory cloneable interface in 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();
        }
    }

}

抽象类实现Cloneable; abstract对象clone（）

2 个答案: