ตัวสร้างส่วนตัวใน 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;) ตัวสร้างส่วนตัวไม่สามารถเรียกได้โดยตรงจากวัตถุไคลเอนต์ของคลาส สามารถเรียกได้ภายในโดยวิธีการของคลาสเท่านั้น (แม้แต่ส่วนตัว) คุณสามารถมีตัวสร้างส่วนตัวที่มีพารามิเตอร์ตั้งแต่หนึ่งตัวขึ้นไป คุณไม่สามารถให้ประเภทการส่งคืนของคอนสตรัคเตอร์เป็นบูลีนดั้งเดิมได้ เป็นสตริงหรือคลาสก็ได้