คอฟฟี่เบรค #123. Java Constructor - คำถามและคำตอบในการสัมภาษณ์ทางเทคนิค

ที่มา: Hackenoon

ตัวสร้างคืออะไร?

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

เหตุใดจึงจำเป็นต้องมีตัวสร้าง? อธิบายอย่างละเอียด

สมมติว่าเรามีคลาสชื่อStudent และเรามีชื่อตัวแปรอินสแตนซ์และ roll_number

class 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();

ตอนนี้ถ้าเราพิมพ์ค่าเราจะได้:

ตัวสร้างที่ไม่มีอาร์กิวเมนต์คืออะไร?

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

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();
}
}

รหัสด้านบนจะพิมพ์: เราจะได้ผลลัพธ์นี้เพราะหากเราไม่ได้รวม คีย์เวิร์ด 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 เดียวกัน :

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);
}