Coffee break #123. Java Constructor - Mga Tanong at Sagot sa Teknikal na Panayam

Pinagmulan: Hackenoon

Ano ang Constructor?

Ang Constructor ay isang espesyal na pamamaraan na tinukoy sa isang klase na may parehong pangalan bilang pangalan ng klase. Ang isang tagabuo ng Java ay tulad ng isang pamamaraan na walang uri ng pagbabalik. Ang mga konstruktor ay gumaganap ng pinakamahalagang papel sa pagsisimula ng mga bagay at sa artikulong ito, ililista namin ang mga sample na tanong sa panayam na sumasaklaw sa mga konstruktor sa Java. Malalaman mo rin ang tungkol sa kahalagahan ng mga konstruktor sa Java, tingnan ang mga halimbawa ng code at iba pang mahahalagang detalye na makakatulong sa iyong sagutin ang mga tanong tungkol sa mga konstruktor ng Java sa isang panayam.

Bakit kailangan ang mga konstruktor? Ipaliwanag nang detalyado

Sabihin nating mayroon tayong klase na pinangalanang Estudyante . At mayroon kaming instance variable name at roll_number .

class Student{
String name;
int rollNo;
}

Ngayon, kung gagawa tayo ng 1000 bagay, ang JVM ay magsisimula ng mga halagang ito gamit ang default na uri nito Pangalan = null at rollNo = 0 . Ang pagkilala sa mga indibidwal na bagay na ito ay hindi posible, at ang pagtatalaga ng mga halaga sa bawat isa sa mga bagay ay tataas ang dami ng code, na itinuturing na masamang kasanayan sa programming. Samakatuwid, upang maiwasan ito, ginagamit ang mga konstruktor. Iyon ay, ang layunin ng isang constructor sa Java ay upang simulan ang halaga ng mga variable na halimbawa ng klase.

Anong mga uri ng mga konstruktor ang mayroon sa Java?

Mayroong tatlong magkakaibang uri ng mga konstruktor sa Java:

• Default na Tagabuo
• No-Argument Constructor
• Parameterized na Tagabuo

Ano ang Default Constructor sa Java?

Ang Default Constructor ay isang constructor na nilikha ng JVM sa runtime kung walang constructor na tinukoy sa klase. Ang pangunahing gawain ng default na tagabuo ay upang simulan ang mga halaga ng mga pagkakataon ayon sa kanilang default na uri. Halimbawa ng default na tagabuo sa Java:

class DefaultConstructor{
int id;
String name;
}

Ngayon para sa klase na ito, kung lumikha tayo ng isang bagay, pagkatapos ay sa loob ng JVM magkakaroon ng isang default na tagabuo na bibigyan ng isang default na halaga.

DefaultConstructor df= new DefaultConstructor();

Ngayon kung i-print natin ang halaga ay makukuha natin:

Ano ang No-Argument Constructor?

Ang constructor na walang argumento ay isang constructor na maaaring tahasang tukuyin upang masimulan ang halaga ng mga pagkakataon. Halimbawa:

class NoArgConstuctor{ int a; int b;

//No Argument Constructor
NoArgConstuctor(){
a = 10;
b = 20;
}

}

Ano ang Parameterized Constructor?

Ang isang parameterized constructor ay isang constructor na tumatanggap ng isang parameter upang simulan ang mga pagkakataon. Halimbawa:

class ParameterizedConstuctor{
String name;
int age;
//Parameterized Constructor
ParameterizedConstuctor(String name, int age){
this.name = name;
this.age = age;
}
}

Ano ang mga patakaran para sa pagtukoy ng isang constructor?

Upang tukuyin ang mga konstruktor, dapat mong sundin ang ilang mga patakaran:

• Dapat tumugma ang pangalan ng constructor sa pangalan ng klase.

• Hindi dapat magkaroon ng constructor return type sa Java.

• Ang tanging naaangkop na mga modifier para sa mga konstruktor ay:

  • pampubliko
  • default
  • protektado
  • pribado

• Ang mga konstruktor ay maaaring kumuha ng anumang bilang ng mga parameter.

• Ang mga modifier na pinal, naka-synchronize, static at abstract ay hindi pinapayagan sa isang constructor.

• Hindi sinusuportahan ng constructor ang isang return statement sa loob ng katawan nito.

• Maaaring may mga pagbubukod sa isang throw statement sa constructor .

• Ito ay katanggap-tanggap na gumamit ng throws clause na may constructor.

• Ang constructor ay hindi dapat bumuo ng recursion.

Kailan tayo maaaring gumamit ng pribadong tagabuo?

Kung hindi namin nais na lumikha ng mga bagay ng isang tiyak na klase mula sa labas, maaari kaming gumamit ng mga sarado o pribadong konstruktor. Sa pamamagitan ng pagdedeklara ng mga constructor na pribado, makakagawa lamang tayo ng mga bagay sa loob ng klase. Ang mga klase ng singleton ay isang magandang halimbawa ng paggamit ng mga pribadong konstruktor.

Ano ang magiging default na constructor access modifier kung hindi natin ito tahasan?

Ang default na access modifier ng isang constructor ay palaging magiging pareho sa class modifier. Kung pampubliko ang klase, magiging pampubliko din ang constructor. Kung pribado ang klase, magiging pribado din ang constructor. Ang parehong ay mangyayari sa iba pang mga access modifier.

Isulat ang output ng snippet ng code sa ibaba at ipaliwanag

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

Ang code sa itaas ay magpi-print: Makukuha natin ang output na ito dahil kung hindi natin isasama ang super() o this() na keyword sa constructor sa unang linya, awtomatikong ilalagay ito ng JVM sa runtime. Ginagawa ito ng JVM dahil nagmana ito mula sa ibang klase at ang functionality nito ay ipapatupad din sa nagmula na klase. Kaya, kapag nagtatalaga ng mga default na halaga sa mga instance ng base class, idinaragdag ng JVM ang super() na keyword bilang default .

Suriin ang code at ipahiwatig kung ito ay wasto o hindi wasto. Ipaliwanag ang dahilan

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

Ang code sa itaas ay hindi wasto dahil ito ay ang parehong constructor sa loob ng Scaler Academy constructor . Lumilikha ito ng recursion sa constructor, na hindi pinapayagan. Alinsunod dito, makakatanggap kami ng error sa compile-time na nauugnay sa tawag sa recursive constructor.

Maaari ba tayong gumamit ng dalawang konstruktor sa isang klase sa Java?

Oo, maaari naming gamitin ang anumang bilang ng mga konstruktor sa isang klase, napapailalim sa dalawang kundisyon:

• Ang mga parameter ng constructor ay dapat na iba.
• Dapat ay walang recursion sa constructor.

Halimbawa. Isaalang-alang ang dalawang konstruktor ng parehong klase ng 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.");
}

Hindi wasto ang code na ito dahil lilikha ito ng recursion. Ang isang constructor na walang mga argumento ay tatawag ng isang constructor na may mga parameter, at isang constructor na may mga parameter ay tatawag sa isang constructor na walang mga argumento.

Maaari ba nating i-override ang isang constructor sa Java?

Hindi, ang konsepto ng constructor overloading ay hindi naaangkop sa Java.

Maaari bang maging pangwakas ang isang konstruktor sa Java?

Walang constructor ang maaaring maging pangwakas. Ito ay dahil ang panghuling mga keyword ay ginagamit upang ihinto ang pag-override sa isang paraan sa isang nagmula na klase. Ngunit sa isang constructor, hindi nalalapat ang konsepto ng overriding, kaya hindi na kailangang isulat ang panghuling keyword . Kung isusulat natin ang panghuling keyword sa constructor, makakakuha tayo ng error sa oras ng pag-compile na tinatawag na kinakailangang uri ng pagbabalik dahil itinuturing ito ng compiler bilang isang paraan.

Maaari bang maging static ang isang constructor sa Java?

Hindi, ang isang Java constructor ay hindi maaaring maging static. Ito ay dahil ang mga static na keyword ay ginagamit kapag gusto naming mapabilang ang isang miyembro sa isang klase kaysa sa isang bagay. Ngunit ang mga konstruktor ay sinadya upang simulan ang mga bagay, kaya ituturing ito ng compiler bilang isang paraan. Makakakuha kami ng kinakailangang error sa uri ng pagbabalik .

Ilarawan ang pagkakaiba sa pagitan ng super(), super at this(), ito

super() at ito() ay mga constructor na tawag. Ginagamit lamang ito upang tawagan ang constructor ng parent class o ang kasalukuyang klase. Tandaan na ang "sobrang" at "ito" ay mga keyword na ginagamit upang magtalaga ng mga miyembro ng isang instance ng sarili nitong klase o baseng klase. Isaalang-alang ang code sa ibaba:

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

Sa snippet ng code na ito, ipi-print ng this.message ang mensaheng “ Welcome to Scaler Academy ” at ipi-print ng super.message ang “ Welcome to InterviewBit ”. Ito ay kung paano ginagamit ang dalawang keyword na ito upang sumangguni sa mga instance ng miyembro ng base at nagmula na mga klase.

Ano ang mga destructors? Mayroon bang isang destructor sa Java?

Ang mga destructor ay ginagamit upang palayain ang memorya na nakuha ng isang programa. Halimbawa, kung ang memorya ay kailangan ng isang programa sa panahon ng pagpapatupad nito, pinapalaya ng destructor ang memorya na iyon upang magamit ito ng ibang mga programa. Walang konsepto ng isang destructor sa Java dahil ang gawain ng pagpapalaya ng memorya sa Java ay pinangangasiwaan ng tagakolekta ng basura.

Ano ang constructor chaining sa Java?

Kapag ang isang constructor ay tinawag mula sa isa pang constructor, ito ay matatawag na constructor chaining. Ang constructor call ay hindi kailangang gawin sa parehong klase. Magagawa rin ito para sa klase ng magulang. Para sa isang halimbawa, isaalang-alang ang larawan sa ibaba. Susunod, maaari nating tingnan ang code upang masimulan ang bagay na may mga halaga ng halaga ng mga variable na ito ng halimbawa:

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

Sa code sa itaas, gumagawa kami ng object ng Employee class na may mga detalye ng empleyado at kanyang address. Ang klase ng address ng Empleyado ay minana ng Employee class . Ngayon, para mag-instantiate ng object value para sa isang address, hindi kami nagtatalaga ng tahasang value sa address ng empleyado. Sa halip, ginagamit namin ang constructor ng klase ng Employee Address para gawin ito . At sa tulong ng mga super(argument) ay bumubuo kami ng isang kadena ng mga konstruktor upang masimulan ang mga halaga. Iyan ay kung ano ang isang constructor chain ay.

Tukuyin ang output ng programa mula sa code at ipaliwanag ang iyong sagot.

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

Ang code sa itaas ay hindi magpi-print ng anuman dahil ang InterviewBit() ay hindi isang constructor dito. Dahil ang Void at int na mga keyword ay ginagamit , ito ay nagiging isang paraan. Samakatuwid hindi namin tinatawag ang pamamaraan. Hindi kami makakakuha ng anumang output dahil upang maisagawa ang pamamaraan na kailangan naming tahasan itong tawagan sa bagay.

Sumulat ng isang programa upang kopyahin ang mga halaga ng isang bagay sa isang bagong bagay gamit ang isang constructor

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