ที่มา: Hackenoon
Constructor มีบทบาทสำคัญในการเริ่มต้น Object และในบทความนี้ เราจะแสดงรายการคำถามสัมภาษณ์ตัวอย่างที่ครอบคลุม Constructor ใน Java นอกจากนี้คุณยังจะได้เรียนรู้เกี่ยวกับความสำคัญของคอนสตรัคเตอร์ใน Java ดูตัวอย่างโค้ดและรายละเอียดสำคัญอื่นๆ ที่จะช่วยคุณตอบคำถามเกี่ยวกับคอนสตรัคเตอร์ Java ในการสัมภาษณ์
ต่อไปเราสามารถดูโค้ดเพื่อเริ่มต้นวัตถุด้วยค่าของตัวแปรอินสแตนซ์เหล่านี้:
ตัวสร้างคืออะไร?
Constructorเป็นวิธีการพิเศษที่กำหนดในคลาสที่มีชื่อเดียวกันกับชื่อคลาส ตัวสร้าง Java เป็นเหมือนวิธีการที่ไม่มีชนิดส่งคืน
เหตุใดจึงจำเป็นต้องมีตัวสร้าง? อธิบายอย่างละเอียด
สมมติว่าเรามีคลาสชื่อStudent และเรามีชื่อตัวแปรอินสแตนซ์และ roll_numberclass Student{
String name;
int rollNo;
}
ตอนนี้ถ้าเราสร้างวัตถุ 1,000 รายการ JVM จะเริ่มต้นค่าเหล่านี้ด้วยประเภทเริ่มต้นName = nullและrollNo = 0 ไม่สามารถระบุแต่ละออบเจ็กต์เหล่านี้ได้ และการกำหนดค่าให้กับแต่ละออบเจ็กต์จะทำให้จำนวนโค้ดเพิ่มขึ้น ซึ่งถือเป็นการฝึกเขียนโปรแกรมที่ไม่ดี ดังนั้นเพื่อหลีกเลี่ยงปัญหานี้ จึงมีการใช้ตัวสร้าง นั่นคือจุดประสงค์ของ Constructor ใน Java คือการเริ่มต้นค่าของตัวแปรอินสแตนซ์ของคลาส
มี Constructor ประเภทใดบ้างใน Java?
มีตัวสร้างคอนสตรัคเตอร์สามประเภทที่แตกต่างกันใน Java:- ตัวสร้างเริ่มต้น
- ตัวสร้างที่ไม่มีอาร์กิวเมนต์
- ตัวสร้างพารามิเตอร์
ตัวสร้างเริ่มต้นใน Java คืออะไร?
ตัวสร้างเริ่มต้นคือตัวสร้างที่สร้างโดย JVM ณ รันไทม์หากไม่มีการกำหนดตัวสร้างในคลาส งานหลักของตัวสร้างเริ่มต้นคือการเริ่มต้นค่าของอินสแตนซ์ตามประเภทเริ่มต้น ตัวอย่าง Constructor เริ่มต้นใน Java:class DefaultConstructor{
int id;
String name;
}
ตอนนี้สำหรับคลาสนี้ ถ้าเราสร้างอ็อบเจ็กต์ ภายใน JVM จะมีตัวสร้างเริ่มต้นซึ่งได้รับค่าเริ่มต้น
DefaultConstructor df= new DefaultConstructor();
ตอนนี้ถ้าเราพิมพ์ค่าเราจะได้:
พิมพ์ = df.id = 0.df.name = null
ตัวสร้างที่ไม่มีอาร์กิวเมนต์คืออะไร?
ตัวสร้างที่ไม่มีอาร์กิวเมนต์คือตัวสร้างที่สามารถกำหนดได้อย่างชัดเจนเพื่อเริ่มต้นค่าของอินสแตนซ์ ตัวอย่างเช่น:class NoArgConstuctor{ int a; int b;
//No Argument Constructor
NoArgConstuctor(){
a = 10;
b = 20;
}
}
ตัวสร้างพารามิเตอร์คืออะไร?
ตัวสร้างพารามิเตอร์คือตัวสร้างที่ยอมรับพารามิเตอร์เพื่อเริ่มต้นอินสแตนซ์ ตัวอย่างเช่น:class ParameterizedConstuctor{
String name;
int age;
//Parameterized Constructor
ParameterizedConstuctor(String name, int age){
this.name = name;
this.age = age;
}
}
กฎในการกำหนดตัวสร้างมีอะไรบ้าง?
ในการกำหนดตัวสร้าง คุณต้องปฏิบัติตามกฎหลายข้อ:-
ชื่อ Constructor ต้องตรงกับชื่อคลาส
-
ไม่ควรมีประเภทส่งคืนคอนสตรัคเตอร์ใน Java
-
ตัวดัดแปลงที่ใช้ได้เฉพาะสำหรับตัวสร้างคือ:
- สาธารณะ
- ค่าเริ่มต้น
- มีการป้องกัน
- ส่วนตัว
-
ตัวสร้างสามารถรับพารามิเตอร์จำนวนเท่าใดก็ได้
-
ไม่อนุญาตให้ใช้ตัวแก้ไขขั้นสุดท้าย การซิงโครไนซ์ สแตติก และนามธรรมใน Constructor
-
Constructor ไม่สนับสนุน คำสั่ง returnภายในเนื้อความ
-
อาจมีข้อยกเว้นด้วย คำ สั่งThrow ในตัวสร้าง
-
เป็นที่ยอมรับได้ที่จะใช้Throws clauseกับ Constructor
-
ตัวสร้างไม่ควรสร้างการเรียกซ้ำ
เมื่อใดที่เราสามารถใช้ตัวสร้างส่วนตัวได้?
หากเราไม่ต้องการสร้างอ็อบเจ็กต์ของคลาสใดคลาสหนึ่งจากภายนอก เราสามารถใช้ตัวสร้างแบบปิดหรือแบบส่วนตัวได้ ด้วยการประกาศคอนสตรัคเตอร์แบบส่วนตัว เราสามารถสร้างอ็อบเจ็กต์ได้เฉพาะภายในคลาสเท่านั้น คลาสซิงเกิลตันเป็นตัวอย่างที่ดีของการใช้ตัวสร้างส่วนตัวตัวแก้ไขการเข้าถึงคอนสตรัคเตอร์เริ่มต้นจะเป็นอย่างไรหากเราไม่ได้กำหนดไว้อย่างชัดเจน
ตัวแก้ไขการเข้าถึงเริ่มต้นของ Constructor จะเหมือนกับตัวแก้ไขคลาสเสมอ หากคลาสเป็นแบบสาธารณะ Constructor ก็จะเป็นแบบสาธารณะด้วย หากคลาสเป็นแบบส่วนตัว Constructor ก็จะเป็นแบบส่วนตัวเช่นกัน สิ่งเดียวกันนี้จะเกิดขึ้นกับตัวแก้ไขการเข้าถึงอื่นๆเขียนผลลัพธ์ของโค้ดด้านล่างแล้วอธิบาย
class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class ScalerAcademy extends InterviewBit{
ScalerAcademy(){
System.out.println(" Welcome to Scaler Academy by InterviewBit");
}
}
class Main{
public static void main(String[] args) {
ScalerAcademy sc = new ScalerAcademy();
}
}
รหัสด้านบนจะพิมพ์:
ยินดีต้อนรับสู่การสัมภาษณ์Bit ยินดีต้อนรับสู่ Scaler Academy โดย InterviewBit
เราจะได้ผลลัพธ์นี้เพราะหากเราไม่ได้รวม คีย์เวิร์ด super()หรือthis() ไว้ใน Constructor ในบรรทัดแรก JVM จะใส่คีย์เวิร์ดดังกล่าวตอนรันไทม์โดยอัตโนมัติ JVM ทำเช่นนี้เนื่องจากสืบทอดมาจากคลาสอื่นและฟังก์ชันการทำงานของมันจะถูกนำมาใช้ในคลาสที่ได้รับด้วย ดังนั้น เมื่อกำหนดค่าดีฟอลต์ให้กับ อิน สแตนซ์คลาสฐาน JVM จะเพิ่ม คีย์เวิร์ด super() ตามค่าเริ่มต้น
ตรวจสอบรหัสและระบุว่าถูกต้องหรือไม่ถูกต้อง อธิบายเหตุผล
class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class ScalerAcademy extends InterviewBit{
ScalerAcademy(){
this();
System.out.println(" Welcome to Scaler Academy by InterviewBit");
}
}
class Main{
public static void main(String[] args) {
ScalerAcademy sc = new ScalerAcademy();
}
}
โค้ดด้านบนไม่ถูกต้องเนื่องจากเป็นตัวสร้างเดียวกันภายในตัว สร้าง Scaler Academy สิ่งนี้จะสร้างการเรียกซ้ำในตัวสร้างซึ่งไม่ได้รับอนุญาต ดังนั้นเราจะได้รับข้อผิดพลาดเวลาคอมไพล์ที่เกี่ยวข้องกับการเรียกตัวสร้างแบบเรียกซ้ำ
เราสามารถใช้คอนสตรัคเตอร์สองตัวในคลาสเดียวใน Java ได้หรือไม่?
ใช่ เราสามารถใช้ตัวสร้างจำนวนเท่าใดก็ได้ในคลาสเดียว โดยอยู่ภายใต้เงื่อนไขสองประการ:- พารามิเตอร์ตัวสร้างจะต้องแตกต่างกัน
- ไม่ควรมีการเรียกซ้ำในตัวสร้าง
InterviewBit(){
this("Scaler"); // Calling parameterized constructor
System.out.println(" No Argument Constructor");
}
InterviewBit(String name){
this(); // Calling no-arg constructor
System.out.println(" Constructor with Parameters.");
}
รหัสนี้ไม่ถูกต้องเนื่องจากจะทำให้เกิดการเรียกซ้ำ ตัวสร้างที่ไม่มีอาร์กิวเมนต์จะเรียกตัวสร้างที่มีพารามิเตอร์ และตัวสร้างที่มีพารามิเตอร์จะเรียกตัวสร้างที่ไม่มีอาร์กิวเมนต์
เราสามารถแทนที่ Constructor ใน Java ได้หรือไม่?
ไม่ แนวคิดเรื่อง Constructor Overloading ไม่สามารถใช้ได้กับ Javaตัวสร้างสามารถเป็นที่สิ้นสุดใน Java ได้หรือไม่?
ไม่มีคอนสตรัคเตอร์ใดที่สามารถถือเป็นที่สิ้นสุดได้ เนื่องจาก คำสำคัญ สุดท้ายถูกใช้เพื่อหยุดการแทนที่วิธีการในคลาสที่ได้รับ แต่ในตัวสร้าง แนวคิดของ การ แทนที่ใช้ไม่ได้ ดังนั้นจึงไม่จำเป็นต้องเขียน คีย์เวิร์ดสุดท้าย หากเราเขียน คีย์เวิร์ดสุดท้ายในตัวสร้าง เราจะได้รับข้อผิดพลาดเวลาคอมไพล์ที่เรียกว่าประเภทการส่งคืนที่ต้องการเนื่องจากคอมไพเลอร์ถือว่ามันเป็นวิธีการConstructor สามารถคงที่ใน Java ได้หรือไม่?
ไม่ ตัวสร้าง Java ไม่สามารถเป็นแบบคงที่ได้ เนื่องจากคีย์เวิร์ดแบบคงที่ถูกใช้เมื่อเราต้องการให้สมาชิกอยู่ในคลาสแทนที่จะเป็นออบเจ็กต์ แต่คอนสตรัคเตอร์มีไว้เพื่อเตรียมใช้งานอ็อบเจ็กต์ ดังนั้นคอมไพลเลอร์จะถือว่ามันเป็นวิธีการ เราจะได้รับ ข้อผิดพลาด ประเภทการคืนสินค้าที่จำเป็นอธิบายความแตกต่างระหว่าง super(), super และ this(), this
super()และthis()เป็นการเรียกคอนสตรัคเตอร์ ใช้เพื่อเรียก Constructor ของคลาสหลักหรือคลาสปัจจุบันเท่านั้น โปรดทราบว่า "super" และ "this" เป็นคำสำคัญที่ใช้ในการกำหนดสมาชิกของอินสแตนซ์ของคลาสของตัวเองหรือคลาสพื้นฐาน พิจารณารหัสด้านล่าง:class InterviewBit{
String message = " Welcome to InterviewBit";
}
public class Scaler extends InterviewBit
{
String message = " Welcome to Scaler Academy";
public void printMethod(){
//this will print the message variable of the current class.
System.out.println(this.message);
//this will print the message variable of Base class.
System.out.println(super.message);
}
public static void main(String[] args) {
Scaler sa = new Scaler();
sa.printMethod();
}
}
ในข้อมูลโค้ดนี้this.messageจะพิมพ์ข้อความ “ ยินดีต้อนรับสู่ Scaler Academy ” และsuper.messageจะพิมพ์ “ ยินดีต้อนรับสู่ InterviewBit ” นี่คือวิธีการใช้คำสำคัญทั้งสองนี้เพื่ออ้างถึงอินสแตนซ์สมาชิกของคลาสฐานและคลาสที่ได้รับ
ตัวทำลายคืออะไร? destructor มีอยู่ใน Java หรือไม่?
ตัวทำลายจะใช้เพื่อเพิ่มหน่วยความจำที่โปรแกรมได้มา ตัวอย่างเช่น หากโปรแกรมต้องการหน่วยความจำในระหว่างดำเนินการ ตัวทำลายจะปล่อยหน่วยความจำนั้นให้ว่างเพื่อให้โปรแกรมอื่นสามารถใช้งานได้ ไม่มีแนวคิดเกี่ยวกับ destructor ใน Java เนื่องจากงานการเพิ่มหน่วยความจำใน Java ได้รับการจัดการโดยตัวรวบรวมขยะConstructor chaining ใน Java คืออะไร?
เมื่อคอนสตรัคเตอร์ตัวหนึ่งถูกเรียกจากคอนสตรัคเตอร์ตัวอื่น สิ่งนี้สามารถเรียกว่าการผูกมัดคอนสตรัคเตอร์ ไม่จำเป็นต้องทำการเรียก Constructor ในคลาสเดียวกัน ซึ่งสามารถทำได้สำหรับชั้นเรียนผู้ปกครองเช่นกัน ตัวอย่างเช่น ลองพิจารณาภาพด้านล่าง
class EmployeeAddess{
int pinCode;
String address;
String mobNo;
EmployeeAddress(int pinCode, String address, String mobNo){
this.pinCode = pinCodel
this.address = address;
this.mobNo = mobNo;
}
}
class Employees extends EmployeeAddress{
int ID;
String name;
String designation;
String department;
Employee(int ID, String name, String designation,String department,
int pinCode, String address, String mobNo){
//Calling Constructor for Base class to initialize the object.
//This can be a constructor chaining.
super(pinCode, address, mobNo);
this.ID = ID;
this.name = name;
this.designation = designation;
this.department = department;
}
}
public class Main{
Employee emp = new Employee(101, "XYX", "SDE", "Cloud", 123456, "no 150, xys, xys, INDIA", "999999999");
}
ในโค้ดข้างต้น เรากำลังสร้าง อ็อบเจ็กต์คลาส Employeeพร้อมด้วยรายละเอียดพนักงานและที่อยู่ของเขา คลาสที่อยู่ของพนักงานนั้นสืบทอดมาจาก คลาส ของพนักงาน ตอนนี้ เพื่อยกตัวอย่างค่าอ็อบเจ็กต์สำหรับที่อยู่ เราจะไม่กำหนดค่าที่ชัดเจนให้กับที่อยู่ของพนักงาน แต่เราใช้ Constructor ของ คลาส Employee Address เพื่อทำสิ่งนี้ แทน และด้วยความช่วยเหลือของsuper(อาร์กิวเมนต์)เราจึงสร้างสายโซ่ของตัวสร้างเพื่อเริ่มต้นค่าต่างๆ นั่นคือสิ่งที่ห่วงโซ่คอนสตรัคเตอร์เป็น
หาผลลัพธ์ของโปรแกรมจากโค้ดและอธิบายคำตอบของคุณ
class InterviewBit{
void InterviewBit(){
System.out.println(" Java Constructor interview questions by InterviewBit");
}
int InterviewBit(int val){
System.out.println(" Java Constructor. And Value = "+val);
}
}
public class Main{
InterviewBit ib1 = new InterviewBit();
InterviewBit ib2 = new InterviewBit();
}
โค้ดด้านบนจะไม่พิมพ์อะไรเลย เนื่องจากInterviewBit()ไม่ใช่ Constructor ที่นี่ เนื่องจาก มีการใช้คีย์เวิร์ดVoidและintจึงกลายเป็นวิธีการ ดังนั้นเราจึงไม่เรียกวิธีการ เราจะไม่ได้รับผลลัพธ์ใด ๆ เนื่องจากเพื่อดำเนินการตามวิธีที่เราจำเป็นต้องเรียกมันบนวัตถุอย่างชัดเจน
เขียนโปรแกรมเพื่อคัดลอกค่าของวัตถุไปยังวัตถุใหม่โดยใช้ตัวสร้าง
class Rectangle{
int length;
int breadth;
Rectangle(int length, int breadth){
this.length = length;
this.breadth = breadth;
}
//Overloaded Constructor for copying the value of old Object to new object
Rectangle(Rectangle obj){
this.length = obj.length;
this.breadth = obj.breadth;
}
}
public class Main{
Rectangle obj1 = new Rectangle(10, 5);
//New Object of rectangle class will be created with the value from obj1.
Rectangle obj2 = new Rectangle(obj1);
}
GO TO FULL VERSION