ตัวสร้างส่วนตัวใน Java: กรณีการใช้งานอธิบายด้วยตัวอย่าง
เผยแพร่แล้ว: 2021-04-09สารบัญ
บทนำ
คอน สตรัคเตอร์ส่วนตัวใน Java ใช้ในการจำกัดการสร้างอ็อบเจ็กต์ มันเป็นตัวสร้างอินสแตนซ์พิเศษที่ใช้ในคลาสคงที่สำหรับสมาชิกเท่านั้น หากคอนสตรัคเตอร์ถูกประกาศเป็นไพรเวต วัตถุนั้นสามารถเข้าถึงได้จากภายในคลาสที่ประกาศเท่านั้น คุณไม่สามารถเข้าถึงวัตถุจากภายนอกคลาสตัวสร้าง
กรณีใช้งานตัวสร้างส่วนตัว
ตัว สร้างส่วนตัวใน Java สามารถเข้าถึงได้จากภายในคลาสเท่านั้น คุณไม่สามารถเข้าถึงตัวสร้างส่วนตัวจากคลาสอื่น หากวัตถุยังไม่ได้เริ่มต้น คุณสามารถเขียนฟังก์ชันสาธารณะเพื่อเรียกผู้สอนส่วนตัวได้ หากอ็อบเจกต์ถูกเตรียมใช้งานแล้ว คุณจะส่งคืนได้เฉพาะอินสแตนซ์ของอ็อบเจ็กต์นั้นเท่านั้น ตัว สร้างส่วนตัวใน Java มีกรณีการใช้งานดังต่อไปนี้:
- คุณสามารถใช้กับคลาสคงที่สำหรับสมาชิกเท่านั้น
- คุณสามารถใช้กับ ยูทิลิตี้สแตติก หรือคลาสคงที่
- คุณสามารถใช้เพื่อให้บริการคลาสซิงเกิลตัน
- คุณสามารถใช้เพื่อกำหนดชื่อ เช่น การสร้างโดยใช้วิธีการจากโรงงาน
- คุณสามารถใช้เพื่อป้องกันการจัดคลาสย่อย
ซิงเกิลตันคลาส
ตัว สร้างส่วนตัวใน Java ใช้เพื่อสร้างคลาสซิงเกิลตัน คลาสซิงเกิลตันคือคลาสใน Java ที่จำกัดจำนวนของอ็อบเจ็กต์ของคลาสที่ประกาศให้เป็นหนึ่งคลาส คอน สตรัคเตอร์ส่วนตัวใน Java ช่วยให้มั่นใจว่ามีการสร้างอ็อบเจ็กต์เพียงครั้งละหนึ่งอ็อบเจ็กต์ มันจำกัดอินสแตนซ์ของคลาสภายในคลาสที่ประกาศ เพื่อไม่ให้สร้างอินสแตนซ์ของคลาสนอกคลาสที่ประกาศ คุณสามารถใช้คลาสซิงเกิลตันในแนวคิดเกี่ยวกับเครือข่ายและการเชื่อมต่อฐานข้อมูล
ตัวอย่างที่ 1: ตัวอย่างต่อไปนี้แสดงให้เห็นว่า คอนสตรัคเตอร์ส่วนตัวใน Java จำกัดจำนวนของอ็อบเจ็กต์ในคลาสซิงเกิลตันอย่างไร
นำเข้า java.io.*; คลาส newTestClass { วัตถุ newTestClass แบบคงที่ = null; int สาธารณะ a = 20; newTestClass ส่วนตัว () { } // เราได้สร้างตัวสร้างส่วนตัว สแตติก newTestClass displayInstance() สาธารณะแบบคงที่ /** *displayInstance() เป็นวิธีการสาธารณะที่เราจะใช้เพื่อสร้างอินสแตนซ์ *เรียกเมธอดนี้เพื่อเข้าถึงอินสแตนซ์เหล่านี้จากภายนอกคลาส */ { ถ้า (วัตถุ == null) วัตถุ = newTestClass(); //สร้างอ็อบเจกต์คลาส singleton ส่งคืนวัตถุ; } } คลาสสาธารณะ SingletonClass { โมฆะคงที่สาธารณะหลัก (สตริง args []) { newTestClass instance1 = newTestClass.displayInstance (); //แสดงตัวอย่างคลาสซิงเกิลตันโดยเรียกเมธอดสาธารณะ newTestClass instance2 = newTestClass.displayInstance (); //แสดงตัวอย่างคลาสซิงเกิลตันโดยเรียกเมธอดสาธารณะ instance1.a = อินสแตนซ์1.a + 26; System.out.println(“อินสแตนซ์ 1 ที่สร้างมีค่าต่อไปนี้ =” + instance1.a); System.out.println(“อินสแตนซ์ 2 ที่สร้างมีค่าต่อไปนี้ =” + instance2.a); } } |
เอาท์พุต
อินสแตนซ์ 1 ที่สร้างมีค่าต่อไปนี้ = 46 ตัวอย่างที่ 2 ที่สร้างมีค่าต่อไปนี้ = 46 |
ในโปรแกรมข้างต้น ค่าของอินสแตนซ์ 2 จะได้รับการอัปเดตโดยอัตโนมัติเมื่อเราอัปเดตค่าอ็อบเจ็กต์ instance1 การสังเกตนี้แสดงให้เห็นว่าทั้งอินสแตนซ์ที่ 1 และอินสแตนซ์ที่ 2 อ้างถึงวัตถุเดียวกัน
ตัวอย่างที่ 2: ตัวอย่างต่อไปนี้แสดงให้เห็นว่า คอนสตรัคเตอร์ส่วนตัวใน Java ช่วยให้มั่นใจได้ว่าจะไม่มีการสร้างอ็อบเจ็กต์มากกว่าหนึ่งรายการในแต่ละครั้ง
// โปรแกรม Java สำหรับการใช้งานคลาสซิงเกิลตัน นำเข้า java.io.*; คลาสสาธารณะ newTestClass { ส่วนตัวคงที่ newTestClass var=null; ส่วนตัว newTestClass(){ //Private Constructor สามารถเข้าถึงได้ภายในคลาส } newTestClass testObject() สแตติกสาธารณะแบบคงที่ { // เมธอดนี้ทำให้แน่ใจว่าสร้างอ็อบเจ็กต์ครั้งละหนึ่งอ็อบเจ็กต์เท่านั้น ถ้า(var==null){ var= newTestClass(); ใหม่ } ผลตอบแทน var; } การแสดงโมฆะสาธารณะ (){ System.out.println("นี่คือตัวอย่างของตัวสร้างส่วนตัวโดยใช้คลาส Singleton "); } โมฆะคงที่สาธารณะหลัก (สตริง args[]){ newTestClass newObject= newTestClass.testObject(); newObject.display(); } } |
เอาท์พุต
นี่คือตัวอย่างของตัวสร้างส่วนตัวโดยใช้คลาส Singleton
ตัวอย่างที่ 2: Private Constructor ใน Java เพื่อจำกัดจำนวนอินสแตนซ์ของคลาส
ตัวอย่างนี้สาธิตวิธีที่คุณสามารถจำกัดจำนวนของอินสแตนซ์ของคลาสโดยการประกาศคอนสตรัคเตอร์ส่วนตัว
LimitInstanceCreationClass คลาสสาธารณะ { โมฆะคงที่สาธารณะหลัก (สตริง [] args) { จำกัดอินสแตนซ์ obj; int a=1; ในขณะที่(a<=20) { obj = RestrictInstance.getLimInstance(); ++; } } } คลาส RestrictInstance { คงที่สาธารณะ int varCount = 0; /** *สร้างตัวสร้างส่วนตัวที่เพิ่มจำนวน *ของตัวแปร varCount หลังจากสร้างอินสแตนซ์แต่ละครั้ง */ จำกัดส่วนตัว () { varCount++; System.out.println(“สร้างหมายเลขอินสแตนซ์ ” + varCount + ” ); }
RestrictInstance getLimInstance () ที่ซิงโครไนซ์สาธารณะแบบคงที่ { ถ้า (varCount <5) { ส่งคืน RestrictInstance(); } System.out.println("ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป"); System.gc(); คืนค่าเป็นโมฆะ; } /** *ลบอินสแตนซ์และลดจำนวน *ของตัวแปร varCount */ สิ้นสุดโมฆะสาธารณะ () { System.out.println(“อินสแตนซ์ถูกลบแล้ว”); varCount–; }} |
เอาท์พุต
สร้างอินสแตนซ์หมายเลข 1 แล้ว สร้างอินสแตนซ์หมายเลข 2 แล้ว สร้างอินสแตนซ์หมายเลข 3 แล้ว สร้างอินสแตนซ์หมายเลข 4 แล้ว สร้างอินสแตนซ์หมายเลข 5 แล้ว ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป อินสแตนซ์ถูกลบ อินสแตนซ์ถูกลบ อินสแตนซ์ถูกลบ อินสแตนซ์ถูกลบ ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป สร้างอินสแตนซ์หมายเลข 1 แล้ว สร้างอินสแตนซ์หมายเลข 2 แล้ว สร้างอินสแตนซ์หมายเลข 3 แล้ว สร้างอินสแตนซ์หมายเลข 4 แล้ว สร้างอินสแตนซ์หมายเลข 5 แล้ว ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป ถึงขีดจำกัดสูงสุดของอินสแตนซ์แล้ว คุณไม่ได้รับอนุญาตให้สร้างอินสแตนซ์อีกต่อไป อินสแตนซ์ถูกลบ อินสแตนซ์ถูกลบ อินสแตนซ์ถูกลบ สร้างอินสแตนซ์หมายเลข 1 แล้ว สร้างอินสแตนซ์หมายเลข 2 แล้ว สร้างอินสแตนซ์หมายเลข 3 แล้ว สร้างอินสแตนซ์หมายเลข 4 แล้ว สร้างอินสแตนซ์หมายเลข 5 แล้ว |
เรียนรู้ หลักสูตรซอฟต์แวร์ออนไลน์ จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม PG สำหรับผู้บริหาร โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว
บทสรุป
รหัสที่ใช้ในบทความมีวัตถุประสงค์เพื่อการอธิบายเท่านั้น คุณสามารถแก้ไขคำสั่งที่ให้ไว้ในตัวอย่างได้ตามความต้องการของคุณ ในบล็อกนี้ เราได้พูดถึงวิธีที่ คอนสตรัคเตอร์ส่วนตัวใน Java จำกัดจำนวนอ็อบเจ็กต์ในคลาสซิงเกิลตัน
คุณสามารถลองใช้โค้ดเพื่อเสริม ความรู้ของคอนสตรัคเตอร์ Java ของคุณ หากคุณต้องการได้รับความเข้าใจในเชิงลึกเกี่ยวกับ Java ให้ดูที่ upGrad Executive PG Program ในหลักสูตร Full Stack Development ที่ออกแบบมาสำหรับมืออาชีพที่ทำงานเพื่อให้ได้ความเชี่ยวชาญในด้านนี้
คอนสตรัคเตอร์ในการเขียนโปรแกรมคืออะไร?
ตัวสร้างในการเขียนโปรแกรมคือเมธอดที่ถูกเรียกโดยอัตโนมัติเมื่ออ็อบเจกต์ถูกเตรียมใช้งาน จุดประสงค์ของตัวสร้างคือการเริ่มต้นวัตถุ ตัวสร้างควรเป็นแบบสาธารณะเสมอและมีการประกาศโดยไม่มีประเภทการส่งคืน ตัวสร้างใช้เพื่อเริ่มต้นวัตถุและทำงานอื่น ๆ ที่สามารถทำได้เพียงครั้งเดียว ตัวสร้างยังใช้เพื่อดำเนินการเริ่มต้นของคลาส กล่าวคือ เพื่อดำเนินงานที่สร้างคลาส
คอนสตรัคเตอร์ใน Java มีกี่ประเภท?
คอนสตรัคเตอร์ใน Java มีห้าประเภท คอนสตรัคเตอร์ที่ไม่มีอาร์กิวเมนต์: มีการใช้งานเริ่มต้นซึ่งจะดำเนินการเมื่อโหลดคลาสลงในหน่วยความจำ คลาสที่ไม่มีคอนสตรัคเตอร์ไม่มีอาร์กิวเมนต์จะต้องประกาศเป็นขั้นสุดท้าย ตัวสร้างเริ่มต้น: ตัวสร้างนี้ถูกสร้างขึ้นเมื่อคลาสถูกเขียนใน Java และใช้เพื่อเริ่มต้นตัวแปร (แอตทริบิวต์) ของคลาสทั้งหมดให้เป็นค่าเริ่มต้น (ศูนย์หรือค่าว่าง) ตัวสร้างพารามิเตอร์: ตัวสร้างนี้ใช้เพื่อเริ่มต้นตัวแปรบางตัวจากค่าบางค่า ตัวสร้างที่ไม่มีค่าส่งคืน: ใช้เพื่อเริ่มต้นตัวแปรบางตัวจากค่าบางค่า ตัวสร้างที่มีค่าส่งคืน: ใช้เพื่อเริ่มต้นตัวแปรบางตัวจากค่าบางค่าและส่งคืนด้วยค่า
คอนสตรัคเตอร์ส่วนตัวใน Java คืออะไร?
ตัวสร้างส่วนตัวสามารถใช้เพื่อสร้างคลาสที่ไม่เปลี่ยนรูปได้ โดยไม่ต้องใช้ตัวสร้างส่วนตัว เราสามารถสร้างคลาสที่ไม่เปลี่ยนรูปแบบได้โดยการประกาศคลาส Final และสร้างคุณสมบัติทั้งหมดเป็น Final (เช่น Private Final String name;) ตัวสร้างส่วนตัวไม่สามารถเรียกได้โดยตรงจากวัตถุไคลเอนต์ของคลาส สามารถเรียกได้ภายในโดยวิธีการของคลาสเท่านั้น (แม้แต่ส่วนตัว) คุณสามารถมีตัวสร้างส่วนตัวที่มีพารามิเตอร์ตั้งแต่หนึ่งตัวขึ้นไป คุณไม่สามารถให้ประเภทการส่งคืนของคอนสตรัคเตอร์เป็นบูลีนดั้งเดิมได้ เป็นสตริงหรือคลาสก็ได้