อะไรคือวิธีที่แตกต่างในการสร้างวัตถุใน Java?

มีการสนทนากับเพื่อนร่วมงานเมื่อวันก่อนเกี่ยวกับเรื่องนี้

มีความชัดเจนในการใช้คอนสตรัคเตอร์ แต่มีวิธีอื่นอีกบ้าง?

มีสี่วิธีในการสร้างวัตถุใน java:

ก . การใช้newคำสำคัญ
นี่เป็นวิธีที่พบได้บ่อยที่สุดในการสร้างวัตถุในจาวา วัตถุเกือบ 99% ถูกสร้างขึ้นด้วยวิธีนี้

 MyObject object = new MyObject();

ข . ใช้Class.forName()
ถ้าเรารู้ชื่อของคลาส & ถ้ามันมีตัวสร้างค่าเริ่มต้นสาธารณะเราสามารถสร้างวัตถุด้วยวิธีนี้

MyObject object = (MyObject) Class.forName("subin.rnd.MyObject").newInstance();

ค . การใช้clone()
clone () สามารถใช้เพื่อสร้างสำเนาของวัตถุที่มีอยู่

MyObject anotherObject = new MyObject();
MyObject object = (MyObject) anotherObject.clone();

ง . การใช้การดีobject deserialization
ซีเรียลไลซ์เซชันของวัตถุคืออะไร แต่การสร้างวัตถุจากรูปแบบต่อเนื่องของมัน

ObjectInputStream inStream = new ObjectInputStream(anInputStream );
MyObject object = (MyObject) inStream.readObject();

คุณสามารถอ่านได้จากที่นี่

มีหลายวิธี:

• Class.newInstanceตลอด
• Constructor.newInstanceตลอด
• ผ่าน deserialisation (ใช้ตัวสร้าง no-args ของคลาสพื้นฐานที่ไม่ได้รับส่วนใหญ่)
• ผ่านObject.clone( ไม่เรียกตัวสร้าง )
• ผ่าน JNI (ควรเรียกตัวสร้าง)
• ผ่านวิธีการอื่นใดที่เรียกร้องnewให้คุณ
• ฉันเดาว่าคุณสามารถอธิบายการโหลดคลาสเป็นการสร้างวัตถุใหม่ (เช่น interned Strings)
• อาร์เรย์ตัวอักษรเป็นส่วนหนึ่งของการเริ่มต้นในการประกาศ (ไม่มีตัวสร้างสำหรับอาร์เรย์)
• อาร์เรย์ใน "varargs" ( ...) การเรียกใช้เมธอด (ไม่มีตัวสร้างสำหรับอาร์เรย์)
• การต่อสตริงค่าคงที่แบบไม่คอมไพล์เวลา (เกิดขึ้นกับการสร้างวัตถุอย่างน้อยสี่อย่าง
• ทำให้เกิดข้อยกเว้นที่จะสร้างและโยนโดยรันไทม์ ยกตัวอย่างเช่นหรือthrow null;"".toCharArray()[0]
• โอ้และการชกมวยของชนพื้นเมือง (ยกเว้นในแคช) แน่นอน
• JDK8 ควรมี lambdas (โดยพื้นฐานแล้วจะมีคลาสภายในที่ไม่ระบุชื่อ) ซึ่งถูกแปลงเป็นวัตถุโดยปริยาย
• เพื่อความสมบูรณ์ (และPaŭlo Ebermann) มีไวยากรณ์ด้วยnewคำหลักเช่นกัน

ภายในภาษา Java วิธีเดียวในการสร้างวัตถุคือการเรียก constructor ของมันไม่ว่าจะโดยชัดแจ้งหรือโดยปริยาย การใช้ผลลัพธ์การสะท้อนกลับในการเรียกไปยังวิธีการสร้าง, deserialization ใช้การสะท้อนกลับเพื่อเรียกใช้ตัวสร้างวิธีการจากโรงงานตัดการเรียกไปยังตัวสร้างเพื่อนามธรรมการก่อสร้างจริงและการโคลนคือการเรียกการสร้างแบบเดียวกัน

ใช่คุณสามารถสร้างวัตถุโดยใช้การสะท้อน ตัวอย่างเช่นString.class.newInstance()จะให้วัตถุสตริงว่างใหม่แก่คุณ

มีห้าวิธีในการสร้างวัตถุใน Java

1. การใช้newคีย์เวิร์ด → constructor ถูกเรียก

Employee emp1 = new Employee();

2. ใช้newInstance()วิธีการของตัวClassสร้าง→รับเรียก

Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee")
                                .newInstance();

มันยังสามารถเขียนเป็น

Employee emp2 = Employee.class.newInstance();

3. การใช้newInstance()วิธีการของตัวConstructorสร้าง→รับเรียก

Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();

4. ใช้clone()method →ไม่มีการเรียก constructor

Employee emp4 = (Employee) emp3.clone();

5. การใช้ deserialization →ไม่มีการเรียก constructor

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();

newคีย์เวิร์ดสามเมธอดแรกและทั้งสองnewInstance()รวมการเรียก constructor แต่หลังจากนั้นสอง clone และ deserialization

วิธีการทั้งหมดข้างต้นมีวิธีการเข้ารหัสแบบต่าง ๆ ที่เกี่ยวข้องอ่านวิธีการที่แตกต่างกันในการสร้างวัตถุใน Java พร้อมตัวอย่างสำหรับตัวอย่าง

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

การโคลนและการดีซีเรียลไลเซชัน

นอกจากนี้คุณสามารถใช้

 Object myObj = Class.forName("your.cClass").newInstance();

สิ่งนี้จะสังเกตได้ถ้าคุณยังใหม่กับจาวาทุกวัตถุได้รับมาจากวัตถุ

การป้องกัน Native Object clone () พ่น CloneNotSupportedException;

นอกจากนี้คุณยังสามารถยกเลิกการทำให้ข้อมูลเป็นวัตถุ สิ่งนี้ไม่ผ่าน Constructor ของชั้นเรียน!

ปรับปรุง : ขอบคุณทอมที่ชี้ให้เห็นในความคิดเห็นของคุณ! และไมเคิลก็ทำการทดลองด้วยเช่นกัน

มันผ่านตัวสร้างของ superclass ที่ไม่ต่อเนื่องที่ได้มามากที่สุด
และเมื่อคลาสนั้นไม่มีคอนสตรัคเตอร์ที่ไม่ถูกต้อง InvalidClassException จะถูกส่งออกไปตามการทำให้เป็นอนุกรม

โปรดดูคำตอบของ Tom สำหรับการรักษาทุกกรณี ;-)
มีวิธีอื่นในการสร้างวัตถุโดยไม่ใช้คำหลัก "ใหม่" ใน java

มีชนิดของวัตถุที่ไม่สามารถถูกสร้างขึ้นโดยกลไกการสร้างอินสแตนซ์ปกติ (โทรก่อสร้าง) เป็น: อาร์เรย์ อาร์เรย์ถูกสร้างขึ้นด้วย

 A[] array = new A[len];

หรือ

 A[] array = new A[] { value0, value1, value2 };

ดังที่ฌอนกล่าวไว้ในความคิดเห็นนี่คือวากยสัมพันธ์คล้ายกับการเรียก constructor และภายในมันไม่มากไปกว่าการจัดสรรและการเริ่มต้นเป็นศูนย์ (หรือการเริ่มต้นด้วยเนื้อหาที่ชัดเจนในกรณีที่สอง) บล็อกหน่วยความจำ ประเภทและความยาว

เมื่อส่งอาร์กิวเมนต์ไปยัง varargs-method อาร์เรย์จะถูกสร้างขึ้น (และเติม) โดยปริยายเช่นกัน

วิธีที่สี่จะเป็น

 A[] array = (A[]) Array.newInstance(A.class, len);

แน่นอนว่าการโคลนนิ่งและการลดความน่าเชื่อถือนั้นก็ทำงานที่นี่เช่นกัน

มีวิธีการมากมายใน Standard API ซึ่งสร้างอาร์เรย์ แต่จริงๆแล้วพวกเขาทั้งหมดกำลังใช้หนึ่ง (หรือมากกว่า) ของวิธีเหล่านี้

วิธีอื่นถ้าเราหมดแรง

• บน Oracle JVM คือ Unsafe.allocateInstance () ซึ่งสร้างอินสแตนซ์โดยไม่ต้องเรียกตัวสร้าง
• โดยใช้การจัดการรหัสไบต์คุณสามารถเพิ่มรหัสanewarray, multianewarray, หรือnewarray newสามารถเพิ่มได้โดยใช้ไลบรารีเช่น ASM หรือ BCEL เวอร์ชันของ bcel มาพร้อมกับ Java ของ Oracle สิ่งนี้ไม่ได้เรียกว่านวกรรมิก แต่คุณสามารถเรียกนวกรรมิกเป็นการโทรแยก

การสะท้อน:

someClass.newInstance();

การสะท้อนกลับก็จะทำงานให้คุณ

SomeClass anObj = SomeClass.class.newInstance();

เป็นอีกวิธีในการสร้างอินสแตนซ์ใหม่ของคลาส ในกรณีนี้คุณจะต้องจัดการกับข้อยกเว้นที่อาจถูกโยน

• ใช้newโอเปอเรเตอร์ (เรียกใช้ตัวสร้าง)
• ใช้การสะท้อนclazz.newInstance()(ซึ่งเรียกใช้ตัวสร้างอีกครั้ง) หรือโดยclazz.getConstructor(..).newInstance(..)(อีกครั้งโดยใช้ตัวสร้าง แต่คุณสามารถเลือกได้)

เพื่อสรุปคำตอบ - หนึ่งวิธีหลัก - โดยเรียกใช้ Constructor ของคลาสของวัตถุ

อัปเดต: คำตอบอื่นแสดงสองวิธีที่ไม่เกี่ยวข้องกับการใช้ constructor - deseralization and cloning

มีห้าวิธีที่แตกต่างในการสร้างวัตถุใน Java:

1. การใช้คำหลัก `ใหม่ ':

นี่เป็นวิธีทั่วไปในการสร้างวัตถุใน Java วัตถุเกือบ 99% ถูกสร้างขึ้นด้วยวิธีนี้

MyObject object = new MyObject();//normal way

2. โดยใช้วิธีการจากโรงงาน:

ClassName ObgRef=ClassName.FactoryMethod();

ตัวอย่าง:

RunTime rt=Runtime.getRunTime();//Static Factory Method

3. โดยใช้แนวคิดการโคลน:

โดยการใช้clone()ที่clone()สามารถใช้ในการสร้างสำเนาของวัตถุที่มีอยู่

MyObjectName anotherObject = new MyObjectName();
MyObjectName object = anotherObjectName.clone();//cloning Object

4. การใช้ 'Class.forName ()':

ถ้าเรารู้ชื่อของคลาส & ถ้ามันมีตัวสร้างค่าเริ่มต้นสาธารณะเราสามารถสร้างวัตถุด้วยวิธีนี้

MyObjectName object = (MyObjectNmae) Class.forName("PackageName.ClassName").newInstance();

ตัวอย่าง:

String st=(String)Class.forName("java.lang.String").newInstance();

5. การใช้การดีซีเรียลไลซ์เซชันของวัตถุ:

การดีซีเรียลไลซ์เซชั่นของวัตถุเป็นเพียงการสร้างวัตถุจากรูปแบบต่อเนื่อง

ObjectInputStreamName inStream = new ObjectInputStreamName(anInputStream );
MyObjectName object = (MyObjectNmae) inStream.readObject();

นอกจากนี้คุณยังสามารถโคลนวัตถุที่มีอยู่ (ถ้าใช้ Cloneable)

Foo fooClone = fooOriginal.clone (); 

วิธีที่ 1

ใช้คำหลักใหม่ นี่เป็นวิธีทั่วไปในการสร้างวัตถุใน java วัตถุเกือบ 99% ถูกสร้างขึ้นด้วยวิธีนี้

Employee object = new Employee();

วิธีที่ 2

ใช้ Class.forName () Class.forName () ช่วยให้คุณวัตถุคลาสซึ่งมีประโยชน์สำหรับการสะท้อน วิธีการที่วัตถุนี้มีการกำหนดโดย Java ไม่ใช่โดยโปรแกรมเมอร์ที่เขียนชั้นเรียน พวกเขาเหมือนกันสำหรับทุกชั้นเรียน การเรียก newInstance () ที่ให้อินสแตนซ์ของคลาสนั้น (เช่น callingClass.forName ("ExampleClass") newInstance () เทียบเท่ากับการเรียก newClassClass () ใหม่ซึ่งคุณสามารถเรียกใช้เมธอดที่คลาสกำหนด เข้าถึงฟิลด์ที่มองเห็นได้ ฯลฯ

Employee object2 = (Employee) Class.forName(NewEmployee).newInstance();

Class.forName () จะใช้ ClassLoader ของผู้โทรเสมอในขณะที่ ClassLoader.loadClass () สามารถระบุ ClassLoader ที่แตกต่างกัน ฉันเชื่อว่า Class.forName เริ่มต้นคลาสที่โหลดเช่นกันในขณะที่วิธีการ ClassLoader.loadClass () ไม่ได้ทำเช่นนั้นทันที (มันไม่ได้เริ่มต้นจนกว่าจะใช้เป็นครั้งแรก)

ต้องอ่าน:

Java: บทนำสถานะเธรดพร้อมด้วยตัวอย่าง Java Enum ตัวอย่างง่าย ๆ

วิธีที่ 3

ใช้โคลน () สามารถใช้โคลน () เพื่อสร้างสำเนาของวัตถุที่มีอยู่ได้

Employee secondObject = new Employee();
Employee object3 = (Employee) secondObject.clone();

วิธีที่ 4

ใช้วิธี newInstance ()

Object object4 = Employee.class.getClassLoader().loadClass(NewEmployee).newInstance();

วิธีที่ 5

การใช้การดีซีเรียลไลซ์ชันของวัตถุ Object Deserialization ไม่มีอะไรนอกจากสร้างวัตถุจากรูปแบบต่อเนื่อง

// Create Object5
// create a new file with an ObjectOutputStream
FileOutputStream out = new FileOutputStream("");
ObjectOutputStream oout = new ObjectOutputStream(out);

// write something in the file
oout.writeObject(object3);
oout.flush();

// create an ObjectInputStream for the file we created before
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("crunchify.txt"));
Employee object5 = (Employee) ois.readObject();

จากมุมมองของผู้ใช้ API ทางเลือกอื่นสำหรับตัวสร้างเป็นวิธีคงที่จากโรงงาน (เช่น BigInteger.valueOf ()) แต่สำหรับผู้เขียน API (และเทคนิค "สำหรับจริง") วัตถุยังคงสร้างโดยใช้ตัวสร้าง

ขึ้นอยู่กับสิ่งที่คุณหมายถึงโดยการสร้าง แต่คนอื่น ๆ คือ:

• วิธีการโคลน
• ซีเรียลไลซ์
• การสะท้อน (Class.newInstance ())
• การสะท้อน (วัตถุตัวสร้าง)

นอกจากนี้ยังมี ClassLoader.loadClass (สตริง) แต่ไม่ได้ใช้บ่อย

และถ้าคุณต้องการเป็นทนายโดยรวมแล้วอาร์เรย์นั้นเป็นวัตถุทางเทคนิคเพราะคุณสมบัติ. ความยาวของอาร์เรย์ ดังนั้นการเริ่มต้นอาร์เรย์สร้างวัตถุ

เราสามารถสร้างวัตถุได้ 5 วิธี:

1. โดยผู้ประกอบการใหม่
2. ตามการสะท้อนกลับ (เช่น Class.forName () ตามด้วย Class.newInstance ())
3. โดยวิธีการโรงงาน
4. โดยการโคลนนิ่ง
5. โดยการสะท้อน API

นอกจากนี้เรายังสามารถสร้างวัตถุด้วยวิธีนี้: -

String s ="Hello";

ไม่มีใครพูดถึงเรื่องนี้