ஜாவாவில் கன்ஸ்ட்ரக்டர் செயின்னிங்

கன்ஸ்ட்ரக்டர் செயினிங் என்றால் என்ன?

ஜாவாவில் ஒரு கட்டமைப்பாளர் என்பது ஒரு வகுப்பின் பொருள் உருவாக்கத்தில் பயன்படுத்தப்படும் ஒரு குறிப்பிட்ட முறையாகும். வகுப்பின் ஒரு பொருள் உருவாக்கப்படும் ஒவ்வொரு முறையும் கட்டமைப்பாளர் அழைக்கப்படுகிறார். உருவாக்கும் நேரத்தில் பொருளின் பண்புகளுக்கு மதிப்புகளை ஒதுக்க இதைப் பயன்படுத்தலாம். வெவ்வேறு அளவுரு பட்டியல்களுடன் ஜாவா வகுப்பில் பல கட்டமைப்பாளர்கள் இருக்கலாம். பொருள் உருவாக்கும் நேரத்தில் ஒரே வகுப்பு/பெற்றோர் வகுப்பின் கட்டமைப்பாளர்களின் வெவ்வேறு செயலாக்கங்களைத் தூண்டுவதற்கு கன்ஸ்ட்ரக்டர் சங்கிலி பயன்படுத்தப்படுகிறது.

ஜாவாவில் கன்ஸ்ட்ரக்டர் சங்கிலி எவ்வாறு செயல்படுத்தப்படுகிறது?

கன்ஸ்ட்ரக்டரை எப்படி அழைப்பது என்பதன் அடிப்படையில் கன்ஸ்ட்ரக்டர்களை சங்கிலியால் இணைக்க இரண்டு வழிகள் உள்ளன. அவை பின்வருமாறு.

• இந்த() முக்கிய சொல்லைப் பயன்படுத்தி - அதே வகுப்பின் கட்டமைப்பாளர்களை அழைக்க
• சூப்பர்() முக்கிய சொல்லைப் பயன்படுத்தி - பெற்றோர் வகுப்பின் கட்டமைப்பாளர்களை அழைக்க

இது பின்வரும் எடுத்துக்காட்டுகளில் விளக்கப்பட்டுள்ளது.

கன்ஸ்ட்ரக்டர் செயினிங் எடுத்துக்காட்டு #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 - சூப்பர்() முக்கிய சொல்லைப் பயன்படுத்தி கன்ஸ்ட்ரக்டர்கள் சங்கிலியால் இணைக்கப்பட்டுள்ளனர்

இங்கே, குழந்தை வகுப்பு பெற்றோர் வகுப்பின் கட்டமைப்பாளர்களை super() முக்கிய சொல்லைப் பயன்படுத்தி அழைக்கிறது. BaseClass மூன்று கட்டமைப்பாளர்களைக் கொண்டுள்ளது. வாதங்கள் இல்லாத கட்டமைப்பாளர் இதைப் பயன்படுத்தி BaseClass இன் மூன்று-வாத-கட்டமைப்பாளர்களில் ஒன்றை அழைக்கிறார் .

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

டெரிவேட் கிளாஸ் இரண்டு கன்ஸ்ட்ரக்டர்களைக் கொண்டுள்ளது, ஒவ்வொன்றும் சூப்பர் வகுப்பின் வெவ்வேறு கட்டமைப்பாளர்களை 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();
    }
}

மரணதண்டனையின் வெளியீடு

மறைமுகமான மற்றும் வெளிப்படையான கட்டமைப்பாளர் அழைப்பு

கட்டமைப்பாளர்களை அழைப்பதற்கு Java இரண்டு வெவ்வேறு வழிகளைக் கொண்டுள்ளது: மறைமுக அழைப்பு மற்றும் வெளிப்படையான அழைப்பு.

• வெளிப்படையான அழைப்பு என்பது இந்த() அல்லது super() ஐப் பயன்படுத்தி குறியீட்டில் உள்ள கட்டமைப்பாளர்களை வெளிப்படையாக அழைப்பதைக் குறிக்கிறது .
• மறைமுக அழைப்பு என்பது, குழந்தை வகுப்புக் கட்டமைப்பாளரிடமிருந்து அத்தகைய வெளிப்படையான அழைப்பு இல்லாத நிலையில், சூப்பர் கிளாஸின் விவாதம் இல்லாத கட்டமைப்பாளரை மறைமுகமாக அழைப்பதைக் குறிக்கிறது. வேறு வார்த்தைகளில் கூறுவதானால், புரோகிராமர் வெளிப்படையாக குறியீட்டில் super() ஐ அழைக்கவில்லை என்றால், கம்பைலர், குழந்தை வகுப்புகளின் எந்தவொரு கட்டமைப்பாளரின் முதல் வரியாக சூப்பர்() அழைப்பைச் சேர்க்கிறது.

நமக்கு ஏன் கட்டமைப்பாளர் சங்கிலி தேவை?

கீழே பட்டியலிடப்பட்டுள்ளபடி, ஜாவாவில் கன்ஸ்ட்ரக்டர் சங்கிலியை வைத்திருப்பதற்கு பல்வேறு நோக்கங்கள் உள்ளன.

• இது பிற கட்டமைப்பாளர்களின் பண்புகள் அல்லது பெற்றோர் வகுப்புகளின் பண்புகளை அணுகுவதற்கான ஒரு வழியாகும்.
• மற்ற கட்டமைப்பாளர்களை அழைக்கும் போது, ​​ஒரே ஒரு பொருள் மட்டுமே பயன்படுத்தப்படுகிறது, இது வகுப்பின் தற்போதைய நிகழ்வாகும். துவக்கம் ஒரே இடத்தில் நடக்கும், ஆனால் ஒரு சங்கிலி மூலம் வெவ்வேறு கன்ஸ்ட்ரக்டர் செயலாக்கங்களை அழைக்கும் பாக்கியம் எங்களுக்கு உள்ளது. இது நினைவக மேலாண்மை மற்றும் குறியீடு பராமரிப்புக்கு பெரிதும் உதவுகிறது.

முடிவுரை

இந்த டுடோரியலில், ஜாவாவில் கன்ஸ்ட்ரக்டர் செயினிங் பற்றி விவாதித்தோம். கன்ஸ்ட்ரக்டர்கள் என்பது பொருள்களை உருவாக்கும் போது பயன்படுத்தப்படும் முறை போன்ற குறியீடு பிரிவுகளாகும். ஒரு ஜாவா வகுப்பில் வெவ்வேறு அளவுரு பட்டியல்களுடன் எத்தனை கன்ஸ்ட்ரக்டர்கள் வேண்டுமானாலும் இருக்கலாம். கன்ஸ்ட்ரக்டர் செயினிங் என்பது ஒரு வகுப்பின் ஒரு நிகழ்வைக் கொண்டு வெவ்வேறு துவக்கங்களைக் கையாளுவதற்கான எளிதான வழியாகும். இந்த டுடோரியலில் இருந்து கவனிக்க வேண்டிய சில முக்கியமான புள்ளிகள் கீழே பட்டியலிடப்பட்டுள்ளன.

• புரோகிராமர் அதைக் குறியீட்டில் வெளிப்படையாகச் சேர்க்கவில்லை என்றால், கம்பைலர், ஜாவா வகுப்பில் பொது வாதங்கள் இல்லாத கட்டமைப்பாளரைச் சேர்க்கிறது. இது இயல்புநிலை கட்டமைப்பாளர் என்று அழைக்கப்படுகிறது.
• இது() மற்றும் super() கன்ஸ்ட்ரக்டரின் முதல் வரியாக எழுதப்பட வேண்டும்.
• இது() அதே வகுப்பின் கட்டமைப்பாளர்களை அழைக்கப் பயன்படுகிறது, சூப்பர்() என்பது உடனடி சூப்பர் வகுப்பின் கட்டமைப்பாளர்களை அழைக்கப் பயன்படுகிறது.
• இந்த() முக்கிய சொல்லைக் கொண்டிருக்காத வகுப்பிற்குள் குறைந்தபட்சம் ஒரு கட்டமைப்பாளர் இருக்க வேண்டும் .
• வெளிப்படையாகச் சேர்க்கப்படாவிட்டால், கம்பைலர் ஒவ்வொரு குழந்தை வகுப்புக் கட்டமைப்பாளரிடமும் விவாதம் இல்லாத சூப்பர்() அழைப்பைச் சேர்க்கிறது. இது வகுப்புகளை சரியாக நிறுவ உதவும்.