వేరియబుల్స్తో పని చేసే సూక్ష్మ నైపుణ్యాలు

స్థిరాంకాలు

"అమిగో, జావాలో అన్ని వేరియబుల్స్ మార్చబడవని మీకు తెలుసా?"

"అది ఎలా ఉంది, కిమ్? నిజానికి, 'వేరియబుల్' అనే పదం మార్పు గురించి మాట్లాడుతుంది."

"దాని గురించి ఎటువంటి సందేహం లేదు. అనేక ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల వలె, జావాలో స్థిరాంకాలు ఉన్నాయి , అంటే, విలువలను మార్చలేని వేరియబుల్స్ ఉన్నాయి . మరియు 'స్థిరత్వం' అనే పదం స్థిరత్వం గురించి మాట్లాడుతుంది."

"మరి అవి దేనికి?"

Pi"సాధారణంగా, అవి సంవత్సరంలోని నెలల్లోని సంఖ్య లేదా రోజుల సంఖ్య వంటి కొన్ని రకాల ప్రాథమిక విషయాల కోసం ఉపయోగించబడతాయి . సూత్రప్రాయంగా, ప్రోగ్రామర్ ఏదైనా వేరియబుల్‌ను స్థిరంగా మార్చగలడు, అతను లేదా ఆమె అలా చేయాలని నిర్ణయించుకుంటే. కాబట్టి అవసరం."

"మీ ఉద్దేశ్యం పేరు, కారు రంగు లేదా వారంలో ఒక రోజు పేరు?"

"మీకు సరైన ఆలోచన వచ్చింది. మార్చకూడనిది ఏదైనా."

"మరియు ఈ స్థిరాంకాలు జావాలో ఎలా కనిపిస్తాయి?"

"Java వాటి కోసం ఒక ప్రత్యేక కీవర్డ్‌ని కలిగి ఉంది: . ఒక మార్పులేని వేరియబుల్‌ని సృష్టించడం అనేది సాధారణమైన దానిని సృష్టించినట్లుగానే కనిపిస్తుంది. ఒకే ఒక్క తేడా ఏమిటంటే, వేరియబుల్ రకానికి ముందు మీరు ఈ విధంగా finalపదాన్ని వ్రాయాలి :final

final Type name = value;

"మీరు స్థిరాంకాన్ని సృష్టించి, దానికి వేరొక విలువను కేటాయించడానికి ప్రయత్నిస్తే ఏమి జరుగుతుంది?"

"అడగడానికి ఇది సరైన ప్రశ్న! మరియు సరైన సమాధానం ఇది: మీరు వేరియబుల్‌కు వేరే విలువను కేటాయించడానికి ప్రయత్నిస్తే final, మీ ప్రోగ్రామ్ కంపైల్ చేయదు."

final"మీరు వేరియబుల్‌ని డిక్లేర్ చేసినా దానికి విలువను కేటాయించకపోతే ఏమి చేయాలి ?"

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

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

"ఊ... ఓవర్‌రైడ్ చేశారా? వారసత్వంగా వచ్చారా? ఇప్పుడు ఏ భాష మాట్లాడుతున్నారు?"

"ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క భాష. మీరు దానిని అతి త్వరలో పొందుతారు. అప్పటి వరకు, అందమైన పదజాలాన్ని ఆస్వాదించండి."

"సరే. కాబట్టి, finalవేరియబుల్స్, క్లాస్‌లు మరియు మెథడ్స్‌కు ముందు ఉంచవచ్చు మరియు ఈ కీవర్డ్ వాటిని ఏదో ఒక కోణంలో మార్చలేనిదిగా చేస్తుంది?"

"అవును. ఇంకా, finalమాడిఫైయర్ ఏదైనా వేరియబుల్స్‌కు ముందు జోడించబడవచ్చు: స్థానిక వేరియబుల్స్, మెథడ్ పారామీటర్‌లు, క్లాస్ ఫీల్డ్‌లు మరియు స్టాటిక్ క్లాస్ వేరియబుల్స్.

"ఇక్కడ గుర్తుంచుకోవలసిన ముఖ్యమైన విషయం ఏమిటంటే: finalవేరియబుల్ పేరు ముందు ఆ వేరియబుల్‌కు ఏవైనా మార్పులకు వ్యతిరేకంగా రక్షణగా ఉంటుంది . వేరియబుల్ ఒక వస్తువుకు సూచనను నిల్వ చేస్తే, ఆ వస్తువును ఇప్పటికీ మార్చవచ్చు."

"నాకు సరిగ్గా అర్థం కాలేదు."

"మీరు నిజంగా త్వరలోనే అర్థం చేసుకుంటారు. ఇక్కడ ఒక ఉదాహరణ:

final int[] data = {1, 2, 3, 4, 5, 6};

data = {6, 7, 8, 9};

data[0] = 0;
data[1] = 0;
data[2] = 0;

"అర్థమైంది. గమ్మత్తుగా ఉంది."

గ్లోబల్ స్థిరాంకాలు

"గ్లోబల్ స్థిరాంకాలు అంటే ఏమిటి?"

"గ్లోబల్ స్థిరాంకాలు బహుశా గ్లోబల్ వేరియబుల్స్ లాగా ఉంటాయని నేను ఊహిస్తున్నాను, స్థిరాంకాలు మాత్రమే?"

"సరిగ్గా. మీరు మీ ప్రోగ్రామ్‌లో గ్లోబల్ స్థిరాంకాలను ప్రకటించాల్సిన అవసరం ఉన్నట్లయితే, స్టాటిక్ క్లాస్ వేరియబుల్‌లను సృష్టించండి మరియు వాటిని తయారు చేయండి publicమరియు final. అటువంటి వేరియబుల్స్ పేర్లకు ప్రత్యేక శైలి ఉంది: అవి అన్ని పెద్ద అక్షరాలతో, అండర్‌స్కోర్ అక్షరంతో వ్రాయబడతాయి. ప్రత్యేక పదాలు.

ఉదాహరణలు:

class Solution
{
   public static final String SOURCE_ROOT = "c:\\projects\\my\\";
   public static final int DISPLAY_WIDTH = 1024;
   public static final int DISPLAY_HEIGHT = 768;
}

వేరియబుల్ నీడ

"నేను ముందే చెప్పినట్లు, మీరు ఒకే పద్ధతిలో ఒకే పేర్లతో బహుళ స్థానిక వేరియబుల్‌లను సృష్టించలేరు. వివిధ పద్ధతులలో, మీరు చేయవచ్చు."

"అది నాకు తెలుసు!"

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

ఉదాహరణ:

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

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

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

"పద్ధతిలో add, మేము స్థానిక వేరియబుల్ పేరును ప్రకటించాము sum. పద్ధతి ముగిసే వరకు, ఇది ఉదాహరణ వేరియబుల్‌ను నీడలు (లేదా ముసుగులు ) చేస్తుంది sum."

"హ్మ్... ఇది ఊహించిన ప్రవర్తన అని నేను కొంత కోణంలో చెబుతాను."

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

this.name

"పేరు వైరుధ్యం విజయవంతంగా పరిష్కరించబడిన ఉదాహరణ ఇక్కడ ఉంది:

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

   public void add(int data)
   {
     int sum = data * 2;
     this.sum = this.sum + data;
     count++;
   }
}

this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum, data
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum

మరియు countవేరియబుల్స్ కీవర్డ్‌తో sumలేదా లేకుండా ప్రతిచోటా అందుబాటులో ఉంటాయి this. sumలోకల్ వేరియబుల్ ఇన్‌స్టాన్స్ వేరియబుల్‌ను షాడో చేసే లైన్‌లలో sum, sumఇన్‌స్టాన్స్ వేరియబుల్ కీవర్డ్‌ని ఉపయోగించి మాత్రమే యాక్సెస్ చేయబడుతుంది this.

"సహజంగానే, నేను దీన్ని సాధన చేయాలి."

"మీరు నిర్వహిస్తారు."

"ఒక స్టాటిక్ క్లాస్ వేరియబుల్ కేవలం (నాన్-స్టాటిక్) ఇన్‌స్టాన్స్ వేరియబుల్ కాకుండా షాడోడ్ చేయబడితే? మీరు దానిని యాక్సెస్ చేయలేరు this?"

"మీరు చెప్పింది నిజమే. ఈ కీవర్డ్ పని చేయదు. మీరు దానిని తరగతి పేరు ద్వారా సూచించాలి:

ClassName.name

ఉదాహరణ:

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

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

Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum, data
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum

"శ్రద్ధ వహించండి: మీరు తరగతి పేరును ఉపసర్గగా ఉపయోగించకుండా లేదా లేకుండా ప్రతిచోటా countమరియు స్టాటిక్ వేరియబుల్‌లను యాక్సెస్ చేయవచ్చు . స్థానిక వేరియబుల్ ఇన్‌స్టాన్స్ వేరియబుల్‌ను షాడో చేసే పంక్తులలో , ఉపసర్గగా ఉపయోగిస్తున్నప్పుడు మాత్రమే క్లాస్ వేరియబుల్‌కు ప్రాప్యత సాధ్యమవుతుంది .sumSolutionsumsumsumSolution

forలూప్ లోపల వేరియబుల్స్

for"మరియు మరొక చిన్న కానీ ఆసక్తికరమైన వాస్తవం. వేరియబుల్ ఒక ప్రత్యేక మార్గంలో ప్రకటించబడిన ప్రదేశం కూడా ఉంది — నేను లూప్ లోపల మాట్లాడుతున్నాను ." సాధారణంగా, లూప్ కుండలీకరణాల్లో వేరియబుల్ forఉంటుంది . counterమరియు ఈ వేరియబుల్ యొక్క దృశ్యమానత ఏమిటి? అన్ని తరువాత, ఇది లూప్ యొక్క శరీరంలో లేదు. ఇది మొత్తం పద్ధతి? లేదా?"

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

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

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a

"కాబట్టి మీరు నా కోడ్‌లో ఒకే పేరుతో కౌంటర్ వేరియబుల్‌తో ఒకదాని తర్వాత ఒకటిగా అనేక లూప్‌లను వ్రాయవచ్చని మరియు ఎటువంటి సమస్యలు ఉండవని మీరు చెబుతున్నారా?"

"ఏ సమస్యలు ఉండవు. ఇక్కడ చూడండి:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   for (int i = 0; i < 10; i--)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a, i
a, i
a, i
a
a
a