இந்த முக்கிய வார்த்தை ஜாவா

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

1. ஒரு நிகழ்வு மாறி மற்றும் முறை/கட்டமைப்பாளர் மாறி ஒரே பெயரைக் கொண்டிருக்கும் போது;
2. நீங்கள் ஒரு குறிப்பிட்ட வகை கட்டமைப்பாளரை (உதாரணமாக, ஒரு இயல்புநிலை கட்டமைப்பாளர் அல்லது அளவுருவாக்கப்பட்ட கட்டமைப்பாளர்) மற்றொரு வகை கட்டமைப்பாளரிடமிருந்து அழைக்க வேண்டும். இது வெளிப்படையான கட்டமைப்பாளர் அழைப்பு என்றும் அழைக்கப்படுகிறது.

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

எடுத்துக்காட்டு 1: ஒரு நிகழ்வு மாறி மற்றும் முறை மாறி ஒரே பெயரைக் கொண்டுள்ளன.

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

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

String newName ஐ setName செட்டர் முறைக்கு அனுப்புகிறோம் என்பதை நினைவில் கொள்ளவும், நாங்கள் ஒரு புதிய மாறியை அறிவித்தோம், அதற்கு நாம் விரும்பும் பெயரைப் பெற்றிருக்கலாம், ஏனெனில் இது setName முறையை இணைக்கும் சுருள் பிரேஸ்களுக்குள் ({}) மட்டுமே தெரியும். செட்டரில் ஒரு வரி உள்ளது என்பதை நினைவில் கொள்க:

name = newName;

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

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

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

name = name;

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

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        human1.print();
    }
}
class Human {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    void print() {
        System.out.println(name);
    }
}

எனவே, ஒரே விஷயத்தைக் குறிக்க புதிய மாறிகளை அறிமுகப்படுத்துவதைத் தவிர்க்க இது உதவுகிறது, குறியீட்டை சுத்தமாகவும், கூடுதல் மாறிகள் குறைவாகவும் இரைச்சலாக மாற்றுகிறது.

எடுத்துக்காட்டு 2: வெளிப்படையான கட்டமைப்பாளர் அழைப்பிற்கு இதைப் பயன்படுத்துதல்

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

class Human {
    int age;
    int weight;
    int height;

    Human(int age, int weight) {
        this.age = age;
        this.weight = weight;
    }
    Human(int age, int weight, int height) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

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

this.age = age;
this.weight = weight;

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

this.age = age;
this.weight = weight;
this.height = height;

ஆனால் இந்த கன்ஸ்ட்ரக்டரில் ஏற்கனவே உள்ள குறியீட்டை மீண்டும் கூறுவதற்கு பதிலாக, இரண்டு அளவுருக்கள் கொண்ட கன்ஸ்ட்ரக்டரை வெளிப்படையாக அழைக்க இந்த முக்கிய சொல்லைப் பயன்படுத்தலாம் :

this(age, weight);
// and then initialize the missing variable:
this.height = height;

நாங்கள் மூன்று அளவுரு கட்டமைப்பாளரிடம் சொல்வது போல் உள்ளது:

• இரண்டு அளவுருக்கள் கொண்ட இந்த மற்ற கட்டமைப்பாளரை அழைக்கவும்
• பின்னர் மற்றொரு மாறியைச் சேர்க்கவும்.

அவ்வளவுதான் =). இறுதியாக, ஜாவாவில் இந்த முக்கிய சொல் முறைகள் மற்றும் கட்டமைப்பாளர்களில் மட்டுமே பயன்படுத்தப்படுகிறது என்பதை நாங்கள் கவனிக்கிறோம். ஆனால் இது அனைத்து நிலையான அல்லாத முறைகளுக்கும் மறைமுகமாக அனுப்பப்படுகிறது (அதனால்தான் இது பெரும்பாலும் மறைமுகமான அளவுரு என்று அழைக்கப்படுகிறது) மேலும் முறை என்று அழைக்கப்படும் பொருளைக் குறிக்கப் பயன்படுத்தலாம். இந்த முக்கிய வார்த்தைக்கு பயப்பட வேண்டாம், ஏனென்றால் இது பயமாக இல்லை.