వేరియబుల్ స్కోప్ గురించి మరింత

"ప్రొఫెసర్ తన గుట్టు నుండి బయటపడలేడు, ఉపన్యాసాలు చెప్పే పాత ఉపాధ్యాయులు ఎప్పుడూ ఇలాగే ఉంటారు, మీకు పుస్తకాలలో దొరకని విషయం అతను మీకు చెప్పలేడు. మీరు విని ఈత నేర్చుకోరు . ఈత ఉపన్యాసాలకు ఉపన్యాసాలు మీకు సబ్జెక్ట్ గురించి బాగా తెలిసినప్పుడు మరియు మీ ప్రొఫెసర్‌కు దాదాపుగా తెలిసినప్పుడు మాత్రమే ఉపయోగపడతాయి."

"అప్పటికీ, అతని పాఠాలు ఉపయోగకరంగా ఉన్నాయి."

అవును వ్యాపారానికి తిరిగి వెళ్ళు."

"నేను ఇంతకు ముందు మీకు చూపించిన చిత్రాన్ని చూద్దాం."

┏
┃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> డాట్ <పద్ధతి పేరు> ఉపయోగించి ఒక పద్ధతిని కాల్ చేసినప్పుడు , మీరు వాస్తవానికి తరగతి పద్ధతిని కాల్ చేస్తున్నారు మరియు అదే ఆబ్జెక్ట్‌ను మొదటి ఆర్గ్యుమెంట్‌గా పాస్ చేస్తున్నారు. పద్ధతి లోపల, ఆబ్జెక్ట్‌ని 'ఇది' అంటారు . అన్ని కార్యకలాపాలు పద్ధతి ఈ వస్తువు మరియు దాని డేటాపై నిర్వహించబడుతుంది."

"వావ్! ఐతే ఇదంతా ఎలా పనిచేస్తుంది!"

"మరియు స్టాటిక్ పద్ధతి ఇలా పనిచేస్తుంది."

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

"మీరు స్టాటిక్ మెథడ్‌ని పిలిచినప్పుడు, దానికి ఏ వస్తువు కూడా పంపబడదు. మరో మాటలో చెప్పాలంటే, 'ఇది' శూన్యానికి సమానం . అందుకే స్టాటిక్ మెథడ్ నాన్-స్టాటిక్ వేరియబుల్స్ మరియు మెథడ్స్‌ను యాక్సెస్ చేయదు (దీనికి పాస్ చేయడానికి 'ఇది' లేదు కాబట్టి. ఈ పద్ధతులకు)."

"హ్మ్మ్. నాకు అర్థమైంది. కనీసం కొంచెం అయినా."

"మరియు ఇక్కడ అంకుల్ డియెగో వచ్చాడు ... మరియు అతని పనులు."