เกี่ยวกับ Java ที่สามารถโคลนได้

ฉันกำลังมองหาแบบฝึกหัดที่อธิบายเกี่ยวกับ Java Cloneableแต่ไม่ได้รับลิงก์ที่ดีเลยและ Stack Overflow ก็กลายเป็นตัวเลือกที่ชัดเจนมากขึ้น

ฉันต้องการทราบสิ่งต่อไปนี้:

1. Cloneableหมายความว่าเราสามารถมีโคลนหรือสำเนาของวัตถุได้โดยใช้Cloneableอินเทอร์เฟซ ข้อดีข้อเสียของการทำแบบนั้นคืออะไร?
2. การโคลนแบบวนซ้ำจะเกิดขึ้นได้อย่างไรหากวัตถุนั้นเป็นวัตถุผสม

สิ่งแรกที่คุณควรรู้Cloneableคือ - อย่าใช้มัน

เป็นการยากมากที่จะใช้การโคลนอย่างCloneableถูกต้องและความพยายามนั้นไม่คุ้มค่า

แทนที่จะใช้ตัวเลือกอื่น ๆ เช่น apache-commons SerializationUtils(โคลนลึก) หรือBeanUtils(โคลนนิ่งตื้น) หรือใช้ตัวสร้างการคัดลอก

ดูที่นี่สำหรับมุมมองของ Josh Bloch เกี่ยวกับการโคลนนิ่งCloneableซึ่งอธิบายถึงข้อบกพร่องหลายประการของแนวทางนี้ ( Joshua Blochเป็นพนักงานของ Sun และเป็นผู้นำในการพัฒนาคุณลักษณะ Java มากมาย)

Cloneable นั้นน่าเสียดายที่เป็นเพียงอินเทอร์เฟซของ marker นั่นคือมันไม่ได้กำหนดวิธีการ clone ()

คืออะไรคือเปลี่ยนพฤติกรรมของเมธอด Object.clone () ที่ได้รับการป้องกันซึ่งจะโยน CloneNotSupportedException สำหรับคลาสที่ไม่ใช้ Cloneable และดำเนินการคัดลอกตื้นที่ชาญฉลาดสำหรับสมาชิกสำหรับคลาสที่ทำ

แม้ว่านี่จะเป็นพฤติกรรมที่คุณกำลังมองหา แต่คุณก็ยังต้องใช้เมธอด clone () ของคุณเองเพื่อให้เป็นแบบสาธารณะ

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

วิธีนี้จะข้ามตรรกะใด ๆ ที่อาจกำหนดไว้ในตัวสร้างของคุณซึ่งอาจเป็นปัญหาได้

ปัญหาอีกประการหนึ่งคือคลาสย่อยใด ๆ ที่ลืมแทนที่ clone () จะสืบทอดสำเนาตื้นเริ่มต้นโดยอัตโนมัติซึ่งอาจไม่ใช่สิ่งที่คุณต้องการในกรณีที่สถานะไม่แน่นอน (ซึ่งตอนนี้จะแชร์ระหว่างซอร์สและสำเนา)

นักพัฒนาส่วนใหญ่ไม่ใช้ Cloneable ด้วยเหตุผลเหล่านี้และใช้ตัวสร้างการคัดลอกแทน

สำหรับข้อมูลเพิ่มเติมและข้อผิดพลาดที่อาจเกิดขึ้นของ Cloneable ฉันขอแนะนำหนังสือ Effective Java โดย Joshua Bloch

1. การโคลนนิ่งก่อให้เกิดวิธีการสร้างวัตถุที่เป็นภาษาพิเศษโดยไม่ต้องใช้ตัวสร้าง
2. การโคลนต้องการให้คุณดำเนินการกับ CloneNotSupportedException หรือรบกวนรหัสไคลเอ็นต์ในการรักษา
3. ประโยชน์มีน้อย - คุณไม่จำเป็นต้องเขียนตัวสร้างการคัดลอกด้วยตนเอง

ดังนั้นให้ใช้ Cloneable อย่างรอบคอบ ไม่ได้ให้ประโยชน์เพียงพอเมื่อเทียบกับความพยายามที่คุณต้องใช้เพื่อทำทุกอย่างให้ถูกต้อง

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

สมมติว่าฉันมีคลาส A, B และ C โดยที่ B และ C มาจาก A ถ้าฉันมีรายการวัตถุประเภท A ดังนี้:

ArrayList<A> list1;

ตอนนี้รายการดังกล่าวอาจมีวัตถุประเภท A, B หรือ C คุณไม่รู้ว่าวัตถุประเภทใด ดังนั้นคุณไม่สามารถคัดลอกรายการได้ดังนี้:

ArrayList<A> list2 = new ArrayList<A>();
for(A a : list1) {
    list2.add(new A(a));
}

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

ArrayList<A> list2 = new ArrayList<A>();
for(A a : list1) {
    if(a instanceof A) {
        list2.add(new A(a));
    } else if(a instanceof B) {
        list2.add(new B(a));
    } else if(a instanceof C) {
        list2.add(new C(a));
    }
}

นี่เป็นความคิดที่แย่มาก จะเกิดอะไรขึ้นถ้าคุณเพิ่มประเภทที่ได้รับใหม่? จะเกิดอะไรขึ้นถ้า B หรือ C อยู่ในแพ็คเกจอื่นและคุณไม่สามารถเข้าถึงได้ในคลาสนี้

สิ่งที่คุณต้องการทำคือ:

ArrayList<A> list2 = new ArrayList<A>();
for(A a : list1) {
    list2.add(a.clone());
}

ผู้คนจำนวนมากระบุว่าเหตุใดการใช้งาน Java พื้นฐานของการโคลนจึงมีปัญหา แต่มันเอาชนะได้อย่างง่ายดายด้วยวิธีนี้:

ในคลาส A:

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

ในคลาส B:

@Override
public B clone() {
    return new B(this);
}

ในคลาส C:

@Override
public C clone() {
    return new C(this):
}

ฉันไม่ได้ใช้ Cloneable เพียงแค่ใช้ชื่อฟังก์ชันเดียวกัน ถ้าไม่ชอบก็ตั้งชื่ออย่างอื่น

A) ไม่มีข้อดีของการโคลนมากกว่าตัวสร้างสำเนา อาจเป็นสิ่งที่ใหญ่ที่สุดคือความสามารถในการสร้างวัตถุใหม่ที่มีประเภทไดนามิกเดียวกันทั้งหมด (สมมติว่าประเภทที่ประกาศนั้นสามารถโคลนได้และมีวิธีการโคลนสาธารณะ)

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

Bozho พูดถูกการโคลนอาจเป็นเรื่องยากที่จะทำให้ถูกต้อง ผู้สร้างสำเนา / โรงงานจะตอบสนองความต้องการส่วนใหญ่

ข้อเสียของ Cloneable คืออะไร?

การโคลนนิ่งเป็นสิ่งที่อันตรายมากหากวัตถุที่คุณกำลังคัดลอกมีองค์ประกอบคุณต้องคิดถึงผลข้างเคียงที่อาจเกิดขึ้นด้านล่างในกรณีนี้เนื่องจากการโคลนจะสร้างสำเนาตื้น ๆ :

สมมติว่าคุณมีวัตถุหนึ่งชิ้นที่จะจัดการกับการจัดการที่เกี่ยวข้องกับฐานข้อมูล สมมติว่าวัตถุนั้นมีConnectionวัตถุเป็นหนึ่งในคุณสมบัติ

ดังนั้นเมื่อมีคนสร้างโคลนของวัตถุที่ถูกสร้างขึ้นให้พูดว่าoriginalObject cloneObjectที่นี่originalObjectและcloneObjectถืออ้างอิงเดียวกันสำหรับConnectionวัตถุ

สมมติว่าoriginalObjectปิดConnectionวัตถุดังนั้นตอนนี้cloneObjectจะไม่ทำงานเนื่องจากconnectionวัตถุถูกแชร์ระหว่างพวกเขาและมันถูกปิดโดยอัตโนมัติโดยไฟล์originalObject.

ปัญหาที่คล้ายกันอาจเกิดขึ้นหากคุณต้องการโคลนวัตถุที่มี IOStream เป็นคุณสมบัติ

การโคลนแบบวนซ้ำจะเกิดขึ้นได้อย่างไรหากวัตถุนั้นเป็นวัตถุผสม

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