நிலையான மாறிகள் மற்றும் முறைகள்

"ஒரு புதிய தலைப்புக்கு செல்லலாம். இப்போது, ​​நான் நிலையான மாறிகள் மற்றும் முறைகளைப் பற்றி விவாதிக்க விரும்புகிறேன்."

"எல்லி, நான் ஏற்கனவே நிலையான மாறிகள் மற்றும் முறைகள் பற்றி கற்றுக்கொண்டேன். ஆனால் நான் மேலும் விவரங்களை அறிய விரும்புகிறேன்."

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

class Cat                        // Class
{
    String name;                 // Variable

    Cat(String name)             // Constructor
    {
        this.name = name;        // Variable initialization
    }
}

Cat cat1 = new Cat("Oscar"); // Create one object whose name variable contains "Oscar"
Cat cat2 = new Cat("Missy"); // Create one object whose name variable contains "Missy"
System.out.println(cat1.name);
System.out.println(cat2.name);

Oscar
Missy

"ஒரே வகுப்பில் (பூனை) அறிவிக்கப்பட்டிருந்தாலும், மாறிகள் cat1.nameமற்றும் cat2.nameவெவ்வேறு மதிப்புகளைக் கொண்டிருக்கின்றன, ஏனெனில் அவை வெவ்வேறு பொருள்களைக் குறிப்பிடுகின்றன."
"அறிவுபூர்வமாக உள்ளது."
"இருப்பினும், ஒரு வர்க்கத்தின் ஒவ்வொரு நிகழ்விற்கும் நிலையான மாறியின் ஒரே ஒரு நகல் மட்டுமே உள்ளது, மேலும் அது வர்க்கப் பெயரைப் பயன்படுத்தி அணுகப்பட வேண்டும்."

class Cat                   // Сlass
{
    String name;            // Instance (non-static) variable
    static int catCount;    // Static variable

    Cat(String name)
    {
        this.name = name;
        Cat.catCount++;   // Increment the static variable by 1
    }
}

System.out.println(Cat.catCount);
Cat cat1 = new Cat("Oscar");

System.out.println(Cat.catCount);
Cat cat2 = new Cat("Missy");

System.out.println(cat1.name);
System.out.println(cat2.name);
System.out.println(Cat.catCount);

0
1
Oscar
Missy
2

"சரி, அதுவும் அர்த்தமுள்ளதாக இருக்கிறது."

"ஜாவா முறைகள் இரண்டு வகைகளாகப் பிரிக்கப்பட்டுள்ளன. ஒரு பொருளின் மீது நிகழ்வு முறைகள் அழைக்கப்படுகின்றன மற்றும் அந்த பொருளின் தரவை அணுகலாம். நிலையான முறைகளுக்கு அந்த அணுகல் இல்லை, ஏனெனில் அவை வெறுமனே ஒரு பொருள் குறிப்பு இல்லை. இருப்பினும், அவை குறிப்பிடலாம் வகுப்பின் நிலையான மாறிகள் மற்றும் பிற நிலையான முறைகள்.

நிலையான முறைகள் நிலையான முறைகள் அல்லது நிலையான அல்லாத மாறிகள் ஆகியவற்றைக் கையாள முடியாது!"

"அது ஏன் எல்லி?"

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

"உதாரண முறைகளுக்கு அத்தகைய குறிப்பு உள்ளதா?"

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

பொருள் குறிப்புக்குப் பதிலாக, பூஜ்யமானது நிலையான முறைகளுக்கு அனுப்பப்படுகிறது. அதனால்தான் நிலையான அல்லாத மாறிகள் மற்றும் முறைகளை அவர்களால் தீர்க்க முடியாது. இந்த மாறிகள் மற்றும் முறைகளுடன் தொடர்புடைய ஒரு பொருளைப் பற்றிய குறிப்பு அவர்களிடம் இல்லை."

"சரி, எல்லி, எனக்கு அது புரிகிறது."

"நிலையற்ற முறைகள் இப்படித்தான் செயல்படுகின்றன:

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

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

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

"ஒரு மாறி அல்லது முறையானது அதற்கு முன்னால் நிலையான முக்கிய சொல் இருந்தால் நிலையானது."

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

"சரி, அத்தகைய முறைகள் அவற்றின் நன்மைகளைக் கொண்டுள்ளன."

"முதலில், நிலையான முறைகள் மற்றும் மாறிகளைப் பயன்படுத்துவதற்கு நாம் பொருள் குறிப்பை அனுப்ப வேண்டியதில்லை. "

"இரண்டாவது, சில நேரங்களில் ஒரு மாறியின் ஒரே ஒரு பிரதியை வைத்திருப்பது அவசியமாகும். எடுத்துக்காட்டாக, System.out (கணினி வகுப்பின் நிலையான அவுட் மாறி)."

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

"எல்லி, இதற்கு ஒரு உதாரணம் சொல்ல முடியுமா?"

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