பெறுபவர்கள் மற்றும் செட்டர்கள்

வணக்கம்! முந்தைய வகுப்புகளில், முறைகள் மற்றும் புலங்களுடன் உங்கள் சொந்த முழு அளவிலான வகுப்புகளை எவ்வாறு அறிவிப்பது என்பதை நீங்கள் ஏற்கனவே கற்றுக்கொண்டீர்கள். இன்றைய பாடத்தில், ஜாவாவில் கெட்டர்ஸ் மற்றும் செட்டர்ஸ் பற்றி பேசுவோம். இது தீவிர முன்னேற்றம், நன்றாக முடிந்தது! ஆனால் இப்போது நான் உங்களுக்கு ஒரு விரும்பத்தகாத உண்மையைச் சொல்ல வேண்டும். நாங்கள் எங்கள் வகுப்புகளை சரியாக அறிவிக்கவில்லை! ஏன்? முதல் பார்வையில், பின்வரும் வகுப்பில் எந்த தவறும் இல்லை:

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

இப்போது மற்றொரு வகுப்பு ( முதன்மை ) கேட் புலங்களை அணுக முடியும் , ஆனால் பெறுபவர்கள் மூலம் மட்டுமே. பெறுபவர்களுக்கு பொது அணுகல் மாற்றி உள்ளது என்பதை நினைவில் கொள்ளவும், அதாவது அவை நிரலில் எங்கிருந்தும் கிடைக்கும். ஆனால் மதிப்புகளை ஒதுக்குவது பற்றி என்ன? இதற்குத்தான் செட்டர் முறைகள்

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

செட்டரின் உள்ளே, தவறான தரவை அமைக்கும் முயற்சியில் இருந்து எங்களைப் பாதுகாக்கும் கட்டுப்பாட்டை உருவாக்கினோம். ஸ்மட்ஜின் வயது மாற்றப்படவில்லை. நீங்கள் எப்போதும் பெறுபவர்களையும் செட்டர்களையும் உருவாக்க வேண்டும். உங்கள் புலங்கள் என்ன மதிப்புகளை எடுக்கலாம் என்பதில் கட்டுப்பாடுகள் இல்லாவிட்டாலும், இந்த உதவி முறைகள் எந்தத் தீங்கும் செய்யாது. பின்வரும் சூழ்நிலையை கற்பனை செய்து பாருங்கள்: நீங்களும் உங்கள் சக ஊழியர்களும் சேர்ந்து ஒரு நிரலை எழுதுகிறீர்கள். நீங்கள் பொதுப் புலங்களுடன் ஒரு பூனை வகுப்பை உருவாக்குகிறீர்கள். எல்லா புரோகிராமர்களும் எப்படி வேண்டுமானாலும் பயன்படுத்துகிறார்கள். பின்னர் ஒரு நல்ல நாள் நீங்கள் புரிந்துகொள்கிறீர்கள்: "கேவலம், விரைவில் அல்லது பின்னர் யாராவது தற்செயலாக எடைக்கு எதிர்மறை எண்ணை ஒதுக்கலாம்! நாம் செட்டர்களை உருவாக்கி, எல்லா புலங்களையும் தனிப்பட்டதாக மாற்ற வேண்டும்!" நீங்கள் அதைச் செய்து, உங்கள் சகாக்கள் எழுதிய அனைத்து குறியீட்டையும் உடனடியாக உடைக்கவும். எல்லாவற்றிற்கும் மேலாக, அவர்கள்பூனை நேரடியாக களமிறங்குகிறது.

cat.name = "Behemoth";

இப்போது புலங்கள் தனிப்பட்டவை மற்றும் கம்பைலர் பல பிழைகளைத் தூண்டுகிறது!

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

இந்த விஷயத்தில், புலங்களை மறைத்து, ஆரம்பத்திலிருந்தே கெட்டர் மற்றும் செட்டர்களை உருவாக்குவது நல்லது. உங்கள் சக ஊழியர்கள் அனைவரும் அவற்றைப் பயன்படுத்தியிருப்பார்கள். புல மதிப்புகளை எப்படியாவது கட்டுப்படுத்த வேண்டும் என்பதை நீங்கள் தாமதமாக உணர்ந்திருந்தால், செட்டருக்குள் காசோலையை எழுதியிருக்கலாம். மேலும் யாருடைய குறியீடும் உடைக்கப்படாது. நிச்சயமாக, ஒரு புலத்திற்கான அணுகல் "படிக்க மட்டும்" இருக்க வேண்டுமெனில், அதற்கான பெறுநரை மட்டுமே நீங்கள் உருவாக்க முடியும். முறைகள் மட்டுமே வெளிப்புறமாக இருக்க வேண்டும் (அதாவது உங்கள் வகுப்பிற்கு வெளியே). தரவு மறைக்கப்பட வேண்டும். மொபைல் போனுடன் நாம் ஒப்பிட்டுப் பார்க்கலாம். வழக்கமான இணைக்கப்பட்ட மொபைல் ஃபோனுக்குப் பதிலாக, உங்களுக்கு ஒரு திறந்த பெட்டியுடன் கூடிய தொலைபேசி வழங்கப்பட்டது என்று கற்பனை செய்து பாருங்கள், அனைத்து வகையான நீண்டுகொண்டிருக்கும் கம்பிகள், சர்க்யூட்கள் போன்றவை. ஆனால் தொலைபேசி வேலை செய்கிறது: நீங்கள் கடினமாக முயற்சி செய்து, சுற்றுகளை குத்தினால், நீங்கள் கூட இருக்கலாம். அழைப்பு செய்ய முடியும். ஆனால் நீ' அதற்கு பதிலாக, உற்பத்தியாளர் உங்களுக்கு ஒரு இடைமுகத்தை வழங்குகிறார்: பயனர் சரியான இலக்கங்களை உள்ளிட்டு, பச்சை அழைப்பு பொத்தானை அழுத்தி, அழைப்பு தொடங்குகிறது. சுற்றுகள் மற்றும் கம்பிகளால் உள்ளே என்ன நடக்கிறது, அல்லது அவர்கள் தங்கள் வேலையை எப்படிச் செய்கிறார்கள் என்பதைப் பற்றி அவள் கவலைப்படுவதில்லை. இந்த எடுத்துக்காட்டில், நிறுவனம் ஃபோனின் "இன்சைட்ஸ்" (தரவு) க்கான அணுகலைக் கட்டுப்படுத்துகிறது மற்றும் ஒரு இடைமுகத்தை (முறைகள்) மட்டுமே வெளிப்படுத்துகிறது. இதன் விளைவாக, பயனர் அவள் விரும்பியதைப் பெறுகிறார் (அழைப்பு செய்யும் திறன்) மற்றும் நிச்சயமாக உள்ளே எதையும் உடைக்க மாட்டார். நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்