జావాలో ఎన్‌క్యాప్సులేషన్

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

ఇప్పుడు సమాచారాన్ని దాచడం గురించి మాట్లాడుకుందాం

అన్ని రకాల సంక్లిష్టమైన మెకానిజమ్‌లు ఎలా నిర్మించబడ్డాయో లేదా అవి ఎలా పని చేస్తాయో అర్థం చేసుకోకుండా వాటిని ఎలా ఉపయోగిస్తాము? ఇది చాలా సులభం: వాటి సృష్టికర్తలు సరళమైన మరియు అనుకూలమైన ఇంటర్‌ఫేస్‌లను అందించారు. సోడా మెషీన్‌లో, ఇంటర్‌ఫేస్ ముందు ప్యానెల్‌లోని బటన్లు. ఒక బటన్ కప్పు పరిమాణాన్ని ఎంచుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు రెండవ బటన్‌తో సిరప్‌ని ఎంచుకోండి. మూడవది మంచును జోడించడానికి బాధ్యత వహిస్తుంది. మరియు మీరు చేయాల్సిందల్లా. యంత్రం లోపల ఎలా ఉంటుందో పట్టింపు లేదు. ముఖ్యమైన విషయం ఏమిటంటే, వినియోగదారు మూడు బటన్లను నొక్కడం ద్వారా సోడా పొందేలా ఇది రూపొందించబడింది. అదే విషయం కారుకు వర్తిస్తుంది. లోపల ఏమి జరుగుతుందో పట్టింపు లేదు. ముఖ్యమైన విషయం ఏమిటంటే, మీరు కుడి పెడల్‌ను నొక్కినప్పుడు కారు ముందుకు కదులుతుంది మరియు మీరు ఎడమ పెడల్‌ను నొక్కినప్పుడు కారు వేగాన్ని తగ్గిస్తుంది. ఇది సమాచారాన్ని దాచడం యొక్క సారాంశం. అంతా ఒక కార్యక్రమం' s 'innards' వినియోగదారు నుండి దాచబడ్డాయి. అటువంటి సమాచారం వినియోగదారుకు అనవసరమైనది లేదా అనవసరమైనది. వినియోగదారుకు అంతిమ ఫలితం అవసరం, అంతర్గత ప్రక్రియ కాదు. ఒక ఉదాహరణ కోసం, దానిని పరిశీలిద్దాంవాహన తరగతి:

public class Vehicle {

   public void gas() {

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

   public void brake() {

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

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

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

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. కోడ్ మార్పులు వినియోగదారులను ప్రభావితం చేయవు. మేము పద్ధతుల్లో అన్ని మార్పులను చేస్తాము. ఇది వినియోగదారులను ప్రభావితం చేయదు: వారు గ్యాస్‌ను వర్తింపజేయడానికి వాహనం.గ్యాస్() అని వ్రాసారు మరియు వారు అదే పని చేస్తూ ఉంటారు. మేము గ్యాస్ () పద్ధతిలో ఏదైనా మార్చాము అనే వాస్తవం కనిపించదు: మునుపటిలా, అవి అవసరమైన ఫలితాన్ని పొందుతాయి.