गेटर्स आणि सेटर्स

नमस्कार! मागील लेक्चर्समध्ये, तुम्ही आधीच शिकलात की पद्धती आणि फील्डसह तुमचे स्वतःचे पूर्ण वर्ग कसे घोषित करायचे. आजच्या धड्यात, आपण Java मधील Getters आणि Setters बद्दल बोलू. ही गंभीर प्रगती आहे, चांगले केले! पण आता मला एक कटू सत्य सांगायचे आहे. आम्ही आमचे वर्ग योग्यरित्या घोषित केले नाहीत! का? प्रथमदर्शनी, खालील वर्गात कोणतीही चूक नाही:

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 = "";

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

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

आता दुसरा वर्ग ( मुख्य ) कॅट फील्डमध्ये प्रवेश करू शकतो, परंतु केवळ गेटर्सद्वारे. लक्षात घ्या की गेटर्सकडे सार्वजनिक प्रवेश सुधारक असतो, म्हणजे ते प्रोग्राममध्ये कुठूनही उपलब्ध असतात. पण मूल्ये नियुक्त करण्याबद्दल काय? यासाठी सेटर पद्धती आहेत

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

जसे आपण पाहू शकता, ते देखील सोपे आहेत. आम्ही Cat ऑब्जेक्टवर setName() पद्धतीला कॉल करतो , स्ट्रिंगला वितर्क म्हणून पास करतो आणि स्ट्रिंग ऑब्जेक्टच्या नाव फील्डला नियुक्त केली जाते.

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

सेटरच्या आत, आम्ही एक निर्बंध तयार केले ज्याने आम्हाला अवैध डेटा सेट करण्याच्या प्रयत्नापासून संरक्षित केले. Smudge चे वय बदलले नाही. तुम्ही नेहमी गेटर्स आणि सेटर तयार केले पाहिजेत. तुमची फील्ड कोणती मूल्ये घेऊ शकतात यावर कोणतेही निर्बंध नसले तरीही, या सहाय्यक पद्धती कोणतेही नुकसान करणार नाहीत. खालील परिस्थितीची कल्पना करा: तुम्ही आणि तुमचे सहकारी एकत्र एक कार्यक्रम लिहित आहात. तुम्ही सार्वजनिक फील्डसह एक मांजर वर्ग तयार करता. सर्व प्रोग्रामर त्यांना हवे तसे वापरत आहेत. आणि मग एक चांगला दिवस तुम्हाला जाणवेल: "बकवास, लवकर किंवा नंतर कोणीतरी चुकून वजनासाठी नकारात्मक संख्या नियुक्त करू शकते! आम्हाला सेटर तयार करणे आणि सर्व फील्ड खाजगी करणे आवश्यक आहे!" तुम्ही तेच करा आणि तुमच्या सहकाऱ्यांनी लिहिलेले सर्व कोड झटपट तोडून टाका. अखेर, ते'थेट मांजर शेतात.

cat.name = "Behemoth";

आणि आता फील्ड खाजगी आहेत आणि कंपाइलर त्रुटींचा एक समूह दर्शवितो!

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

या प्रकरणात, फील्ड लपविणे आणि अगदी सुरुवातीपासून गेटर आणि सेटर तयार करणे चांगले होईल. तुमच्या सर्व सहकाऱ्यांनी त्यांचा वापर केला असता. आणि जर तुम्हाला उशीराने जाणवले की तुम्हाला फील्ड व्हॅल्यूज मर्यादित करणे आवश्यक आहे, तर तुम्ही सेटरमध्ये चेक लिहू शकता. आणि कोणाचाही कोड मोडला जाणार नाही. अर्थात, जर तुम्हाला एखाद्या फील्डमध्ये फक्त "रीड ओन्ली" असा प्रवेश हवा असेल तर तुम्ही त्यासाठी फक्त एक गेटर तयार करू शकता. केवळ पद्धती बाहेरून उपलब्ध असाव्यात (म्हणजे तुमच्या वर्गाबाहेर). डेटा लपविला पाहिजे. आम्ही मोबाईल फोनशी तुलना करू शकतो. कल्पना करा की नेहमीच्या बंदिस्त मोबाईल फोन ऐवजी, तुम्हाला एक ओपन केस असलेला फोन देण्यात आला होता, ज्यामध्ये सर्व प्रकारच्या पसरलेल्या तारा, सर्किट इ. पण फोन कार्य करतो: जर तुम्ही खरोखर प्रयत्न केला आणि सर्किट्स पोक केले तर तुम्ही कदाचित कॉल करण्यास सक्षम. पण तू' त्याऐवजी, निर्माता तुम्हाला एक इंटरफेस देतो: वापरकर्ता फक्त योग्य अंक प्रविष्ट करतो, हिरवा कॉल बटण दाबतो आणि कॉल सुरू होतो. सर्किट्स आणि वायर्समध्ये काय होते किंवा ते त्यांचे काम कसे करतात याची तिला पर्वा नाही. या उदाहरणात, कंपनी फोनच्या "इनसाइड्स" (डेटा) मध्ये प्रवेश मर्यादित करते आणि फक्त इंटरफेस (पद्धती) उघड करते. परिणामी, वापरकर्त्याला जे हवे होते ते मिळते (कॉल करण्याची क्षमता) आणि नक्कीच आत काहीही खंडित होणार नाही. तुम्ही जे शिकलात ते बळकट करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधील व्हिडिओ धडा पाहण्याची सूचना देतो