ఎన్కప్సులేషన్ సూత్రాలు

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

public class Auto {

   public void go() {

       /* Some complicated things happen inside the car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside the car.
       As a result, it slows down. */
   }

   public static void main(String[] args) {

       Auto auto = new Auto();

       // From the user's perspective,

       // one pedal is pressed and the car accelerates.
       auto.gas();
      
       // The other is pressed, and the car slows down.
       auto.brake();
   }
}

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

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!");
   }

  
}

చివరి పాఠం నుండి ఈ తరగతికి సంబంధించిన సమస్య మీకు గుర్తుందా? కాకపోతే ఇప్పుడు గుర్తు చేసుకుందాం. సమస్య ఏమిటంటే దాని డేటా (ఫీల్డ్‌లు) అందరికీ తెరిచి ఉంటుంది - మరొక ప్రోగ్రామర్ 0 బరువు మరియు -1000 సంవత్సరాల వయస్సుతో పేరులేని పిల్లిని సులభంగా సృష్టించవచ్చు:

public static void main(String[] args) {

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

}

మీ సహోద్యోగుల్లో ఒకరు చెల్లని స్థితితో వస్తువులను సృష్టించారా లేదా అనే దానిపై మీరు నిశితంగా గమనించవచ్చు, కానీ అలాంటి "చెల్లని వస్తువులను" సృష్టించే అవకాశాన్ని కూడా మినహాయించడం చాలా మంచిది. కింది మెకానిజమ్‌లు డేటా దాచడాన్ని సాధించడంలో మాకు సహాయపడతాయి:

1. యాక్సెస్ మాడిఫైయర్‌లు ( ప్రైవేట్ , ప్రొటెక్టెడ్ , ప్యాకేజీ డిఫాల్ట్ )
2. పొందేవారు మరియు సెట్టర్లు

ఉదాహరణకు, ఎవరైనా పిల్లి వయస్సుకి ప్రతికూల సంఖ్యను కేటాయించడానికి ప్రయత్నిస్తున్నారా అని చూడటానికి మేము అక్కడ చెక్ పెట్టవచ్చు. మేము ఇంతకు ముందే చెప్పినట్లుగా, ఎన్‌క్యాప్సులేషన్ గురించి వివిధ కథనాల రచయితలు కొన్నిసార్లు డేటా మరియు పద్ధతులను కలపడం లేదా వాటిని దాచడం లేదా రెండింటినీ (వాటిని కలపడం మరియు దాచడం) అని అర్థం. జావా రెండు మెకానిజమ్‌లను కలిగి ఉంది (ఇతర OOP భాషలకు ఇది తప్పనిసరిగా నిజం కాదు), కాబట్టి చివరి అర్థం చాలా సరైనది. ఎన్‌క్యాప్సులేషన్ మనకు అనేక ముఖ్యమైన ప్రయోజనాలను అందిస్తుంది:

1. వస్తువు యొక్క సరైన స్థితిపై నియంత్రణ. పైన దీనికి ఉదాహరణలు ఉన్నాయి. సెట్టర్ మరియు ప్రైవేట్ మాడిఫైయర్ మా ప్రోగ్రామ్‌లో 0 బరువు ఉన్న పిల్లులు ఉండవని నిర్ధారిస్తాయి.


2. ఇంటర్‌ఫేస్ ద్వారా వినియోగదారు-స్నేహపూర్వకత. కేవలం పద్ధతులు మాత్రమే బయటి ప్రపంచానికి "బహిర్గతం" అవుతాయి. ఫలితాన్ని పొందడానికి కాలింగ్ పద్ధతులు సరిపోతాయి - అవి ఎలా పని చేస్తాయి అనే వివరాలను లోతుగా పరిశోధించాల్సిన అవసరం లేదు.


3. కోడ్ మార్పులు వినియోగదారులను ప్రభావితం చేయవు. మేము పద్ధతుల్లో ఏవైనా మరియు అన్ని మార్పులను చేస్తాము. ఇది పద్ధతి యొక్క వినియోగదారుని ప్రభావితం చేయదు: గ్యాస్ పెడల్‌ను వర్తింపజేయడానికి సరైన కోడ్ గతంలో "auto.gas()" అయితే, అది అలాగే కొనసాగుతుంది. మేము గ్యాస్ () పద్ధతిలో ఏదైనా మార్చాము అనే వాస్తవం వినియోగదారుకు కనిపించదు: మునుపటిలా, కాలర్ కోరుకున్న ఫలితాన్ని అందుకుంటారు.