抽象類實現Cloneable;抽象對象的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的實現了Cloneable並沒有延伸AbstractFoo

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

子類是可行的。

我該怎麼做「相同」，但擴展抽象類？

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

好的，你有更多更廣泛的問題。我必須說你搞砸了。這裏是相關的問題： 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(); 
     } 
    } 

} 

嗯......如果你需要強制後代impleement克隆...其實我不喜歡這個主意的氣味，但爲什麼不做某事像這樣在這種情況下？

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

}