జావా స్కోప్

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

సాధారణంగా జావా స్కోప్

వేరియబుల్స్ మరియు మెథడ్స్ యొక్క స్కోప్‌లను వేరు చేయడం ఎందుకు అవసరం? వాస్తవం ఏమిటంటే కొన్నిసార్లు ప్రోగ్రామ్‌లు చాలా పెద్దవిగా ఉంటాయి మరియు ఒకటి లేదా మరొక వేరియబుల్‌ను ట్రాక్ చేయడం కష్టం. అదనంగా, పెద్ద ప్రాజెక్ట్‌లలో, వేరియబుల్స్‌కు స్పష్టమైన పేరు పెట్టడం మంచిది, తద్వారా అవి దేని కోసం ఉన్నాయో స్పష్టంగా తెలుస్తుంది. ప్రోగ్రామ్‌లోని వివిధ భాగాలలో ఒకే పేరుతో విభిన్న వేరియబుల్‌లను కలిగి ఉండటానికి స్కోప్ ప్రత్యేకంగా మిమ్మల్ని అనుమతిస్తుంది. ఇటువంటి కోడ్ నిర్వహించడం మరియు చదవడం సులభం. ప్రోగ్రామ్‌లో నిర్దిష్ట వేరియబుల్ లేదా పద్ధతి ఎక్కడ అందుబాటులో ఉందో జావా స్కోప్ నిర్వచిస్తుంది. క్లుప్తంగా:

• ఒక పద్ధతిలో డిక్లేర్ చేయబడిన వేరియబుల్ డిక్లరేషన్ ప్రారంభం నుండి పద్ధతి చివరి వరకు కనిపిస్తుంది (పద్ధతి పరిధి).
• కోడ్ బ్లాక్‌లో డిక్లేర్డ్ చేయబడిన వేరియబుల్ ఆ కోడ్ బ్లాక్ ముగిసే వరకు ఉంటుంది.
• మెథడ్ ఆర్గ్యుమెంట్‌లుగా ఉండే వేరియబుల్స్ మెథడ్ ముగిసే వరకు ఉంటాయి.
• తరగతి/ఆబ్జెక్ట్ వేరియబుల్స్ కలిగి ఉన్న వస్తువు యొక్క జీవితకాలం వరకు ఉంటాయి. వారి దృశ్యమానత ప్రత్యేక యాక్సెస్ మాడిఫైయర్లచే నియంత్రించబడుతుంది.
• ప్రోగ్రామ్ నడుస్తున్న అన్ని సమయాలలో స్టాటిక్ క్లాస్ వేరియబుల్స్ ఉంటాయి. వాటి దృశ్యమానత కూడా యాక్సెస్ మాడిఫైయర్‌ల ద్వారా నిర్ణయించబడుతుంది.

పద్ధతి స్థాయి పరిధి

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

public class JScopeTest1 {


   public static void main(String[] args) {

       System.out.println(myMethod(5));
       System.out.println(myMethod(17));

   }
   public static int  myMethod(int arg) {
       int secondArg = 100; //local method variable
       return secondArg + arg;
   }
}

ఇక్కడ మనం secondArg , లోకల్ వేరియబుల్ లేదా మెథడ్ ఆర్గ్యుమెంట్‌ని కలిగి ఉన్నాము. మేము ఈ వేరియబుల్‌ని myMethod పద్ధతికి వెలుపల లేదా ఇది ప్రకటించబడక ముందు ఉపయోగించలేము . వేరియబుల్ ఒక ఫంక్షన్ ఆర్గ్యుమెంట్ అయితే, అది ఈ పద్ధతి యొక్క మొత్తం శరీరంలో కనిపిస్తుంది. పై ఉదాహరణలో మనకు అలాంటి రెండు ఆర్గ్యుమెంట్‌లు ఉన్నాయి: మైమెథడ్‌లో ఆర్గ్ మరియు మెయిన్ మెథడ్‌లో ఆర్గ్స్.

తరగతి స్థాయి పరిధి

క్లాస్-లెవల్ స్కోప్ (ఇన్‌స్టాన్స్ వేరియబుల్స్) — క్లాస్‌లో డిక్లేర్ చేయబడిన ఏదైనా వేరియబుల్ ఆ తరగతిలోని అన్ని పద్ధతులకు అందుబాటులో ఉంటుంది. దాని యాక్సెస్ మాడిఫైయర్‌పై ఆధారపడి (అంటే పబ్లిక్ లేదా ప్రైవేట్), ఇది కొన్నిసార్లు తరగతి వెలుపల యాక్సెస్ చేయబడుతుంది. కాబట్టి వేరియబుల్ క్లాస్ వేరియబుల్ అయితే, అది ఒక నిర్దిష్ట వస్తువుకు కట్టుబడి ఉంటుంది మరియు ఈ తరగతికి చెందిన వస్తువు ఉన్నంత వరకు ఉంటుంది. వస్తువు లేకపోతే, వేరియబుల్ యొక్క కాపీ లేదు. వేరియబుల్ క్లాస్ యొక్క అన్ని పద్ధతుల నుండి కనిపిస్తుంది, అవి దానికి ముందు లేదా తర్వాత ప్రకటించబడినా అనే దానితో సంబంధం లేకుండా. ప్రతి వస్తువు ఇతర వస్తువులతో సంబంధం లేకుండా దాని స్వంత వేరియబుల్ కలిగి ఉంటుంది. స్టాటిక్ పద్ధతుల నుండి వేరియబుల్‌కు ప్రాప్యత సాధ్యం కాదు.

కోడ్ ఉదాహరణ

public class Student {
   
//class level variables
   public String surname;
   String name;
   String secondName;
   private Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

ఇంటిపేరు , పేరు , రెండవ పేరు మరియు పుట్టినరోజు ఇన్‌స్టాన్స్ వేరియబుల్స్.

బ్లాక్ స్కోప్

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

public class JScopeTest2 {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           int sum = 0;
           sum = sum + i;
       }
      
       int sum = 1;
       System.out.println(sum);
   }
}

మొదటి మొత్తం మరియు i వేరియబుల్స్ రెండూ లూప్ లోపల ప్రకటించబడ్డాయి మరియు ఈ లూప్ వెలుపల ఉనికిలో లేవు. అయితే రెండవ మొత్తం లూప్ వెలుపల ప్రకటించబడింది కాబట్టి ఈ ప్రత్యేక వేరియబుల్ ముద్రించబడుతుంది.

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

ఒక వేరియబుల్ స్టాటిక్‌గా ప్రకటించబడితే (స్టాటిక్ కీవర్డ్‌తో గుర్తించబడింది), అప్పుడు దాని తరగతి ఉన్నంత వరకు అది ఉనికిలో ఉంటుంది. సాధారణంగా, స్టాటిక్ వేరియబుల్స్ ప్రారంభించబడినప్పుడు, JVM మొదటి ఉపయోగంలో ఒక తరగతిని మెమరీలోకి లోడ్ చేస్తుంది.

import java.util.Date;

public class Student {
   public static int today = 2022;
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

 
   public static void main(String[] args) {
       System.out.println(today);
   }

}

స్టాటిక్ టుడే వేరియబుల్‌ని ఉపయోగించడానికి మీరు స్టూడెంట్ క్లాస్ యొక్క కొత్త ఉదాహరణను సృష్టించకూడదు . ఇక్కడ “2022” ముద్రించబడుతుంది.

యాక్సెస్ మాడిఫైయర్‌లు

జావా పద్ధతి లేదా వేరియబుల్‌కు ప్రాప్యతను పరిమితం చేయడానికి 4 యాక్సెస్ మాడిఫైయర్‌లను కలిగి ఉంది. మీరు వాటిని తరగతుల లోపల ఉపయోగించవచ్చు, పద్ధతులు లోపల కాదు.

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

• యాక్సెస్ మాడిఫైయర్ పేర్కొనబడకపోతే, పద్ధతి లేదా వేరియబుల్ డిఫాల్ట్ మాడిఫైయర్‌ను అంగీకరిస్తుంది. డిఫాల్ట్ ప్రస్తుత ప్యాకేజీ నుండి మాత్రమే యాక్సెస్‌ని అనుమతిస్తుంది.

• రక్షిత మాడిఫైయర్ ఒక పద్ధతి లేదా వేరియబుల్‌ని ప్రస్తుత ప్యాకేజీలో నుండి మాత్రమే యాక్సెస్ చేయడానికి అనుమతిస్తుంది, ఇది ప్యాకేజీ వెలుపల ఉన్న చైల్డ్ క్లాస్ ద్వారా యాక్సెస్ చేయబడితే తప్ప.

• పబ్లిక్ అనేది అతి తక్కువ పరిమితి గల మాడిఫైయర్. ఇది క్లాస్, మెథడ్ లేదా వేరియబుల్‌ని డిక్లేర్ చేయబడిన క్లాస్ నుండి మాత్రమే కాకుండా బయట నుండి కూడా యాక్సెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఈ మాడిఫైయర్ నిజంగా తరచుగా ఉపయోగించబడుతుంది.