மாறி நோக்கம் பற்றி மேலும்

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

"இன்னும், அவரது பாடங்கள் பயனுள்ளதாக இருக்கும்."

ஆம் வணிகத்திற்குத் திரும்பு."

"நான் முன்பு உங்களுக்குக் காட்டிய ஒரு படத்தைப் பார்ப்போம்."

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. ஒரு முறையில் அறிவிக்கப்பட்ட ஒரு மாறி அதன் அறிவிப்பின் தொடக்கத்திலிருந்து முறையின் முடிவு வரை உள்ளது (தெரியும்).

2. குறியீடு தொகுதியில் அறிவிக்கப்பட்ட ஒரு மாறி குறியீடு தொகுதி முடியும் வரை இருக்கும்.

3. முறை திரும்பும் வரை முறையின் அளவுருக்கள் இருக்கும்.

4. ஒரு பொருளில் உள்ள மாறிகள் அவற்றைக் கொண்டிருக்கும் பொருளின் வாழ்நாள் முழுவதும் இருக்கும். அவற்றின் தெரிவுநிலையும் சிறப்பு அணுகல் மாற்றிகளால் நிர்வகிக்கப்படுகிறது.

5. நிரல் இயங்கும் முழு நேரத்திலும் நிலையான (வகுப்பு) மாறிகள் இருக்கும். அவற்றின் தெரிவுநிலையும் அணுகல் மாற்றிகளால் வரையறுக்கப்படுகிறது."

"சரி. இந்தப் படம் எனக்கு நினைவிருக்கிறது."

"அருமை. சில முக்கிய விஷயங்களைப் பற்றி உங்களுக்கு நினைவூட்டுகிறேன்."

"முறைகளுக்குள் அறிவிக்கப்பட்ட அனைத்து மாறிகளும் உள்ளன (தெரிகின்றன) அவை அறிவிக்கப்பட்ட இடத்திலிருந்து முறையின் இறுதி வரை (எடுத்துக்காட்டு 1)."

"குறியீடு தொகுதியில் மாறி அறிவிக்கப்பட்டால், அது குறியீடு தொகுதியின் இறுதி வரை இருக்கும் (எடுத்துக்காட்டு 2)."

"ஒரு மாறி ஒரு முறை அளவுருவாக இருந்தால், அது முறையின் முழு உடலிலும் உள்ளது (எடுத்துக்காட்டு 3)."

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

"ஒரு மாறி நிலையானதாக அறிவிக்கப்பட்டால், அதாவது ஸ்டேடிக் என்ற முக்கிய வார்த்தையால் குறிக்கப்பட்டால் , அதன் வர்க்கம் இருக்கும் வரை அது இருக்கும். JVM வழக்கமாக ஒரு வகுப்பை அதன் முதல் பயன்பாட்டில் நினைவகத்தில் ஏற்றுகிறது. அப்போதுதான் நிலையான மாறிகள் துவக்கப்படும்."

"மேலே உள்ள உதாரணம் கேட் வகுப்பை அறிவிக்கிறது, இதில் நான்கு மாறிகள் உள்ளன: a, b, s (நிலையற்ற மாறிகள்), மற்றும் எண்ணிக்கை (ஒரு நிலையான மாறி). இந்த வகுப்பின் பல பொருட்களை நாம் உருவாக்கினால் (மூன்று என்று சொல்லுங்கள்), ஒவ்வொன்றும் அவை வகுப்பின் நிலையான அல்லாத மாறிகளின் சொந்த நிகழ்வுகளைக் கொண்டிருக்கும். ஒரு நிலையான மாறியானது ஒரு வகுப்பின் அனைத்துப் பொருட்களாலும் பகிரப்படுகிறது. தொழில்நுட்ப ரீதியாகப் பார்த்தால், எந்தவொரு பூனைப் பொருள்கள் உருவாக்கப்படுவதற்கு முன்பே அது இந்த பொருட்களுக்குள் கூட இல்லை."

"மாறி நிலையானதாக அறிவித்தால் என்ன நடக்கும் என்பது இங்கே s:"

"சரி. எனக்கு புரிந்திருக்கும் என்று நினைக்கிறேன்."

"அதே பெயரில் மாறிகளை அறிவிக்க முடியுமா?"

"ஒரு முறைக்குள் இல்லை. ஒரு முறைக்குள் அறிவிக்கப்படும் அனைத்து மாறிகளும் தனிப்பட்ட பெயர்களைக் கொண்டிருக்க வேண்டும். ஒரு முறையின் வாதங்களும் உள்ளூர் மாறிகளாகக் கருதப்படுகின்றன."

"உறுப்பினர் மாறிகள் பற்றி என்ன?"

"உறுப்பினர் மாறிகள் ஒவ்வொரு வகுப்பிற்கும் தனிப்பட்டதாக இருக்க வேண்டும்."

"ஆனால் ஒரு விதிவிலக்கு உள்ளது: உள்ளூர் மாறிகள் மற்றும் உறுப்பினர் மாறிகளின் பெயர்கள் ஒரே மாதிரியாக இருக்கலாம். "

"நாம் அத்தகைய மாறியை மாற்றினால், ஒரே மாதிரியாக பெயரிடப்பட்ட இரண்டு மாறிகளில் எது மாற்றப்படும்?"

"எங்கள் குறியீட்டில் பல புலப்படும் (அணுகக்கூடிய) மாறிகள் இருந்தால் - ஒரு நிகழ்வு மாறி மற்றும் ஒரு உள்ளூர் மாறி - உள்ளூர் மாறி அணுகப்படும்."

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

"இந்த குறியீடு இரண்டு எண்ணிக்கை மாறிகளை அறிவிக்கிறது. வரி 3 ஒரு நிகழ்வு மாறியை அறிவிக்கிறது , மற்றும் வரி 8 - ஒரு உள்ளூர் மாறி ."

"ரன் முறை செயல்படுத்தப்படும்போது என்ன நடக்கும் என்பது இங்கே:"

"வரி 7 இல், நிகழ்வு மாறியை அணுகி அதற்கு மதிப்பு 15 ஐ ஒதுக்குகிறோம்"

"வரி 8 இல், நாங்கள் ஒரு புதிய உள்ளூர் மாறியை அறிவிக்கிறோம் (உருவாக்குகிறோம்) : count. இது நிகழ்வு மாறியை மறைக்கிறது. லோக்கல் மாறி என்பது முறையின் அனைத்து அடுத்தடுத்த குறியீடுகளும் (அணுகல்) பார்க்கும்."

"அறிந்துகொண்டேன்."

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

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

"நிலையான முறைகள் மற்றும் நிலையான மாறிகள் பற்றி நீங்கள் வேறு என்ன சொல்ல முடியும்?"

"நிலையான முறைகள் மற்றும் மாறிகள் வகுப்பின் பொருள்களுடன் இணைக்கப்படவில்லை; அவை வகுப்பிலேயே இணைக்கப்பட்டுள்ளன. நாம் பத்து மாறிகள் பொருள்களை உருவாக்கினால் (இந்த நிலையின் தொடக்கத்தில் உள்ள எடுத்துக்காட்டைப் பார்க்கவும்), பத்து நிகழ்வு மாறிகள் (ஒவ்வொன்றிற்கும் ஒன்று) இருக்கும். பொருள்) மற்றும் ஒரே ஒரு பகிரப்பட்ட (நிலையான) மாறி TEXT ."

"எனக்கு ஒரு கேள்வி."

"நிலையான மற்றும் நிலையான முறைகளுக்கு என்ன வித்தியாசம்?"

"நிலையற்ற முறை எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்:"

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

"நீங்கள் <object> dot <method name> ஐப் பயன்படுத்தி ஒரு முறையை அழைக்கும் போது , ​​நீங்கள் உண்மையில் ஒரு வகுப்பு முறையை அழைக்கிறீர்கள் மற்றும் அதே பொருளை முதல் வாதமாக அனுப்புகிறீர்கள். அந்த முறையின் உள்ளே, பொருள் 'இது' என்று அழைக்கப்படுகிறது . அனைத்து செயல்பாடுகளும் இந்த பொருள் மற்றும் அதன் தரவுகளில் முறை செய்யப்படுகிறது."

"ஆஹா! அப்படித்தான் எல்லாம் வேலை செய்கிறது!"

"ஒரு நிலையான முறை இப்படித்தான் செயல்படுகிறது."

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

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

"ம்ம்ம். எனக்கு புரிந்திருக்கும் என்று நினைக்கிறேன். கொஞ்சமாவது."

"இதோ வந்துவிட்டது மாமா டியாகோ... மற்றும் அவரது பணிகள்."