गेटर्स और सेटर्स

नमस्ते! पिछले पाठों में, आप पहले ही सीख चुके हैं कि विधियों और क्षेत्रों के साथ अपनी स्वयं की पूर्ण कक्षाओं की घोषणा कैसे करें। आज के पाठ में, हम जावा में गेटर्स और सेटर्स के बारे में बात करेंगे। यह गंभीर प्रगति है, शाबाश! लेकिन अब मुझे आपको एक कड़वा सच बताना है। हमने अपनी कक्षाओं को सही ढंग से घोषित नहीं किया! क्यों? पहली नजर में, निम्न वर्ग में कोई त्रुटि नहीं है:

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

लेकिन यह करता है। कल्पना कीजिए कि आप काम पर बैठे हैं और बिल्लियों का प्रतिनिधित्व करने के लिए इस कैट क्लास को लिखें। और फिर तुम घर जाओ। जब आप चले जाते हैं, तो दूसरा प्रोग्रामर काम पर आता है। वह अपना मुख्य वर्ग बनाता है, जहाँ वह आपके द्वारा लिखे गए कैट वर्ग का उपयोग करना शुरू करता है।

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";
       cat.age = -1000;
       cat.weight = 0;
   }
}

इससे कोई फर्क नहीं पड़ता कि उसने ऐसा क्यों किया और यह कैसे हुआ (शायद लड़का थक गया है या पर्याप्त नींद नहीं ली है)। कुछ और मायने रखता है: हमारी वर्तमान कैट क्लास फ़ील्ड्स को बिल्कुल पागल मान असाइन करने की अनुमति देती है। नतीजतन, कार्यक्रम में एक अमान्य स्थिति वाली वस्तुएं हैं (जैसे कि यह बिल्ली -1000 वर्ष पुरानी है)। तो हमने अपनी कक्षा घोषित करते समय क्या त्रुटि की? हमने अपनी कक्षा के डेटा को उजागर किया। नाम, उम्र और वज़न फ़ील्ड सार्वजनिक हैं। उन्हें प्रोग्राम में कहीं भी एक्सेस किया जा सकता है: बस एक कैट ऑब्जेक्ट बनाएं और किसी भी प्रोग्रामर की डॉट (। ) ऑपरेटर के माध्यम से इसके डेटा तक सीधी पहुंच हो।

Cat cat = new Cat();
cat.name = "";

यहां हम सीधे नाम क्षेत्र तक पहुंच रहे हैं और इसका मूल्य निर्धारित कर रहे हैं। हमें किसी तरह अपने डेटा को अनुचित बाहरी हस्तक्षेप से बचाने की जरूरत है। हमें ऐसा करने की क्या ज़रूरत है? सबसे पहले, सभी उदाहरण चर (फ़ील्ड) को निजी संशोधक के साथ चिह्नित किया जाना चाहिए। निजी जावा में सबसे सख्त एक्सेस संशोधक है। एक बार जब आप ऐसा कर लेते हैं, तो कैट वर्ग के क्षेत्र कक्षा के बाहर पहुँच योग्य नहीं होंगे।

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";//error! The Cat class's name field is private!
   }
}

संकलक इसे देखता है और तुरंत एक त्रुटि उत्पन्न करता है। अब खेत एक तरह से सुरक्षित हैं। लेकिन यह पता चला है कि हमने पहुंच को शायद बहुत अधिक बंद कर दिया है: आप कार्यक्रम में मौजूदा बिल्ली का वजन नहीं प्राप्त कर सकते हैं, भले ही आपको इसकी आवश्यकता हो। यह भी कोई विकल्प नहीं है। वैसे भी, हमारी कक्षा अनिवार्य रूप से अनुपयोगी है। आदर्श रूप से, हमें किसी प्रकार की सीमित पहुँच की अनुमति देने की आवश्यकता है:

• अन्य प्रोग्रामर कैट ऑब्जेक्ट बनाने में सक्षम होना चाहिए
• उन्हें मौजूदा वस्तुओं से डेटा पढ़ने में सक्षम होना चाहिए (उदाहरण के लिए, मौजूदा बिल्ली का नाम या आयु प्राप्त करें)
• फील्ड वैल्यू असाइन करना भी संभव होना चाहिए। लेकिन ऐसा करने में, केवल मान्य मानों की अनुमति दी जानी चाहिए। हमारी वस्तुओं को अमान्य मूल्यों (जैसे आयु = -1000, आदि) से सुरक्षित किया जाना चाहिए।

यह आवश्यकताओं की एक अच्छी सूची है! वास्तव में, यह सब गेटर्स और सेटर्स नामक विशेष विधियों से आसानी से हासिल किया जाता है। ये नाम "गेट" (यानी "फ़ील्ड का मान प्राप्त करने की विधि") और "सेट" (यानी "फ़ील्ड का मान सेट करने की विधि") से आते हैं। आइए देखें कि वे हमारी कैट क्लास में कैसे दिखते हैं :

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       this.weight = weight;
   }
}

जैसा कि आप देख सकते हैं, वे बहुत सरल दिखते हैं :) उनके नाम में अक्सर "गेट"/"सेट" प्लस प्रासंगिक क्षेत्र का नाम शामिल होता है। उदाहरण के लिए, getWeight () विधि उस वस्तु के वजन क्षेत्र का मान लौटाती है जिस पर उसे बुलाया जाता है। यहाँ यह एक कार्यक्रम में कैसा दिखता है:

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       String smudgeName = smudge.getName();
       int smudgeAge = smudge.getAge();
       int smudgeWeight = smudge.getWeight();

       System.out.println("Cat's name: " + smudgeName);
       System.out.println("Cat's age: " + smudgeAge);
       System.out.println("Cat's weight: " + smudgeWeight);
   }
}

कंसोल आउटपुट:

Cat's name: Smudge
Cat's age: 5
Cat's weight: 4

अब एक अन्य वर्ग ( Main ) कैट फील्ड तक पहुंच सकता है , लेकिन केवल गेटर्स के माध्यम से। ध्यान दें कि गेटर्स के पास पब्लिक एक्सेस मॉडिफायर है, यानी वे प्रोग्राम में कहीं से भी उपलब्ध हैं। लेकिन मूल्यों को असाइन करने के बारे में क्या? यही सेटर तरीके हैं

public void setName(String name) {
   this.name = name;
}

जैसा कि आप देख सकते हैं, वे भी सरल हैं। हम कैट ऑब्जेक्ट पर सेटनेम () विधि को कॉल करते हैं, एक तर्क के रूप में एक स्ट्रिंग पास करते हैं, और स्ट्रिंग को ऑब्जेक्ट के नाम फ़ील्ड में असाइन किया जाता है।

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);

       System.out.println("Cat's original name: " + smudge.getName());
       smudge.setName("Mr. Smudge");
       System.out.println("Cat's new name: " + smudge.getName());
   }
}

यहां हम गेटर्स और सेटर्स दोनों का उपयोग कर रहे हैं। सबसे पहले, हम बिल्ली के मूल नाम को प्राप्त करने और प्रदर्शित करने के लिए गेटर का उपयोग करते हैं। फिर, हम एक नया नाम ("श्री स्मज") निर्दिष्ट करने के लिए एक सेटर का उपयोग करते हैं। और फिर हम नाम प्राप्त करने के लिए एक बार फिर गेट्टर का उपयोग करते हैं (यह जांचने के लिए कि क्या यह वास्तव में बदल गया है)। कंसोल आउटपुट:

Cat's original name: Smudge
Cat's new name: Mr. Smudge

तो क्या फर्क है? यदि हमारे पास बसने वाले हैं तो भी हम फ़ील्ड को अमान्य मान निर्दिष्ट कर सकते हैं:

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       smudge.setAge(-1000);

       System.out.println("Smudge's age: " + smudge.getAge());
   }
}

कंसोल आउटपुट:

Smudge's age: -1000 years

अंतर यह है कि एक सेटर एक पूर्ण विधि है। और एक क्षेत्र के विपरीत, एक विधि आपको अस्वीकार्य मूल्यों को रोकने के लिए आवश्यक सत्यापन तर्क लिखने देती है। उदाहरण के लिए, आप किसी ऋणात्मक संख्या को आयु के रूप में असाइन किए जाने से आसानी से रोक सकते हैं:

public void setAge(int age) {
   if (age >= 0) {
       this.age = age;
   } else {
       System.out.println("Error! Age can't be negative!");
   }
}

और अब हमारा कोड सही ढंग से काम करता है!

public class Main {

   public static void main(String[] args) {

       Cat smudge = new Cat("Smudge", 5, 4);
       smudge.setAge(-1000);

       System.out.println("Smudge's age: " + smudge.getAge());
   }
}

कंसोल आउटपुट:

Error! Age can't be negative!
Smudge's age: 5 years

सेटर के अंदर, हमने एक प्रतिबंध बनाया है जो हमें अमान्य डेटा सेट करने के प्रयास से सुरक्षित रखता है। स्मज की उम्र नहीं बदली थी। आपको हमेशा गेटर्स और सेटर्स बनाना चाहिए। यहां तक ​​​​कि अगर आपके खेतों के मूल्यों पर कोई प्रतिबंध नहीं है, तो ये सहायक तरीके कोई नुकसान नहीं पहुंचाएंगे। निम्नलिखित स्थिति की कल्पना करें: आप और आपके सहयोगी मिलकर एक कार्यक्रम लिख रहे हैं। आप सार्वजनिक क्षेत्रों के साथ कैट क्लास बनाते हैं। सभी प्रोग्रामर उनका उपयोग कर रहे हैं, हालांकि वे चाहते हैं। और फिर एक अच्छे दिन आपको एहसास होता है: "बकवास, जल्दी या बाद में कोई गलती से वजन के लिए एक ऋणात्मक संख्या निर्दिष्ट कर सकता है! हमें सेटर बनाने और सभी क्षेत्रों को निजी बनाने की आवश्यकता है!" आप ऐसा ही करते हैं, और अपने सहयोगियों द्वारा लिखे गए सभी कोड को तुरंत तोड़ देते हैं। आखिर वे'बिल्ली सीधे खेत।

cat.name = "Behemoth";

और अब क्षेत्र निजी हैं और संकलक त्रुटियों का एक गुच्छा उगलता है!

cat.name = "Behemoth";//error! The Cat class's name field is private!

इस मामले में, शुरुआत से ही खेतों को छिपाना और गेट्टर और सेटर बनाना बेहतर होगा। आपके सभी सहयोगियों ने उनका इस्तेमाल किया होगा। और अगर आपको देर से ही पता चला कि आपको किसी तरह फील्ड वैल्यू को प्रतिबंधित करने की जरूरत है, तो आप बस सेटर के अंदर चेक लिख सकते थे। और किसी का कोड नहीं तोड़ा जाएगा। बेशक, यदि आप चाहते हैं कि किसी क्षेत्र तक पहुंच केवल "रीड ओनली" हो, तो आप इसके लिए केवल एक गेट्टर बना सकते हैं। केवल विधियां बाहरी रूप से उपलब्ध होनी चाहिए (अर्थात आपकी कक्षा के बाहर)। डेटा छुपाया जाना चाहिए। हम एक मोबाइल फोन से तुलना कर सकते हैं। कल्पना करें कि सामान्य रूप से बंद मोबाइल फोन के बजाय, आपको एक खुला केस वाला फोन दिया गया था, जिसमें सभी प्रकार के बाहर निकलने वाले तार, सर्किट आदि थे। कॉल करने में सक्षम। परन्तु आप' इसके बजाय, निर्माता आपको एक इंटरफ़ेस देता है: उपयोगकर्ता केवल सही अंक दर्ज करता है, हरा कॉल बटन दबाता है, और कॉल शुरू हो जाती है। उसे परवाह नहीं है कि सर्किट और तारों के अंदर क्या होता है, या वे अपना काम कैसे करते हैं। इस उदाहरण में, कंपनी फोन के "इनसाइड्स" (डेटा) तक पहुंच को सीमित करती है और केवल एक इंटरफ़ेस (विधियों) को उजागर करती है। नतीजतन, उपयोगकर्ता को वह मिलता है जो वह चाहता था (कॉल करने की क्षमता) और निश्चित रूप से अंदर कुछ भी नहीं टूटेगा। आपने जो सीखा है उसे सुदृढ़ करने के लिए, हमारा सुझाव है कि आप हमारे जावा कोर्स से एक वीडियो सबक देखें