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

1. స్థిరాంకాలు

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

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

final Type name = value;

మీరు వేరియబుల్‌కు వేరొక విలువను కేటాయించడానికి ప్రయత్నిస్తే final, మీ ప్రోగ్రామ్ కంపైల్ చేయబడదు.

ఒక finalవేరియబుల్ ప్రకటించబడినప్పుడు తప్పనిసరిగా ప్రారంభించబడాలి (దానికి విలువను కేటాయించాలి). ఈ నియమానికి ఒక మినహాయింపు ఉంది: మీరు స్టాటిక్ క్లాస్ వేరియబుల్ యొక్క ప్రారంభాన్ని కన్స్ట్రక్టర్‌లోకి తరలించవచ్చు. కానీ మీరు దీని గురించి లెవల్ 10లో నేర్చుకుంటారు .

కీలక పదాల సంఖ్యను తగ్గించడానికి, జావా డెవలపర్‌లు 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;
}

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

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

అయితే మీకు బహుశా తెలియనిది ఇక్కడ ఉంది: ఉదాహరణ వేరియబుల్స్ మరియు లోకల్ మెథడ్ వేరియబుల్స్ ఒకే పేరుని కలిగి ఉంటాయి.

ఉదాహరణ:

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
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.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

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

మరియు మరొక చిన్న కానీ ఆసక్తికరమైన వాస్తవం.

ఒక వేరియబుల్ ఒక ప్రత్యేక మార్గంలో ప్రకటించబడిన ప్రదేశం కూడా ఉంది — forలూప్ లోపల .

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

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