जावा व्याप्ती

आपल्या सर्वांना माहित आहे की देशांना सीमा आणि त्यांचे स्वतःचे कायदे आहेत. देशाचे कायदे सीमेवर चालतात. तसेच देशात अशा संस्था आहेत, उदाहरणार्थ, शाळा किंवा संग्रहालये, ज्यांचे स्वतःचे स्थानिक नियम आहेत. ते देशाच्या कायद्यांचा विरोध करत नाहीत, परंतु केवळ निर्दिष्ट संस्थेच्या चौकटीत कार्य करतात. प्रोग्रामिंगमध्येही असेच आहे. म्हणून प्रोग्रामिंगमध्ये आणि विशेषतः जावा भाषेत, "स्कोप" हा शब्द आहे. हे प्रोग्रामच्या क्षेत्रांचा संदर्भ देते जेथे विशिष्ट डेटा, जसे की व्हेरिएबल्स किंवा पद्धती, कार्य करतात. या लेखात, आम्ही जावामधील व्हेरिएबल्ससाठी कोणते स्कोप आहेत आणि ते कसे परिभाषित करायचे ते शोधणार आहोत.

जावा व्याप्ती सर्वसाधारणपणे

व्हेरिएबल्स आणि पद्धतींचे स्कोप वेगळे करणे का आवश्यक आहे? वस्तुस्थिती अशी आहे की कधीकधी प्रोग्राम खूप मोठे असतात आणि एक किंवा दुसर्या व्हेरिएबलचा मागोवा घेणे कठीण होऊ शकते. याव्यतिरिक्त, मोठ्या प्रकल्पांमध्ये, व्हेरिएबल्सचे स्पष्ट नामकरण करणे इष्ट आहे जेणेकरून ते कशासाठी आहेत हे स्पष्ट होईल. स्कोप तुम्हाला प्रोग्रामच्या वेगवेगळ्या भागांमध्ये एकाच नावाचे वेगवेगळे व्हेरिएबल्स ठेवण्याची परवानगी देतो. असा कोड राखणे आणि वाचणे सोपे आहे. Java स्कोप हे परिभाषित करते की प्रोग्राममध्ये विशिष्ट व्हेरिएबल किंवा पद्धत कुठे प्रवेशयोग्य आहे. थोडक्यात:

• मेथडमध्ये घोषित केलेले व्हेरिएबल डिक्लेरेशनच्या सुरुवातीपासून मेथडच्या शेवटपर्यंत (पद्धतीची व्याप्ती) दृश्यमान असते.
• कोड ब्लॉकमध्ये घोषित केलेले व्हेरिएबल त्या कोड ब्लॉकच्या समाप्तीपर्यंत अस्तित्वात असते.
• मेथड आर्ग्युमेंट्स असलेले व्हेरिएबल्स मेथडच्या शेवटपर्यंत अस्तित्वात असतात.
• क्लास/ऑब्जेक्ट व्हेरिएबल्स समाविष्ट असलेल्या ऑब्जेक्टच्या आयुष्यभर अस्तित्वात असतात. त्यांची दृश्यमानता विशेष ऍक्सेस मॉडिफायर्सद्वारे नियंत्रित केली जाते.
• प्रोग्राम चालू असताना स्टॅटिक क्लास व्हेरिएबल्स अस्तित्वात असतात. त्यांची दृश्यमानता देखील ऍक्सेस मॉडिफायर्सद्वारे निर्धारित केली जाते.

पद्धत पातळी व्याप्ती

वितर्कांसह, पद्धतीमध्ये घोषित केलेले कोणतेही चल, त्या पद्धतीच्या बाहेर प्रवेश करण्यायोग्य नाही. मेथड्समध्ये घोषित केलेले सर्व व्हेरिएबल्स त्यांच्या घोषणेच्या सुरुवातीपासून ते पद्धतीच्या शेवटपर्यंत दृश्यमान असतात. येथे पद्धत व्हेरिएबल स्कोपचे उदाहरण आहे:

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" छापले जाईल.

ऍक्सेस मॉडिफायर्स

मेथड किंवा व्हेरिएबलमध्ये प्रवेश प्रतिबंधित करण्यासाठी Java मध्ये 4 ऍक्सेस मॉडिफायर आहेत. तुम्ही त्यांचा वापर वर्गांमध्ये करू शकता, आतील पद्धतींमध्ये नाही.

• खाजगी सर्वात प्रतिबंधित सुधारक आहे. ते घोषित केलेल्या वर्गाच्या पद्धती आणि चलांमध्ये प्रवेश प्रतिबंधित करते. वर्गाच्या बाहेर विशिष्ट पद्धती किंवा चल वापरण्याची आवश्यकता नसल्यास, खाजगी वापरा. क्लास व्हेरिएबल्स सहसा Java मध्ये खाजगी असतात.

• जर कोणताही ऍक्सेस मॉडिफायर निर्दिष्ट केला नसेल, तर पद्धत किंवा व्हेरिएबल डीफॉल्ट सुधारक स्वीकारेल . डीफॉल्ट केवळ वर्तमान पॅकेजमधून प्रवेश करण्यास अनुमती देते.

• प्रोटेक्टेड मॉडिफायर फक्त सध्याच्या पॅकेजमधून पद्धत किंवा व्हेरिएबलमध्ये प्रवेश करण्याची परवानगी देतो, जोपर्यंत पॅकेजच्या बाहेर चाइल्ड क्लासद्वारे प्रवेश केला जात नाही.

• सार्वजनिक हे कमीत कमी प्रतिबंधक सुधारक आहे. हे तुम्हाला वर्ग, पद्धत किंवा व्हेरिएबल केवळ घोषित केलेल्या वर्गातूनच नाही तर बाहेरून देखील प्रवेश करू देते. हे सुधारक खरोखर अनेकदा वापरले जाते.