Constructor Chaining sa Java

Ano ang Constructor Chaining?

Ang isang constructor sa Java ay isang tiyak na paraan na ginagamit sa paglikha ng object ng isang klase. Ang constructor ay hinihingi sa bawat oras na ang isang bagay ng klase ay nilikha. Maaari itong magamit upang magtalaga ng mga halaga sa mga katangian ng bagay sa oras ng paglikha. Maaaring mayroong maraming mga konstruktor sa isang klase ng Java na may iba't ibang mga listahan ng parameter. Ginagamit ang constructor chaining upang mag-invoke ng iba't ibang pagpapatupad ng mga constructor ng parehong klase/parent class sa oras ng paggawa ng object.

Paano ipinapatupad ang constructor chaining sa Java?

Mayroong dalawang paraan ng pag-chain ng mga constructor batay sa kung paano tawagan ang constructor. Ang mga ito ay ang mga sumusunod.

• gamit ang keyword na ito () - upang tumawag sa mga konstruktor ng parehong klase
• gamit ang super() na keyword – para tumawag sa mga constructor ng parent class

Ito ay ipinaliwanag sa mga sumusunod na halimbawa.

Halimbawa ng constructor chaining #1 – Ang mga constructor ay nakakadena gamit ang() keyword na ito

Nagdeklara kami ng apat na konstruktor para sa DerivedClass. Ang isa ay walang argumento at ang tatlo ay may iba't ibang argumento. Sa loob ng bawat constructor, this() keyword ay ginagamit para tawagan ang susunod na constructor ng parehong klase.

package com.tutorialwriting.constchaining;

public class DerivedClass{

    String firstName;
    String country;
    int age;

    public DerivedClass() {
        // calling one argument constructor
        this("Maggie");
    }

    public DerivedClass(String firstName) {
        // calling two argument constructor
        this(firstName, 15);
    }

    public DerivedClass(String firstName, int age) {
        // calling three argument constructor
        this(firstName, age, "Australia");
    }

    public DerivedClass(String firstName, int age, String country) {
        this.firstName = firstName;
        this.age = age;
        this.country = country;
    }

    void displayValues() {
        System.out.println("First Name : " + firstName);
        System.out.println("Country : " + country);
        System.out.println("Age : " + age);
    }

    public static void main(String args[]) {
        DerivedClass object = new DerivedClass();
        object.displayValues();
    }
}

Ang output ng execution

Halimbawa ng constructor chaining #2 – Ang mga constructor ay nakakadena gamit ang super() na keyword

Dito, tinatawag ng child class ang mga constructor ng parent class gamit ang super() na keyword. Ang BaseClass ay may tatlong constructor. Ang constructor na walang argumento ay tumatawag sa isa sa tatlong-argument-constructor ng BaseClass gamit ito() .

package com.tutorialwriting.constchaining;

public class BaseClass {

    public BaseClass() {
        //calling a three argument constructor of the same class
        this("Male", "English", "1989/11/10");
        System.out.println("I'm executed third!!!");
    }

    public BaseClass(String firstName, String surname, int idNo) {
        System.out.println("I'm executed first!");
        System.out.println("First name : " + firstName);
        System.out.println("Surname : " + surname);
        System.out.println("ID Number : " + idNo);
    }

    public BaseClass(String gender, String nationality, String birthDate) {
        System.out.println("I'm executed second!!");
        System.out.println("Gender : " + gender);
        System.out.println("Nationality : " + nationality);
        System.out.println("Birth Date : " + birthDate);
    }

}

Ang DerivedClass ay may dalawang constructor, ang bawat isa ay tumatawag sa iba't ibang constructor ng super class gamit ang super() .

package com.tutorialwriting.constchaining;

public class DerivedClass extends BaseClass {

    public DerivedClass() {
        //calling no argument constructor of the super class
        super();
    }

    public DerivedClass(String firstName, String surname, int idNo) {
        //calling three argument constructor of the super class
        super(firstName, surname, idNo);
    }

    public static void main(String args[]) {
        DerivedClass object2 = new DerivedClass("Paul", "Wilson", 123456);
        DerivedClass object1 = new DerivedClass();
    }
}

Ang output ng execution

Implicit vs. Explicit constructor calling

Ang Java ay may dalawang magkaibang paraan ng pagtawag sa mga constructor: Implicit calling at Explicit calling.

• Ang tahasang pagtawag ay tumutukoy sa pagtawag sa mga constructor nang tahasan sa code gamit ang this() o super() .
• Ang implicit calling ay tumutukoy sa pagtawag sa no-argument constructor ng super class nang tahasan kapag walang ganoong tahasang tawag mula sa child class constructor. Sa madaling salita, idinaragdag ng compiler ang super() na tawag bilang unang linya ng alinman sa mga constructor ng mga child class kung ang programmer ay tahasang hindi tumatawag ng super() sa code.

Bakit kailangan natin ng constructor chaining?

Mayroong ilang iba't ibang mga layunin ng pagkakaroon ng isang constructor chain sa Java, tulad ng nakalista sa ibaba.

• Ito ay isang paraan upang ma-access ang mga katangian ng iba pang mga konstruktor o mga katangian ng mga klase ng magulang.
• Habang tumatawag sa iba pang mga konstruktor, isang bagay lamang ang ginagamit, na siyang kasalukuyang instance ng klase. Nangyayari ang pagsisimula sa isang lugar, ngunit mayroon kaming pribilehiyong tumawag ng iba't ibang pagpapatupad ng constructor sa pamamagitan ng isang chain. Nakakatulong ito nang malaki sa pamamahala ng memorya at pagpapanatili ng code.

Konklusyon

Sa tutorial na ito, tinalakay namin ang constructor chaining sa Java. Ang mga konstruktor ay mga segment ng code na tulad ng pamamaraan na ginagamit habang gumagawa ng mga bagay. Ang isang klase ng Java ay maaaring magkaroon ng anumang bilang ng mga konstruktor na may iba't ibang mga listahan ng parameter. Ang constructor chaining ay isang madaling paraan ng paghawak ng iba't ibang initialization sa isang instance ng isang klase. Ang ilang mahahalagang punto na dapat tandaan mula sa tutorial na ito ay nakalista sa ibaba.

• Kung ang programmer ay hindi tahasang idagdag ito sa code, ang compiler ay nagdaragdag ng pampublikong walang-argumentong constructor sa Java class. Ito ay tinatawag na default na tagabuo.
• this() at super() ay dapat isulat bilang unang linya ng constructor.
• this() ay ginagamit upang tawagan ang mga constructor ng parehong klase habang ang super() ay ginagamit upang tawagan ang mga constructor ng agarang super class.
• Dapat mayroong kahit isang constructor sa loob ng klase na hindi naglalaman ng this() keyword.
• Kung hindi tahasang idinagdag, ang compiler ay nagdaragdag ng walang argumentong super() na tawag sa bawat bata na tagapagtayo ng klase. Ito ay makakatulong sa instantiation ng mga klase nang tama.