జావాలో కన్స్ట్రక్టర్ చైనింగ్

కన్స్ట్రక్టర్ చైనింగ్ అంటే ఏమిటి?

జావాలోని కన్స్ట్రక్టర్ అనేది క్లాస్ యొక్క ఆబ్జెక్ట్ క్రియేషన్‌లో ఉపయోగించే ఒక నిర్దిష్ట పద్ధతి. క్లాస్ యొక్క వస్తువు సృష్టించబడిన ప్రతిసారీ కన్స్ట్రక్టర్ ప్రారంభించబడుతుంది. సృష్టి సమయంలో వస్తువు యొక్క లక్షణాలకు విలువలను కేటాయించడానికి దీనిని ఉపయోగించవచ్చు. విభిన్న పారామీటర్ జాబితాలతో జావా క్లాస్‌లో బహుళ కన్స్ట్రక్టర్‌లు ఉండవచ్చు. ఆబ్జెక్ట్ క్రియేషన్ సమయంలో ఒకే క్లాస్/పేరెంట్ క్లాస్ యొక్క కన్స్ట్రక్టర్‌ల యొక్క విభిన్న అమలులను అమలు చేయడానికి కన్స్ట్రక్టర్ చైనింగ్ ఉపయోగించబడుతుంది.

జావాలో కన్స్ట్రక్టర్ చైనింగ్ ఎలా అమలు చేయబడుతుంది?

కన్స్ట్రక్టర్‌ను ఎలా పిలవాలి అనే దాని ఆధారంగా కన్స్ట్రక్టర్‌లను చైనింగ్ చేయడానికి రెండు మార్గాలు ఉన్నాయి. అవి ఈ క్రింది విధంగా ఉన్నాయి.

• ఈ() కీవర్డ్‌ని ఉపయోగించడం - అదే తరగతికి చెందిన కన్‌స్ట్రక్టర్‌లను కాల్ చేయడానికి
• సూపర్() కీవర్డ్‌ని ఉపయోగించడం - పేరెంట్ క్లాస్ యొక్క కన్‌స్ట్రక్టర్‌లను కాల్ చేయడానికి

ఇది క్రింది ఉదాహరణలలో వివరించబడింది.

కన్స్ట్రక్టర్ చైనింగ్ ఉదాహరణ #1 - ఈ() కీవర్డ్‌ని ఉపయోగించి కన్‌స్ట్రక్టర్‌లు చైన్ చేయబడతారు

డెరైవ్డ్ క్లాస్ కోసం మేము నలుగురు కన్స్ట్రక్టర్‌లను ప్రకటించాము. ఒకటి వాదనలు లేనివి, మరో మూడు భిన్నమైన వాదనలతో. ప్రతి కన్స్ట్రక్టర్ లోపల, అదే తరగతికి చెందిన తదుపరి కన్స్ట్రక్టర్‌ని కాల్ చేయడానికి ఈ() కీవర్డ్ ఉపయోగించబడుతుంది.

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

అమలు యొక్క అవుట్పుట్

కన్స్ట్రక్టర్ చైనింగ్ ఉదాహరణ #2 – సూపర్() కీవర్డ్‌ని ఉపయోగించి కన్‌స్ట్రక్టర్‌లు చైన్ చేయబడతారు

ఇక్కడ, చైల్డ్ క్లాస్ సూపర్() కీవర్డ్‌ని ఉపయోగించి పేరెంట్ క్లాస్ యొక్క కన్స్ట్రక్టర్‌లను పిలుస్తుంది . బేస్‌క్లాస్‌లో ముగ్గురు కన్స్ట్రక్టర్‌లు ఉన్నారు. ఆర్గ్యుమెంట్‌లు లేని కన్‌స్ట్రక్టర్ బేస్‌క్లాస్ యొక్క మూడు-ఆర్గ్యుమెంట్-కన్‌స్ట్రక్టర్‌లో ఒకదానిని దీన్ని() ఉపయోగించి పిలుస్తాడు .

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

డెరైవ్డ్‌క్లాస్‌లో ఇద్దరు కన్‌స్ట్రక్టర్‌లు ఉన్నాయి, ప్రతి ఒక్కటి సూపర్ క్లాస్‌లోని విభిన్న కన్‌స్ట్రక్టర్‌లను సూపర్()ని ఉపయోగించి పిలుస్తుంది .

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

అమలు యొక్క అవుట్పుట్

ఇంప్లిసిట్ వర్సెస్ స్పష్టమైన కన్స్ట్రక్టర్ కాలింగ్

జావా కన్‌స్ట్రక్టర్‌లను కాల్ చేయడానికి రెండు విభిన్న మార్గాలను కలిగి ఉంది: పరోక్ష కాలింగ్ మరియు స్పష్టమైన కాలింగ్.

• స్పష్టమైన కాలింగ్ అనేది ఈ() లేదా సూపర్()ని ఉపయోగించి కోడ్‌లో కన్‌స్ట్రక్టర్‌లను స్పష్టంగా కాల్ చేయడాన్ని సూచిస్తుంది .
• చైల్డ్ క్లాస్ కన్‌స్ట్రక్టర్ నుండి అటువంటి స్పష్టమైన కాల్ లేనప్పుడు సూపర్ క్లాస్ యొక్క నో ఆర్గ్యుమెంట్ కన్‌స్ట్రక్టర్‌ని పరోక్షంగా కాల్ చేయడాన్ని ఇంప్లిసిట్ కాలింగ్ సూచిస్తుంది. మరో మాటలో చెప్పాలంటే, ప్రోగ్రామర్ కోడ్‌లో సూపర్()ని స్పష్టంగా కాల్ చేయకపోతే, కంపైలర్ చైల్డ్ క్లాస్‌ల కన్స్ట్రక్టర్‌లలో ఏదైనా మొదటి లైన్‌గా సూపర్() కాల్‌ని జోడిస్తుంది.

మనకు కన్స్ట్రక్టర్ చైనింగ్ ఎందుకు అవసరం?

జావాలో కన్స్ట్రక్టర్ గొలుసును కలిగి ఉండటం వలన అనేక విభిన్న ప్రయోజనాలున్నాయి, క్రింద జాబితా చేయబడింది.

• ఇది ఇతర కన్స్ట్రక్టర్‌ల లక్షణాలను లేదా మాతృ తరగతుల లక్షణాలను యాక్సెస్ చేయడానికి ఒక మార్గం.
• ఇతర కన్స్ట్రక్టర్‌లను పిలుస్తున్నప్పుడు, ఒక వస్తువు మాత్రమే ఉపయోగించబడుతోంది, ఇది తరగతి యొక్క ప్రస్తుత ఉదాహరణ. ప్రారంభించడం ఒకే చోట జరుగుతుంది, కానీ గొలుసు ద్వారా విభిన్న కన్స్ట్రక్టర్ ఇంప్లిమెంటేషన్‌లను పిలిచే ప్రత్యేక హక్కు మాకు ఉంది. ఇది మెమరీ నిర్వహణ మరియు కోడ్ నిర్వహణలో బాగా సహాయపడుతుంది.

ముగింపు

ఈ ట్యుటోరియల్‌లో, మేము జావాలో కన్స్ట్రక్టర్ చైనింగ్ గురించి చర్చించాము. కన్‌స్ట్రక్టర్‌లు అనేవి ఆబ్జెక్ట్‌లను సృష్టించేటప్పుడు ఉపయోగించబడే పద్ధతి-వంటి కోడ్ విభాగాలు. జావా క్లాస్ వివిధ పారామితి జాబితాలతో ఎన్ని కన్స్ట్రక్టర్లను కలిగి ఉండవచ్చు. కన్స్ట్రక్టర్ చైనింగ్ అనేది క్లాస్ యొక్క ఒక ఉదాహరణతో విభిన్న ప్రారంభాలను నిర్వహించడానికి సులభమైన మార్గం. ఈ ట్యుటోరియల్ నుండి గమనించవలసిన కొన్ని ముఖ్యమైన అంశాలు క్రింద ఇవ్వబడ్డాయి.

• ప్రోగ్రామర్ దానిని కోడ్‌కు స్పష్టంగా జోడించకపోతే, కంపైలర్ జావా క్లాస్‌కు పబ్లిక్ నో ఆర్గ్యుమెంట్ కన్‌స్ట్రక్టర్‌ను జోడిస్తుంది. దీనిని డిఫాల్ట్ కన్స్ట్రక్టర్ అంటారు.
• this() మరియు super()ని కన్స్ట్రక్టర్ యొక్క మొదటి పంక్తిగా వ్రాయాలి.
• ఇదే తరగతికి చెందిన కన్‌స్ట్రక్టర్‌లను కాల్ చేయడానికి ఇది() ఉపయోగించబడుతుంది, అయితే సూపర్() అనేది తక్షణ సూపర్ క్లాస్ యొక్క కన్‌స్ట్రక్టర్‌లను కాల్ చేయడానికి ఉపయోగించబడుతుంది.
• ఈ() కీవర్డ్ లేని క్లాస్‌లో కనీసం ఒక కన్స్ట్రక్టర్ అయినా ఉండాలి .
• స్పష్టంగా జోడించబడకపోతే, కంపైలర్ ప్రతి చైల్డ్ క్లాస్ కన్‌స్ట్రక్టర్‌కు నో ఆర్గ్యుమెంట్ సూపర్() కాల్‌ని జోడిస్తుంది. ఇది తరగతులను సరిగ్గా ఉంచడానికి సహాయపడుతుంది.