వేరియబుల్ దృశ్యమానత

స్థానిక వేరియబుల్స్

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

"పద్ధతులలో డిక్లేర్ చేయబడిన అన్ని వేరియబుల్స్ లోకల్ వేరియబుల్స్ అంటారు . లోకల్ వేరియబుల్ అది డిక్లేర్డ్ చేయబడిన కోడ్ బ్లాక్‌లో మాత్రమే ఉంటుంది. లేదా, మరింత ఖచ్చితంగా చెప్పాలంటే, అది డిక్లేర్ చేయబడిన క్షణం నుండి బ్లాక్ ముగిసే వరకు ఉంటుంది. ఇది ప్రకటించబడిన కోడ్."

"స్పష్టంగా, నాకు ఒక ఉదాహరణ కావాలి."

"సమస్య లేదు. ఇదిగోండి:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

a
a
a
a, b
a, b
a, b
a, b, x
a, b, x
a, b
a, b
a
a

"ఇంకోసారి లోకల్ వేరియబుల్స్‌ని యాక్సెస్ చేయడానికి నియమాలను పరిశీలిద్దాం. ఇక్కడ కోడ్ బ్లాక్ ఉంది. దాని ప్రారంభం మరియు ముగింపు ఏది?"

"వంకర కలుపులు?"

"సరైనది. ఇది మెథడ్ బాడీ కావచ్చు, లూప్ యొక్క బాడీ కావచ్చు లేదా షరతులతో కూడిన స్టేట్‌మెంట్ కోసం కోడ్ యొక్క బ్లాక్ కావచ్చు. కోడ్ బ్లాక్‌లో డిక్లేర్ చేయబడిన వేరియబుల్ ఆ కోడ్ బ్లాక్ ముగిసే వరకు ఉంటుంది. నాకు చెప్పండి, ఎక్కడ ఉంటుంది లూప్ బాడీలో డిక్లేర్ చేయబడితే వేరియబుల్ ఉందా?"

"ఇది లూప్ శరీరంలో మాత్రమే ఉంటుంది."

"అది నిజం. ఇంకా ఏమిటంటే, లూప్ యొక్క ప్రతి పునరావృతం వద్ద ఇది సృష్టించబడుతుంది మరియు నాశనం చేయబడుతుంది."

"అంటే మీరు ఒకే పేరుతో రెండు స్థానిక వేరియబుల్‌లను ఒక పద్ధతిలో ప్రకటించలేరు - ప్రోగ్రామ్ కంపైల్ చేయదు. అయితే వేరియబుల్స్ డిక్లేర్డ్ చేయబడిన కోడ్ బ్లాక్‌లు అతివ్యాప్తి చెందకపోతే మీరు దీన్ని చేయవచ్చు. "

"నువ్వు నాకు ఇష్టమైనవి కావడానికి ఒక కారణం ఉంది, అమిగో. దీన్ని మీ మెదడులో పదిలపరచుకోవడానికి మరో ఉదాహరణ తీసుకోండి.

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     System.out.println(b);
   }

   if (a < 20)
   {
     int b = 20;
     System.out.println(b);
   }
}

a
a
a
a, b
a, b
a
a
a
a
a, b
a, b
a

b"రెండవ వేరియబుల్ డిక్లేర్ చేయబడిన కోడ్ బ్లాక్‌లో మొదటి bవేరియబుల్ కనిపించనందున మాత్రమే మేము రెండవ లోకల్ వేరియబుల్ పేరును ప్రకటించగలిగాము b.

పారామితులు

"మేము ముందే చెప్పినట్లు, ప్రతి పద్ధతికి మనం పారామీటర్లు అని పిలుస్తున్న వేరియబుల్స్ ఉండవచ్చు. వాటి దృశ్యమానత మరియు జీవితకాలం గురించి ఏమిటి?"

"హ్మ్మ్.. నేను మొద్దుబారిపోయాను..."

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

"మరో మాటలో చెప్పాలంటే, అవి మొత్తం శరీరంలో కనిపిస్తాయి మరియు అక్కడ మాత్రమే?"

"అవును. ఉదాహరణ:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

args
args, a
args, a
args, a
args, a, b
args, a, b
args, a, b
args, a, b, x
args, a, b, x
args, a, b
args, a, b
args, a
args, a

"మేము ఇంతకు ముందు చెప్పినట్లుగా, argsఇది కేవలం ఒక వేరియబుల్, దీని రకం స్ట్రింగ్‌ల శ్రేణి. మరియు అన్ని పారామీటర్‌ల మాదిరిగానే, ఇది పద్ధతి యొక్క శరీరంలో ప్రతిచోటా అందుబాటులో ఉంటుంది. అంటే, మేము సాధారణంగా మా ఉదాహరణలలో దీనిని విస్మరిస్తాము.

తరగతిలోని వేరియబుల్స్

"స్థాయి 1లోని పాఠాలను గుర్తుంచుకోండి, ఇక్కడ ఒక తరగతికి పద్ధతులు మరియు వేరియబుల్స్ ఉండవచ్చని మేము చెప్పాము. మెథడ్‌లను కొన్నిసార్లు ఇన్‌స్టాన్స్ మెథడ్స్ అని పిలుస్తారు మరియు వేరియబుల్స్ — ఇన్‌స్టాన్స్ వేరియబుల్స్ లేదా ఫీల్డ్‌లు.

" తరగతి యొక్క వేరియబుల్స్ (లేదా ఫీల్డ్‌లు) ఏమిటి ?

అవి ఒక పద్ధతిలో కాకుండా ఒక తరగతిలో ప్రకటించబడిన వేరియబుల్స్."

"మరి వారు అక్కడ దేనికి?"

"ప్రారంభం కోసం, వాటిని క్లాస్ యొక్క ఏదైనా (స్టాటిక్ కాని) పద్ధతి నుండి యాక్సెస్ చేయవచ్చు. స్థూలంగా చెప్పాలంటే, ఇన్‌స్టాన్స్ వేరియబుల్స్ అనేది క్లాస్ యొక్క అన్ని పద్ధతుల ద్వారా భాగస్వామ్యం చేయబడిన వేరియబుల్స్.

ఉదాహరణ:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     sum = sum + data;
     count++;
   }

   public void remove(int data)
   {
     sum = sum - data;
     count--;
   }
}

count
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum
count, sum

"ఈ ఉదాహరణలో, మనకు రెండు పద్ధతులు ఉన్నాయి - add()మరియు remove(). పద్ధతి మరియు ఇన్‌స్టాన్స్ వేరియబుల్‌లను add()పెంచుతుంది , మరియు పద్ధతి మరియు వేరియబుల్‌లను తగ్గిస్తుంది . రెండు పద్ధతులు భాగస్వామ్య ఉదాహరణ వేరియబుల్స్‌పై పని చేస్తాయి."sumcountremove()sumcount

"నేను అన్నింటినీ అర్థం చేసుకున్నాను! ఒక పద్ధతిని అమలు చేస్తున్నప్పుడు స్థానిక వేరియబుల్స్ ఉనికిలో ఉంటాయి. తరగతి యొక్క ఇన్‌స్టాన్స్ వేరియబుల్స్ ఆ వస్తువు ఉన్నంత వరకు తరగతి యొక్క వస్తువులో ఉంటాయి."

"బాగా చేసారు, అమిగో. మేము కొంత పునాదిని ఏర్పాటు చేసాము మరియు మీరు తదుపరి దశలో తరగతికి చెందిన వస్తువుల గురించి వివరాలను తెలుసుకుంటారు.

స్టాటిక్ వేరియబుల్స్

"పద్ధతుల వలె, తరగతిలోని వేరియబుల్స్ స్టాటిక్ లేదా నాన్-స్టాటిక్ కావచ్చు. స్టాటిక్ పద్ధతులు మాత్రమే స్టాటిక్ వేరియబుల్స్‌ను యాక్సెస్ చేయగలవు.

"నాకు ఇంకా స్టాటిక్ వేరియబుల్స్ గురించి స్పష్టమైన అవగాహన లేదు."

"ఓహ్, నాకు తెలుసు, కానీ చింతించకండి. ప్రస్తుతానికి, వారితో సుఖంగా ఉండండి. వారితో పరిచయం పెంచుకోండి. లెవెల్ 11లో, మేము స్టాటిక్ వేరియబుల్స్ మరియు పద్ధతుల నిర్మాణాన్ని విశ్లేషిస్తాము మరియు మీరు వీటికి కారణాలను అర్థం చేసుకుంటారు పరిమితులు.

"స్టాటిక్ వేరియబుల్ (క్లాస్ వేరియబుల్) చేయడానికి, మీరు staticదాని డిక్లరేషన్‌లో తప్పనిసరిగా కీవర్డ్‌ని వ్రాయాలి.

"స్టాటిక్ వేరియబుల్స్ అవి డిక్లేర్ చేయబడిన తరగతికి సంబంధించిన వస్తువు లేదా ఉదాహరణకి కట్టుబడి ఉండవు. బదులుగా, అవి తరగతికి చెందినవి. అందుకే తరగతిలోని ఒక్క వస్తువు కూడా సృష్టించబడనప్పటికీ అవి ఉనికిలో ఉన్నాయి . మీరు వీటిని సూచించవచ్చు. ఇలాంటి నిర్మాణాన్ని ఉపయోగించి ఇతర తరగతుల నుండి వారు:

ClassName.variableName

ఉదాహరణ:

public class Solution
{
   public void add(int data)
   {
     Storage.sum = Storage.sum + data;
     Storage.count++;
   }

   public void remove(int data)
   {
     Storage.sum = Storage.sum - data;
     Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum



Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum

"పై ఉదాహరణలో, మేము ఒక ప్రత్యేక Storageతరగతిని సృష్టించాము, దానికి countమరియు వేరియబుల్‌లను తరలించాము మరియు వాటిని స్థిరంగా ప్రకటించాము . పబ్లిక్ స్టాటిక్ వేరియబుల్స్ ప్రోగ్రామ్‌లోని ఏదైనా పద్ధతి నుండి (మరియు ఒక పద్ధతి నుండి మాత్రమే కాకుండా) యాక్సెస్ చేయవచ్చు."sum

"నాకు పూర్తిగా అర్థం కాలేదు, కానీ ఇది నాకు సౌకర్యంగా ఉంది."

"కాబట్టి ఇది. మరియు కొన్నిసార్లు ఇది అవసరం. స్టాటిక్ వేరియబుల్స్ మరియు పద్ధతులు లేకుండా మనం చిక్కుకుపోతాము."

"ఆశాజనక, నేను నెమ్మదిగా దాన్ని గుర్తించగలను."

"అవును, తప్పకుండా చేస్తాను."