วิธีการแทนที่วิธีการโคลนอย่างถูกต้อง?

ฉันจำเป็นต้องใช้การโคลนระดับลึกในวัตถุของฉันซึ่งไม่มีชั้นยอด

วิธีใดที่ดีที่สุดในการจัดการกับการตรวจสอบที่CloneNotSupportedExceptionถูกโยนโดยซูเปอร์คลาส (ซึ่งคือObject)?

เพื่อนร่วมงานแนะนำให้ฉันจัดการด้วยวิธีต่อไปนี้:

@Override
public MyObject clone()
{
    MyObject foo;
    try
    {
        foo = (MyObject) super.clone();
    }
    catch (CloneNotSupportedException e)
    {
        throw new Error();
    }

    // Deep clone member fields here

    return foo;
}

นี่ดูเหมือนจะเป็นวิธีแก้ปัญหาที่ดีสำหรับฉัน แต่ฉันต้องการเผยแพร่ให้ชุมชน StackOverflow ดูว่ามีข้อมูลเชิงลึกอื่น ๆ ที่ฉันสามารถรวมไว้ได้หรือไม่ ขอบคุณ!

ต้องใช้อย่างแน่นอนclone? คนส่วนใหญ่ยอมรับว่า Java'scloneเสีย

Josh Bloch เกี่ยวกับการออกแบบ - ตัวสร้างการคัดลอกเทียบกับการโคลน

ถ้าคุณเคยอ่านเนื้อหาเกี่ยวกับการโคลนนิ่งในหนังสือของฉันโดยเฉพาะอย่างยิ่งถ้าคุณอ่านระหว่างบรรทัดคุณจะรู้ว่าฉันคิดว่าcloneมันพังมาก [... ] มันน่าเสียดายที่Cloneableเสีย แต่มันเกิดขึ้น

คุณสามารถอ่านอภิปรายเพิ่มเติมในหัวข้อในหนังสือของเขาที่มีประสิทธิภาพ Java ฉบับที่ 2 ข้อที่ 11: แทนที่cloneรอบคอบ เขาแนะนำให้ใช้ตัวสร้างสำเนาหรือโรงงานคัดลอกแทน

cloneเขาเดินไปที่หน้าเขียนหน้าเกี่ยวกับวิธีการถ้าคุณรู้สึกว่าคุณต้องคุณควรดำเนินการ แต่เขาปิดด้วยสิ่งนี้:

ความซับซ้อนทั้งหมดนี้จำเป็นจริงหรือ? นาน ๆ ครั้ง. หากคุณขยายคลาสที่ใช้Cloneableได้คุณมีทางเลือกน้อยมากนอกจากใช้cloneวิธีการที่มีพฤติกรรมดี มิฉะนั้นคุณจะดีกว่าให้หมายถึงทางเลือกของวัตถุการคัดลอกหรือเพียงแค่ไม่ให้ความสามารถในการ

สิ่งที่เน้นคือเขาไม่ใช่ของฉัน

เนื่องจากคุณทำให้มันชัดเจนว่าคุณมีทางเลือกน้อย แต่จะใช้ที่นี่เป็นสิ่งที่คุณสามารถทำได้ในกรณีนี้ให้แน่ใจว่าclone MyObject extends java.lang.Object implements java.lang.Cloneableหากเป็นเช่นนั้นคุณสามารถรับประกันได้ว่าคุณจะไม่จับไฟล์CloneNotSupportedException. การขว้างปาAssertionErrorตามที่บางคนแนะนำดูเหมือนจะสมเหตุสมผล แต่คุณยังสามารถเพิ่มความคิดเห็นที่อธิบายว่าเหตุใดจึงไม่ป้อนบล็อกการจับในกรณีนี้

อีกวิธีหนึ่งคือเป็นคนอื่นได้ชี้ให้เห็นนอกจากนี้คุณอาจจะสามารถดำเนินการโดยไม่ต้องโทรclonesuper.clone

บางครั้งการใช้ตัวสร้างสำเนาก็ง่ายกว่า:

public MyObject (MyObject toClone) {
}

ช่วยให้คุณประหยัดปัญหาในการจัดการCloneNotSupportedExceptionทำงานกับfinalฟิลด์และคุณไม่ต้องกังวลเกี่ยวกับประเภทที่จะส่งคืน

วิธีการทำงานของโค้ดของคุณค่อนข้างใกล้เคียงกับวิธีเขียนแบบ "บัญญัติ" ฉันจะโยนAssertionErrorเข้าไปในการจับแม้ว่า มันส่งสัญญาณว่าไม่ควรไปถึงเส้นนั้น

catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
}

มีสองกรณีที่CloneNotSupportedExceptionจะถูกโยน:

1. คลาสที่กำลังโคลนจะไม่ถูกนำไปใช้Cloneable(สมมติว่าในที่สุดการโคลนนิ่งจริงจะเปลี่ยนไปObjectใช้วิธีการโคลนของ) หากคลาสที่คุณกำลังเขียนวิธีนี้โดยใช้วิธีCloneableนี้จะไม่เกิดขึ้น (เนื่องจากคลาสย่อยใด ๆ จะสืบทอดอย่างเหมาะสม)
2. ยกเว้นในกรณีที่จะถูกโยนทิ้งอย่างชัดเจนโดยการดำเนินงาน - นี้เป็นวิธีที่แนะนำเพื่อป้องกันไม่ให้ clonability ใน subclass เมื่อ superclass Cloneableคือ

กรณีหลังไม่สามารถเกิดขึ้นในชั้นเรียนของคุณ (ตามที่คุณกำลังโดยตรงเรียก superclass' วิธีการในtryบล็อกแม้ว่าเรียกจากโทร subclass super.clone()) Cloneableและอดีตไม่ควรตั้งแต่ระดับของคุณอย่างชัดเจนควรใช้

โดยพื้นฐานแล้วคุณควรบันทึกข้อผิดพลาดอย่างแน่นอน แต่ในกรณีนี้จะเกิดขึ้นก็ต่อเมื่อคุณทำผิดนิยามของคลาส ดังนั้นให้ปฏิบัติเหมือนกับเวอร์ชันที่ตรวจสอบแล้วของNullPointerException(หรือคล้ายกัน) - จะไม่ถูกโยนทิ้งหากรหัสของคุณใช้งานได้

ในสถานการณ์อื่น ๆ คุณจะต้องเตรียมพร้อมสำหรับเหตุการณ์ที่อาจเกิดขึ้นนี้ - ไม่มีการรับประกันว่าอ็อบเจ็กต์ที่ระบุนั้นสามารถโคลนนิ่งได้ดังนั้นเมื่อตรวจพบข้อยกเว้นคุณควรดำเนินการที่เหมาะสมโดยขึ้นอยู่กับเงื่อนไขนี้ (ดำเนินการต่อกับอ็อบเจ็กต์ที่มีอยู่ใช้กลยุทธ์การโคลนทางเลือก เช่น serialize-deserialize ให้โยนIllegalParameterExceptionถ้าวิธีการของคุณต้องการพารามิเตอร์โดยการโคลนเป็นต้น)

แก้ไข : แม้ว่าโดยรวมแล้วฉันควรชี้ให้เห็นว่าใช่ แต่clone()เป็นเรื่องยากที่จะนำไปใช้อย่างถูกต้องและยากสำหรับผู้โทรที่จะรู้ว่าค่าที่ส่งคืนจะเป็นสิ่งที่พวกเขาต้องการหรือไม่ดังนั้นเมื่อคุณพิจารณาโคลนลึกและตื้น มักจะดีกว่าเพียงแค่หลีกเลี่ยงเรื่องทั้งหมดและใช้กลไกอื่น

ใช้การทำให้เป็นอนุกรมเพื่อทำสำเนาแบบลึก นี่ไม่ใช่วิธีแก้ปัญหาที่เร็วที่สุด แต่ไม่ได้ขึ้นอยู่กับประเภท

คุณสามารถใช้ตัวสร้างสำเนาที่มีการป้องกันได้ดังนี้:

/* This is a protected copy constructor for exclusive use by .clone() */
protected MyObject(MyObject that) {
    this.myFirstMember = that.getMyFirstMember(); //To clone primitive data
    this.mySecondMember = that.getMySecondMember().clone(); //To clone complex objects
    // etc
}

public MyObject clone() {
    return new MyObject(this);
}

คำตอบส่วนใหญ่ที่นี่ถูกต้องฉันต้องบอกว่าโซลูชันของคุณเป็นวิธีที่นักพัฒนา Java API จริงทำด้วย (ไม่ว่าจะเป็น Josh Bloch หรือ Neal Gafter)

นี่คือสารสกัดจากคลาส openJDK, ArrayList:

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

ดังที่คุณสังเกตเห็นและคนอื่น ๆ กล่าวถึงCloneNotSupportedExceptionแทบไม่มีโอกาสถูกโยนทิ้งหากคุณประกาศว่าคุณใช้Cloneableอินเทอร์เฟซ

นอกจากนี้ไม่จำเป็นต้องแทนที่เมธอดหากคุณไม่ได้ทำอะไรใหม่ในเมธอดที่ถูกแทนที่ คุณจะต้องลบล้างเมื่อคุณต้องการดำเนินการเพิ่มเติมกับวัตถุหรือคุณต้องทำให้เป็นสาธารณะ

ในที่สุดก็ยังดีที่สุดที่จะหลีกเลี่ยงและใช้วิธีอื่น

public class MyObject implements Cloneable, Serializable{   

    @Override
    @SuppressWarnings(value = "unchecked")
    protected MyObject clone(){
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            ByteArrayOutputStream bOs = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bOs);
            oos.writeObject(this);
            ois = new ObjectInputStream(new ByteArrayInputStream(bOs.toByteArray()));
            return  (MyObject)ois.readObject();

        } catch (Exception e) {
            //Some seriouse error :< //
            return null;
        }finally {
            if (oos != null)
                try {
                    oos.close();
                } catch (IOException e) {

                }
            if (ois != null)
                try {
                    ois.close();
                } catch (IOException e) {

                }
        }
    }
}

เพียงเพราะการใช้งาน Cloneable ของ java ไม่ได้หมายความว่าคุณไม่สามารถสร้างขึ้นมาเองได้

หากวัตถุประสงค์ที่แท้จริงของ OP คือการสร้างโคลนลึกฉันคิดว่าเป็นไปได้ที่จะสร้างอินเทอร์เฟซเช่นนี้:

public interface Cloneable<T> {
    public T getClone();
}

จากนั้นใช้ตัวสร้างต้นแบบที่กล่าวถึงก่อนที่จะใช้งาน:

public class AClass implements Cloneable<AClass> {
    private int value;
    public AClass(int value) {
        this.vaue = value;
    }

    protected AClass(AClass p) {
        this(p.getValue());
    }

    public int getValue() {
        return value;
    }

    public AClass getClone() {
         return new AClass(this);
    }
}

และคลาสอื่นที่มีฟิลด์อ็อบเจ็กต์ AClass:

public class BClass implements Cloneable<BClass> {
    private int value;
    private AClass a;

    public BClass(int value, AClass a) {
         this.value = value;
         this.a = a;
    }

    protected BClass(BClass p) {
        this(p.getValue(), p.getA().getClone());
    }

    public int getValue() {
        return value;
    }

    public AClass getA() {
        return a;
    }

    public BClass getClone() {
         return new BClass(this);
    }
}

ด้วยวิธีนี้คุณสามารถโคลนวัตถุของคลาส BClass ได้อย่างง่ายดายโดยไม่ต้องใช้ @SuppressWarnings หรือรหัสลูกเล่นอื่น ๆ