గెట్టర్స్ మరియు సెట్టర్స్

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

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;
}

మీరు గమనిస్తే, అవి కూడా సరళమైనవి. మేము క్యాట్ ఆబ్జెక్ట్‌పై సెట్‌నేమ్() పద్ధతిని పిలుస్తాము , స్ట్రింగ్‌ను ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము మరియు స్ట్రింగ్ ఆబ్జెక్ట్ నేమ్ ఫీల్డ్‌కు కేటాయించబడుతుంది.

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!

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