ตัวสร้าง ใช้เพื่อเริ่มต้นสถานะของวัตถุ เช่นเดียวกับวิธีการตัวสร้างยังสามารถเก็บชุดคำสั่งซึ่งเรียกได้ว่าไม่มีอะไรนอกจากคำสั่ง ในบทความนี้เราจะพูดถึงตัวสร้างส่วนตัวใน ตามลำดับต่อไปนี้:
- รู้เบื้องต้นเกี่ยวกับ Constructor ใน Java
- คลาส Singleton
- ผลกระทบของ Private Constructor ใน Java
- การเชื่อมโยงตัวสร้างภายใน
- รูปแบบการออกแบบคลาส Singleton
รู้เบื้องต้นเกี่ยวกับ Constructor ใน Java
ตัวสร้างจะดำเนินการในช่วงเวลาของการสร้างวัตถุ เพื่อให้เข้าใจคอนสตรัคเตอร์และแอพพลิเคชั่นได้ดีขึ้นให้คิดว่ากล่องเป็นคลาส คลาส Box จะถือว่ามีตัวแปรคลาส (เช่นความยาวความกว้างและความสูง) อย่างไรก็ตามในช่วงเวลาของการสร้างวัตถุ (เช่นกล่องมีอยู่ในหน่วยความจำของคอมพิวเตอร์) กล่องจะมีอยู่โดยไม่มีค่าที่กำหนดไว้สำหรับปริมาณมิติ
เห็นได้ชัดว่าไม่
ดังนั้นคอนสตรัคเตอร์จึงถูกนำมาใช้เพื่อกำหนดค่าให้กับตัวแปรคลาสในการสร้างอ็อบเจ็กต์ สิ่งนี้สามารถทำได้อย่างชัดเจนโดยโปรแกรมเมอร์หรือโดย Java เอง เมื่อทำโดย Java เองมันจะถูกเรียกว่าเป็นตัวสร้างเริ่มต้น
มีความจำเป็นที่จะต้องเข้าใจว่าเมธอดใด ๆ ที่มีตัวระบุการเข้าถึงที่ผู้เขียนโค้ดจัดเตรียมไว้ให้กับคอนสตรัคเตอร์ซึ่งทำให้เป็นแบบส่วนตัวสามารถเข้าถึงได้ภายในคลาสเท่านั้น
คลาส Singleton
จากชื่อตัวเองเราสามารถเรียกคลาสว่าซิงเกิลตันได้หาก จำกัด จำนวนอ็อบเจ็กต์ของคลาสนั้นไว้ที่หนึ่ง คลาสไม่สามารถมีมากกว่าหนึ่งอ็อบเจ็กต์เดียวในกรณีเช่นนี้ คลาสซิงเกิลถูกนำมาใช้อย่างละเอียดถี่ถ้วนในแนวคิดเช่นเครือข่ายและการเชื่อมต่อฐานข้อมูล คลาส Singleton คือไฟล์ ชั้นเรียนส่วนตัว .
ต้องมีวิธีอื่นในการแยกอินสแตนซ์ของคลาสและวิธีการส่งคืนเพื่อดึงผลลัพธ์กลับมา ด้านล่างนี้เป็นภาพประกอบที่เหมาะสมเหมือนกัน ภาพแรกแสดงให้เห็นถึงผลลัพธ์ที่น่าจะเป็นโดยที่ค่าของ“ a.x” เท่ากับ 20 และค่าของ“ b.x” ได้ผลลัพธ์เป็น 20 เช่นกัน ในโค้ดในขณะที่เรากำหนดคลาสส่วนตัวแบบซิงเกิลตันตัวสร้างของมันจะไม่สามารถเข้าถึงนอกคลาสได้
ค่า a.x = 20
ค่า b.x = 20
// โปรแกรม Java เพื่อสาธิตการใช้งาน Singleton // รูปแบบโดยใช้ตัวสร้างส่วนตัว นำเข้า java.io. * class MySingleton {Static MySingleton instance = null public int x = 10 // private constructor ไม่สามารถเข้าถึงภายนอกคลาส private MySingleton () {} // วิธีการจากโรงงานเพื่อให้ผู้ใช้มีอินสแตนซ์ MySingleton สาธารณะแบบคงที่ getInstance () {if (instance == null) instance = new MySingleton () return instance}} // Driver Class Class Main {public static void main (String args []) {MySingleton a = MySingleton.getInstance () MySingleton b = MySingleton.getInstance () ax = ax + 10 System.out.println ('มูลค่าของ ax =' + ax) System.out.println ('Value of bx =' + bx)}}ผลกระทบของ Private Constructor ใน Java
คอนสตรัคเตอร์ส่วนตัวไม่สามารถเข้าถึงคลาสที่สืบทอดมาจากคลาสอื่นได้ ดังนั้นเราต้องให้ฟังก์ชันสาธารณะซึ่งเรียกว่าตัวสร้างส่วนตัว ในกรณีที่อ็อบเจ็กต์ไม่ได้ถูกกำหนดค่าเริ่มต้นหรือเราต้องส่งอินสแตนซ์กลับไปที่อ็อบเจ็กต์หากถูกเริ่มต้น นี่เป็นประโยชน์อย่างยิ่งสำหรับวัตถุซึ่งไม่สามารถเริ่มต้นได้ ตัวสร้างไพรเวตถูกใช้ในกรณีต่อไปนี้:
- คลาสตามลำดับซึ่งมีเฉพาะเมธอดและสมาชิกแบบคงที่
- คลาสเฉพาะซึ่งใช้กันอย่างแพร่หลายเฉพาะสมาชิกสุดท้ายแบบคงที่ (ค่าคงที่)
- เพื่อรวมเสื้อกล้าม
- เพื่อรวมวิธีการของโรงงาน
เพื่อใช้การแจงนับซึ่งเป็นประเภทที่ปลอดภัย
การเชื่อมโยงตัวสร้างภายใน
คอนสตรัคเตอร์ภายในคือการที่คอนสตรัคเตอร์เรียกคอนสตรัคเตอร์อื่นในคลาสเดียวกันจากนั้นสามารถเรียกว่าคอนสตรัคเตอร์คอนสตรัคเตอร์ เป็นหน้าที่ของเราที่จะใช้คีย์เวิร์ดนี้เพื่อเรียกคอนสตรัคเตอร์อื่นของคลาส ในบางกรณีจะใช้เพื่อกำหนดค่าเริ่มต้นของตัวแปรคลาส โปรดทราบว่าการเรียกตัวสร้างอื่นจะต้องเป็นคำสั่งแรกในบล็อกโค้ด
นอกจากนี้ไม่ควรมีการเรียกซ้ำซึ่งจะทำให้เกิดการวนซ้ำแบบไม่สิ้นสุด ตอนนี้ให้เราดูตัวอย่างของคอนสตรัคเตอร์ที่เชื่อมโยงในโปรแกรม java
package com.journaldev.constructor public class Employee {private int id private String name public Employee () {this ('John Doe', 999) System.out.println ('Default Employee Created')} public Employee (int i) { this ('John Doe', i) System.out.println ('Employee Created with Default Name')} public Employee (String s, int i) {this.id = i this.name = s System.out.println ( 'Employee Created')} public static void main (String [] args) {Employee emp = new Employee () System.out.println (emp) Employee emp1 = new Employee (10) System.out.println (emp1) Employee emp2 = พนักงานใหม่ ('Pankaj', 20) System.out.println (emp2)} @Override public String toString () {return 'ID =' + id + ', Name =' + name} public int getId () {return id } โมฆะสาธารณะ setId (int id) {this.id = id} public String getName () {return name} public void setName (String name) {this.name = name}}รูปแบบการออกแบบคลาส Singleton
java บัฟเฟอร์คืออะไร
สมาชิกระดับคลาส (วิธีการเริ่มต้นอย่างกระตือรือร้น):
ขั้นแรกสร้างอินสแตนซ์คงที่ส่วนตัวของคลาสซิงเกิลตัน
จากนั้นเขียนวิธีการแบบคงที่ซึ่งจะส่งคืนอ็อบเจ็กต์ของคลาสซิงเกิลตันซึ่งเราสร้างขึ้นเป็นอินสแตนซ์สมาชิกคลาส
เป็นไปได้ที่จะทำเครื่องหมายสมาชิกแบบคงที่เป็นสาธารณะเพื่อเข้าถึงอินสแตนซ์แบบคงที่โดยตรง
คลาส singleton แตกต่างจากคลาส Java ปกติในแง่ของการสร้างอินสแตนซ์ ในคลาสปกติจะใช้ตัวสร้าง แต่สำหรับคลาสซิงเกิลตันเราใช้เมธอด get Instance ()
สมาชิกระดับคลาส (Lazy Initialization Method):
ขั้นแรกให้เริ่มตัวสร้างเป็นส่วนตัว
จากนั้นสร้างอินสแตนซ์แบบคงที่ส่วนตัวของคลาสซิงเกิลตันนี้ โปรดทราบว่าอย่าสร้างอินสแตนซ์
จากนั้นเขียนวิธีการแบบคงที่ซึ่งตรวจสอบสมาชิกอินสแตนซ์แบบคงที่ว่าเป็นโมฆะและเริ่มต้นอินสแตนซ์ สุดท้ายจะส่งคืนอ็อบเจ็กต์ของคลาสซิงเกิลตัน
สมาชิกระดับคลาส (Lazy Initialization with double lock Method):
พิจารณาสองเธรดที่ทำงานโดยที่ทั้งคู่อยู่ในคำสั่ง“ if” พร้อมกันในขณะที่อินสแตนซ์เป็นโมฆะ โดยที่เธรดหนึ่งจะเข้าไปในบล็อกที่ซิงโครไนซ์เพื่อสร้างอินสแตนซ์ในขณะที่อีกเธรดหนึ่งถูกบล็อก เนื่องจากเธรดแรกอยู่ในบล็อกที่ซิงโครไนซ์เธรดในคิวจึงสร้างอ็อบเจ็กต์เดี่ยวอื่น โปรดทราบว่าเนื่องจากเธรดที่สองเข้าสู่บล็อกที่ซิงโครไนซ์จึงไม่สามารถตรวจสอบได้ว่าอินสแตนซ์นั้นไม่เป็นโมฆะหรือไม่
การใช้คลาสภายในที่ซ้อนกัน (วิธีการโหลดแบบ Lazy Load):
ที่นี่เป็นไปตามข้อกำหนดของภาษา Java (JLS) Java Virtual Machine จะโหลดสมาชิกข้อมูลแบบคงที่ตามความต้องการเท่านั้น ดังนั้นคลาส Singleton จึงโหลดก่อนโดย JVM ดังนั้นจึงไม่มีสมาชิกข้อมูลคงที่ในคลาส
Singleton Class Holder ไม่โหลด SINGLE_INSTANCE เมื่อเราเรียกใช้เมธอด getIntance สิ่งนี้จะเกิดขึ้นเท่านั้น JLS รับประกันการดำเนินการเริ่มต้นของคลาส ข้อกำหนดสำหรับการซิงโครไนซ์อย่างชัดเจนบนเมธอด getInstance () แบบคงที่สำหรับการโหลดและการกำหนดค่าเริ่มต้น เมื่อการเริ่มต้นสร้างตัวแปรแบบคงที่ SINGLE_INSTANCE ในลักษณะตามลำดับการเรียกใช้ getInstance () พร้อมกันทั้งหมดจะกลับมาเหมือนเดิมโดยไม่มีค่าโสหุ้ยการซิงโครไนซ์
โดยใช้ Enums
ซีลีเนียม webdriver พร้อมตัวอย่างแตงกวาในคราส
วิธีการข้างต้นไม่ได้เป็นวิธีแก้ปัญหาที่สมบูรณ์ในทุกกรณี สามารถสร้างอินสแตนซ์ต่างๆของการใช้งานข้างต้นได้โดยใช้การสะท้อน ในทั้งสองสถานการณ์เราสามารถข้ามตัวสร้างส่วนตัวและสร้างหลายอินสแตนซ์ได้ ดังนั้นแนวทางใหม่คือการสร้างคลาสซิงเกิลตันโดยใช้ enums เนื่องจากฟิลด์ enums รวบรวมค่าคงที่ของเวลาจึงเป็นอินสแตนซ์ของประเภท enum พวกเขาถูกสร้างขึ้นเมื่อมีการอ้างอิงประเภท enum เป็นครั้งแรก
ด้วยเหตุนี้เราจึงมาถึงตอนท้ายของบทความ Private Constructor ใน Java ฉันหวังว่าคุณจะมีความเข้าใจเกี่ยวกับ Private Constructors และวิธีการใช้งานใน Java
ตรวจสอบไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ซึ่งมีเครือข่ายผู้เรียนที่พึงพอใจมากกว่า 250,000 คนกระจายอยู่ทั่วโลก หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ออกแบบมาสำหรับนักเรียนและผู้เชี่ยวชาญที่ต้องการเป็น Java Developer หลักสูตรนี้ออกแบบมาเพื่อให้คุณเริ่มต้นการเขียนโปรแกรม Java และฝึกอบรมแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับเฟรมเวิร์ก Java ต่างๆเช่น Hibernate & Spring
มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบล็อก 'Java Tutorial' และเราจะติดต่อกลับโดยเร็วที่สุด