การสร้างและการทำลายวัตถุในบันทึกการสอน Java

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

1. บทนำ

ในการจัดอันดับภาษาการเขียนโปรแกรม Tiobe ภาษา Java ที่พัฒนาโดย Sun ในปี 1995 เป็นหนึ่งในภาษาการเขียนโปรแกรมที่ใช้กันอย่างแพร่หลายที่สุดในโลก ในฐานะที่เป็นภาษาการเขียนโปรแกรมทั่วไปภาษา Java นั้นน่าสนใจมากสำหรับวิศวกรพัฒนาซอฟต์แวร์เนื่องจากชุดเครื่องมือที่ทรงพลังและสภาพแวดล้อมรันไทม์ไวยากรณ์ง่าย ๆ การสนับสนุนแพลตฟอร์มที่สมบูรณ์ (เขียนพร้อมกันทำงานทุกที่) และการสนับสนุนชุมชนที่ใช้งานอยู่อย่างมาก

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

หลักสูตรนี้มีตัวอย่างโค้ดจำนวนมาก เพื่อทำการเปรียบเทียบบางฝ่ายจะให้ตัวอย่างของ Java 7 และ Java 8 ในเวลาเดียวกัน

2. ตัวอย่างการก่อสร้าง

ในฐานะที่เป็นภาษาที่มุ่งเน้นวัตถุการสร้างวัตถุอาจเป็นหนึ่งในแนวคิดที่สำคัญที่สุดในภาษา Java ตัวสร้างมีบทบาทสำคัญในการเริ่มต้นของอินสแตนซ์วัตถุและ Java มีวิธีการที่หลากหลายในการกำหนดตัวสร้าง

2.1 วิธีการก่อสร้างโดยปริยาย (สร้าง)

Java ไม่อนุญาตให้ประกาศตัวสร้างเมื่อกำหนดคลาสและนี่ไม่ได้หมายความว่าไม่มีตัวสร้าง มาดูคำจำกัดความของคลาสต่อไปนี้:

 แพ็คเกจ com.javacodegeeks.advanced.construction; คลาสสาธารณะ noconstructor {}

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

 noconstructor สุดท้าย noconstructorInstance = neconstructor ใหม่ ();

2.2 วิธีการก่อสร้างแบบไม่มีพารามิเตอร์

ตัวสร้างพารามิเตอร์ที่ไม่มีพารามิเตอร์เป็นวิธีที่ง่ายที่สุดในการแทนที่การรวบรวม Java และสร้างตัวสร้างโดยการประกาศอย่างชัดเจน

 แพ็คเกจ com.javacodegeeks.advanced.construction; คลาสสาธารณะ noargconstructor {public noargconstructor () {// ตัวสร้างร่างกายที่นี่}}

เมื่อสร้างอินสแตนซ์วัตถุใหม่โดยใช้คำหลักใหม่ตัวสร้างด้านบนจะถูกเรียก

2.3 วิธีการก่อสร้างเหมือนพารามิเตอร์

วิธีการก่อสร้างพารามิเตอร์เป็นวิธีที่น่าสนใจและใช้กันอย่างแพร่หลายและการสร้างอินสแตนซ์ใหม่ได้รับการปรับแต่งโดยการระบุพารามิเตอร์ ตัวอย่างต่อไปนี้กำหนดตัวสร้างที่มีพารามิเตอร์สองตัว

 แพ็คเกจ com.javacodegeeks.advanced.construction; คลาสสาธารณะ constructorWithArguments {public constructorWithArguments (สตริงสุดท้าย arg1, สตริงสุดท้าย arg2) {// ตัวสร้างร่างกายที่นี่}}}

ในสถานการณ์นี้เมื่อใช้คำหลักใหม่เพื่อสร้างอินสแตนซ์พารามิเตอร์สองตัวที่กำหนดไว้ในวิธีการก่อสร้างจะต้องมีให้ในเวลาเดียวกัน

 constructorwithArguments สุดท้าย constructorWithArguments = ใหม่ constructorWithArguments ("arg1", "arg2");

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

 Public ConstructorWithArguments (สตริงสุดท้าย arg1) {this (arg1, null);}

2.4 เริ่มต้นบล็อกรหัส

นอกเหนือจากการสร้างวิธีการแล้ว Java ยังให้ตรรกะเพื่อเริ่มต้นโดยเริ่มต้นบล็อกรหัส แม้ว่าการใช้งานนี้จะหายาก แต่ก็ไม่เป็นอันตรายที่จะรู้เพิ่มเติมเกี่ยวกับเรื่องนี้

 แพ็คเกจ com.javacodegeeks.advanced.construction; การเริ่มต้นคลาสสาธารณะ {{// รหัสการเริ่มต้นที่นี่}}}

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

 แพ็คเกจ com.javacodegeeks.advanced.construction; การเริ่มต้นคลาสสาธารณะ blocks {{// รหัสการเริ่มต้นที่นี่} {// รหัสการเริ่มต้นที่นี่}}}

การเริ่มต้นบล็อกรหัสไม่ได้แทนที่ตัวสร้าง แต่สามารถปรากฏขึ้นพร้อมกัน แต่โปรดจำไว้ว่ารหัสการเริ่มต้นจะถูกดำเนินการก่อนการเรียกใช้วิธีการสร้างในไม่ช้า

 แพ็คเกจ com.javacodegeeks.advanced.construction; การเริ่มต้นคลาสสาธารณะ BLOCKANDCONSTRUCTOR {{// รหัสการเริ่มต้นที่นี่} Public ImpartizationBlockandConstructor () {}}

2.5 ตรวจสอบให้แน่ใจว่าการสร้างค่าเริ่มต้น

Java ให้การรับประกันการเริ่มต้นที่ชัดเจนและโปรแกรมเมอร์สามารถใช้ผลลัพธ์การเริ่มต้นโดยตรง อินสแตนซ์ที่ไม่ได้กำหนดค่าและตัวแปรคลาส (สถิติ) จะเริ่มต้นโดยอัตโนมัติกับค่าเริ่มต้นที่สอดคล้องกันโดยอัตโนมัติ

พิมพ์ค่าเริ่มต้น
บูลีนฟอลส์
Byte0
สั้น 0
int0
Long0L
Char/U0000
float0.0f
double0.0d
วัตถุอ้างอิงวัตถุ
ตารางที่ 1

เราใช้ตัวอย่างต่อไปนี้เพื่อตรวจสอบค่าเริ่มต้นในตารางด้านบน:

 แพ็คเกจ com.javacodegeeks.advanced.construction; การเริ่มต้นชั้นเรียนการเริ่มต้นด้วย defaults {บูลีนบูลีนส่วนตัว; Byte Byte ส่วนตัว; สมาชิกสั้น ๆ สั้น ๆ ; intmember ส่วนตัว; สมาชิกยาวยาวส่วนตัว; Charmember ส่วนตัว; ลอยตัวแบบลอยตัวส่วนตัว; Doublemember ส่วนตัว ผู้อ้างอิงวัตถุส่วนตัว; Public InitializationWithDefaults () {System.out.println ("booleanmember =" + booleanmember); System.out.println ("byteMember =" + bytemember); System.out.println ("shortmember =" + shortmember); System.out.println ("intmember =" + intmember); System.out.println ("longmember =" + longmember); System.out.println ("charmember =" + character.codepointat (ถ่านใหม่ [] {charmember}, 0)); System.out.println ("floatmember =" + floatmember); System.out.println ("doublemember =" + doublemember); System.out.println ("ผู้อ้างอิง =" + ผู้อ้างอิง); -

หลังจากอินสแตนซ์วัตถุโดยใช้คำหลักใหม่:

การเริ่มต้นขั้นสุดท้ายด้วยการเริ่มต้นเริ่มต้นด้วยการเริ่มต้น = การเริ่มต้นใหม่ withDefaults ()
คุณสามารถดูผลลัพธ์ผลลัพธ์จากคอนโซลดังนี้:

 booleanMember = falseByTemember = 0ShortMember = 0intMember = 0longMember = 0Charmember = 0FloatMember = 0.0Doublemember = 0.0ReferenceMember = NULL

2.6 ทัศนวิสัย

ตัวสร้างเป็นไปตามกฎการมองเห็นของ Java และสามารถกำหนดได้ว่าตัวสร้างสามารถเรียกได้ในคลาสอื่น ๆ ผ่านตัวดัดแปลงการควบคุมการเข้าถึงหรือไม่

Modifier แพ็คเกจการมองเห็นการมองเห็นย่อยการมองเห็นสาธารณะ
มองเห็นได้ชัดที่มองเห็นได้ชัดเจนมองเห็นได้ชัดเจน
มองไม่เห็นการมองเห็นที่มองเห็นได้และมองไม่เห็นที่มองไม่เห็น
<ไม่มีตัวดัดแปลง> มองเห็นไม่สามารถมองเห็นได้มองไม่เห็น
Invisible Invisible Table 2

2.7 การรีไซเคิลขยะ

Java (JVM จะแม่นยำ) มีกลไกการรวบรวมขยะอัตโนมัติ พูดง่ายๆเมื่อมีการสร้างวัตถุใหม่มันจะจัดสรรภายในโดยอัตโนมัติ จากนั้นเมื่อวัตถุไม่ได้อ้างอิงอีกต่อไปพวกเขาจะถูกทำลายโดยอัตโนมัติและหน่วยความจำที่เกี่ยวข้องจะถูกนำกลับมาใช้ใหม่

Java Garbage Collection ใช้กลไกการรีไซเคิลแบบ generational และขึ้นอยู่กับสมมติฐานที่ว่า "วัตถุส่วนใหญ่มีชีวิตสั้น ๆ " (นั่นคือพวกเขาจะไม่ได้รับการอ่านในไม่ช้าหลังจากที่วัตถุถูกสร้างขึ้นดังนั้นพวกเขาจึงสามารถทำลายได้อย่างปลอดภัย) โปรแกรมเมอร์ส่วนใหญ่เชื่อว่าการสร้างวัตถุใน Java นั้นไม่มีประสิทธิภาพมากดังนั้นพวกเขาจึงควรหลีกเลี่ยงการสร้างวัตถุใหม่ให้มากที่สุด ในความเป็นจริงความเข้าใจนี้ผิด ค่าใช้จ่ายในการสร้างวัตถุใน Java ค่อนข้างต่ำและรวดเร็ว ค่าใช้จ่ายขนาดใหญ่ของคนรุ่นจริงคือวัตถุการเอาชีวิตรอดในระยะยาวที่ไม่จำเป็นดังนั้นในที่สุดพวกเขาก็จะถูกย้ายไปจนถึงวัยชราและทำให้เกิดการหยุดโลก

2.8 วัตถุสุดท้าย

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

อย่างไรก็ตาม Java ยังคงให้คุณสมบัติอื่นที่คล้ายกับ destructor finalizer ซึ่งรับผิดชอบในการทำความสะอาดทรัพยากรหลายอย่าง โดยทั่วไปแล้ว Finalizer จะถูกมองว่าเป็นสิ่งที่อันตราย (เพราะสามารถนำผลข้างเคียงที่หลากหลายและปัญหาด้านประสิทธิภาพ) โดยปกติแล้ว Finalizer ไม่จำเป็นต้องพยายามหลีกเลี่ยง (ยกเว้นในสถานการณ์ที่หายากที่มีวัตถุดั้งเดิมจำนวนมาก) ไวยากรณ์การลอง-ทรัพยากรและอินเทอร์เฟซ Autocloseable ที่แนะนำใน Java 7 สามารถใช้เป็นทางเลือกในการสรุปและสามารถเขียนรหัสกระชับต่อไปนี้: สามารถเขียนได้:

 ลอง (Final InputStream ใน = files.newInputStream (พา ธ )) {// รหัสที่นี่}

3. การเริ่มต้นแบบคงที่

ข้างต้นเราเรียนรู้เกี่ยวกับการก่อสร้างและการเริ่มต้นของอินสแตนซ์ชั้นเรียน นอกจากนี้ Java ยังรองรับการสร้างการเริ่มต้นระดับชั้นเรียนที่เรียกว่าการเริ่มต้นแบบคงที่ การเริ่มต้นแบบสแตติกนั้นคล้ายกับบล็อกรหัสการเริ่มต้นที่อธิบายไว้ข้างต้นยกเว้นว่ามีการปรับเปลี่ยนคำหลักคงที่เพิ่มเติม ควรสังเกตว่าการเริ่มต้นแบบคงที่จะดำเนินการเพียงครั้งเดียวเมื่อโหลดคลาส ตัวอย่างมีดังนี้:

เช่นเดียวกับการเริ่มต้นบล็อกโค้ดสามารถกำหนดบล็อกการเริ่มต้นแบบสแตติกหลายบล็อกได้ในชั้นเรียนและตำแหน่งของพวกเขาในชั้นเรียนจะกำหนดลำดับที่พวกเขาจะดำเนินการในการเริ่มต้น ตัวอย่างมีดังนี้

 แพ็คเกจ com.javacodegeeks.advanced.construction; คลาสสาธารณะ StaticInitializationBlocks {คงที่ {// รหัสการเริ่มต้นแบบคงที่ที่นี่} คงที่ {// รหัสเริ่มต้นแบบคงที่ที่นี่}}}

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

4. โหมดตัวสร้าง

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

4.1 โหมดซิงเกิลตัน

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

 แพ็คเกจ com.javacodegeeks.advanced.construction.patterns; คลาสสาธารณะ NAIVESINGLETON {อินสแตนซ์ NAIVESINGLETONTEN แบบคงที่ส่วนตัว; ส่วนตัวไร้เดียงสา () {} สาธารณะคงที่แบบคงที่แบบคงที่ getInstance () {ถ้า (อินสแตนซ์ == null) {อินสแตนซ์ = ใหม่ naivesingleton (); } return อินสแตนซ์; -

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

 ทรัพย์สินขั้นสุดท้ายของ Class.package com.javacodegeeks.advanced.construction.patterns; Public Class Eagersingleton {ส่วนตัวคงที่ Eagersingleton Instance = New Eagersingleton (); Private Eagersingleton () {} สาธารณะคงที่ eagersingleton getInstance () {อินสแตนซ์กลับ; -

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

 แพ็คเกจ com.javacodegeeks.advanced.construction.patterns; คลาสสาธารณะ Lazysingleton {อินสแตนซ์ Lazysingleton แบบคงที่ส่วนตัว; Private Lazysingleton () {} สาธารณะคงที่แบบคงที่ lazysingleton getInstance () {ถ้า (อินสแตนซ์ == null) {อินสแตนซ์ = ใหม่ lazysingleton (); } return อินสแตนซ์; -

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

4.2 เครื่องมือ/คลาสเสริม

รูปแบบคลาสเครื่องมือ/คลาสช่วยเหลือค่อนข้างเป็นที่นิยมในหมู่นักพัฒนา Java แนวคิดหลักของมันคือการใช้คลาสที่ไม่ได้รับการกำหนด (โดยการประกาศตัวสร้างส่วนตัว) ตัวเลือกสุดท้าย (รายละเอียดเพิ่มเติมเกี่ยวกับการประกาศคลาสสุดท้ายจะถูกนำมาใช้ในคำหลัก Java Advanced 3-Class และ Interface Design) และวิธีการคงที่ ตัวอย่างมีดังนี้:

 แพ็คเกจ com.javacodegeeks.advanced.construction.patterns; ระดับสุดท้ายของคลาสสุดท้าย helperclass {private helperclass () {} โมฆะสาธารณะคงที่ helpermethod1 () {// วิธีการที่นี่} โมฆะสาธารณะคงที่

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

4.3 โมเดลโรงงาน

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

 แพ็คเกจ com.javacodegeeks.advanced.construction.patterns; หนังสือเรียนสาธารณะ {หนังสือส่วนตัว (ชื่อสตริงสุดท้าย) {} หนังสือคงที่สาธารณะนิวบุ๊ก (ชื่อสตริงสุดท้าย) {ส่งคืนหนังสือเล่มใหม่ (ชื่อเรื่อง); -

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

 อินเทอร์เฟซสาธารณะ BookFactory {Book newBook ();}

ขึ้นอยู่กับแกลเลอรี่รูปภาพเราสามารถมีการใช้งานใหม่ได้มากมาย:

 ห้องสมุดระดับสาธารณะใช้ BookFactory {@Override Public Book newBook () {ส่งคืนหนังสือเล่มใหม่ (); }} คลาสสาธารณะ KindleLibrary ใช้ BookFactory {@Override หนังสือสาธารณะ newBook () {ส่งคืน KindleBook ใหม่ (); -

ตอนนี้การใช้งานที่แตกต่างกันของ BookFactory บล็อกความแตกต่างในหนังสือเฉพาะ แต่ให้วิธีการใหม่ทั่วไป

4.4 การฉีดขึ้นอยู่กับการพึ่งพา

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

 แพ็คเกจ com.javacodegeeks.advanced.construction.patterns; นำเข้า java.text.dateFormat; นำเข้า java.util.date; ขึ้นอยู่กับคลาสสาธารณะ รูปแบบสตริงสาธารณะ (วันที่วันที่สุดท้าย) {return format.format (วันที่); -

คลาสที่ขึ้นอยู่กับต้องใช้อินสแตนซ์ของคลาส DateFormat และได้รับโดย DateFormat.getDateInstance () เมื่อสร้างอินสแตนซ์วัตถุ วิธีที่ดีกว่าควรทำสิ่งเดียวกันโดยการสร้างพารามิเตอร์ของวิธีการ:

 แพ็คเกจ com.javacodegeeks.advanced.construction.patterns; นำเข้า java.text.dateformat; นำเข้า java.util.date; ขึ้นอยู่กับคลาสสาธารณะ {รูปแบบวันที่สุดท้ายส่วนตัว; ขึ้นอยู่กับสาธารณะ (รูปแบบวันที่สุดท้าย) {this.format = รูปแบบ; } รูปแบบสตริงสาธารณะ (วันที่วันที่สุดท้าย) {return format.format (วันที่); -

ในตัวอย่างข้างต้นการพึ่งพาทั้งหมดของอินสแตนซ์คลาสมีให้ภายนอกทำให้ง่ายต่อการปรับแต่งวันที่และง่ายต่อการเขียนรหัสทดสอบ