ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లేదా OOP లు అని పిలుస్తారు, ఇది జావా యొక్క ప్రధాన స్తంభాలలో ఒకటి, దాని శక్తిని మరియు వాడుకలో సౌలభ్యాన్ని పెంచింది. ప్రొఫెషనల్ జావా డెవలపర్ కావడానికి, మీరు వివిధ వాటిపై మచ్చలేని నియంత్రణను పొందాలి వంటి , సంగ్రహణ , ఎన్కప్సులేషన్ మరియు పాలిమార్ఫిజం. ఈ వ్యాసం యొక్క మాధ్యమం ద్వారా, OOP ల యొక్క అతి ముఖ్యమైన భావనలలో ఒకదాని గురించి మీకు పూర్తి అవగాహన ఇస్తాను, అంటే జావాలో ఎన్క్యాప్సులేషన్ మరియు అది ఎలా సాధించబడుతుంది.
క్రింద విషయాలు, నేను ఈ వ్యాసంలో చర్చిస్తాను:
- ఎన్కప్సులేషన్ పరిచయం
- జావాలో మనకు ఎన్క్యాప్సులేషన్ ఎందుకు అవసరం?
- ఎన్కప్సులేషన్ యొక్క ప్రయోజనాలు
- రియల్ టైమ్ ఉదాహరణ
మీరు ఈ రికార్డింగ్ ద్వారా కూడా వెళ్ళవచ్చు ఇక్కడ మీరు ఉదాహరణలతో విషయాలను వివరంగా అర్థం చేసుకోవచ్చు.
ఎన్కప్సులేషన్ పరిచయం
ఎన్కప్సులేషన్ అనేది ఒకే యూనిట్ క్రింద డేటాను చుట్టడం. ఇది కోడ్‌ను మరియు డేటాను తారుమారు చేసే విధానం. ఎన్కప్సులేషన్ గురించి ఆలోచించడానికి మరొక మార్గం ఏమిటంటే, ఇది రక్షణ కవచం, ఈ షీల్డ్ వెలుపల ఉన్న కోడ్ ద్వారా డేటాను యాక్సెస్ చేయకుండా నిరోధిస్తుంది. దీనిలో, a యొక్క వేరియబుల్స్ లేదా డేటా ఏ ఇతర తరగతి నుండి దాచబడింది మరియు వారు ప్రకటించిన సొంత తరగతి యొక్క ఏదైనా సభ్యుల ఫంక్షన్ ద్వారా మాత్రమే యాక్సెస్ చేయవచ్చు.
ఇప్పుడు, క్యాప్సూల్ లోపల always షధం ఎల్లప్పుడూ సురక్షితంగా ఉండే మెడికల్ క్యాప్సూల్ యొక్క ఉదాహరణను తీసుకుందాం. అదేవిధంగా, ఎన్కప్సులేషన్ ద్వారా, ఒక తరగతి యొక్క పద్ధతులు మరియు వేరియబుల్స్ బాగా దాచబడతాయి మరియు సురక్షితంగా ఉంటాయి.
జావాలో ఎన్కప్సులేషన్ వీటిని సాధించవచ్చు:
ఈ రోజు వరకు జావా పార్స్ స్ట్రింగ్
- తరగతి యొక్క వేరియబుల్స్ ప్రైవేట్ అని ప్రకటించడం.
- వేరియబుల్స్ విలువలను సవరించడానికి మరియు వీక్షించడానికి పబ్లిక్ సెట్టర్ మరియు గెట్టర్ పద్ధతులను అందించడం.
ఇప్పుడు, ఎన్కప్సులేషన్ గురించి బాగా అర్థం చేసుకోవడానికి కోడ్‌ను చూద్దాం:
పబ్లిక్ క్లాస్ స్టూడెంట్ {ప్రైవేట్ స్ట్రింగ్ పేరు పబ్లిక్ స్ట్రింగ్ getName () {తిరిగి పేరు} పబ్లిక్ శూన్య సెట్‌నేమ్ (స్ట్రింగ్ పేరు) {this.name = name}} క్లాస్ టెస్ట్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {విద్యార్థి s = కొత్త విద్యార్థి () s.setName ('హ్యారీ పాటర్') System.out.println (s.getName ())}} పై కోడ్‌లో మీరు చూడగలిగినట్లుగా, నేను క్లాస్ స్టూడెంట్‌ను సృష్టించాను, అది ప్రైవేట్గా ఉంది పేరు . తరువాత, నేను ఒక విద్యార్థి పేరును పొందడానికి మరియు సెట్ చేయడానికి ఒక గెట్టర్ మరియు సెట్టర్‌ను సృష్టించాను. ఈ పద్ధతుల సహాయంతో, పేరు వేరియబుల్‌ను యాక్సెస్ చేయాలనుకునే ఏ తరగతి అయినా ఈ గెట్టర్ మరియు సెట్టర్ పద్ధతులను ఉపయోగించి చేయాలి.
ఇప్పుడు మరో ఉదాహరణ చూద్దాం మరియు ఎన్‌క్యాప్సులేషన్‌ను లోతుగా అర్థం చేసుకుందాం. ఈ ఉదాహరణలో, కార్ తరగతికి రెండు ఫీల్డ్‌లు ఉన్నాయి-పేరు మరియు టాప్‌స్పీడ్. ఇక్కడ, రెండింటినీ ప్రైవేట్గా ప్రకటిస్తారు, అంటే వాటిని తరగతి వెలుపల నేరుగా యాక్సెస్ చేయలేరు. GetName, setName, setTopSpeed మొదలైన కొన్ని గెట్టర్ మరియు సెట్టర్ పద్ధతులు మాకు ఉన్నాయి మరియు అవి పబ్లిక్‌గా ప్రకటించబడ్డాయి. ఈ పద్ధతులు “బయటివారికి” గురవుతాయి మరియు కార్ ఆబ్జెక్ట్ నుండి డేటాను మార్చడానికి మరియు తిరిగి పొందటానికి ఉపయోగించవచ్చు. వాహనం యొక్క అగ్ర వేగాన్ని సెట్ చేయడానికి మాకు ఒక పద్ధతి మరియు MPH లేదా KMHt లో గరిష్ట వేగం విలువను తిరిగి పొందడానికి రెండు గెట్టర్ పద్ధతులు ఉన్నాయి. కాబట్టి ప్రాథమికంగా, ఇది ఎన్కప్సులేషన్ చేస్తుంది - ఇది అమలును దాచిపెడుతుంది మరియు మనకు కావలసిన విలువలను ఇస్తుంది. ఇప్పుడు, దిగువ కోడ్‌ను చూద్దాం.
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ కార్ {ప్రైవేట్ స్ట్రింగ్ పేరు ప్రైవేట్ డబుల్ టాప్‌స్పీడ్ పబ్లిక్ కార్ ()}} పబ్లిక్ స్ట్రింగ్ గెట్‌నేమ్ () {తిరిగి పేరు} పబ్లిక్ శూన్య సెట్‌నేమ్ (స్ట్రింగ్ పేరు) {this.name = name} పబ్లిక్ శూన్య సెట్టాప్స్పీడ్ (డబుల్ స్పీడ్ఎంపిహెచ్) {టాప్‌స్పీడ్ = speedMPH} పబ్లిక్ డబుల్ getTopSpeedMPH () {రిటర్న్ టాప్‌స్పీడ్} పబ్లిక్ డబుల్ getTopSpeedKMH () {రిటర్న్ టాప్‌స్పీడ్ * 1.609344}}ఇక్కడ, ప్రధాన ప్రోగ్రామ్ ఇచ్చిన పేరుతో కార్ ఆబ్జెక్ట్‌ను సృష్టిస్తుంది మరియు ఈ ఉదాహరణ కోసం అగ్ర వేగాన్ని నిల్వ చేయడానికి సెట్టర్ పద్ధతిని ఉపయోగిస్తుంది. ఇలా చేయడం ద్వారా, కార్ క్లాస్‌లో వేగం ఎలా మార్చబడుతుందనే దాని గురించి పట్టించుకోకుండా MPH లేదా KMH లో వేగాన్ని సులభంగా పొందవచ్చు.
ప్యాకేజీ ఎడురేకా పబ్లిక్ క్లాస్ ఉదాహరణ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) కార్ కార్ = కొత్త కార్ () కార్.సెట్నామ్ ('ముస్తాంగ్ జిటి 4.8-లీటర్ వి 8') కార్.సెట్టాప్స్పీడ్ (201) సిస్టమ్.అవుట్.ప్రింట్ల్న్ (కారు. getName () + 'MPH లో అగ్ర వేగం' + car.getTopSpeedMPH ()) System.out.println (car.getName () + 'KMH లో అగ్ర వేగం' + car.getTopSpeedKMH ())ఎస్o, జావాలో ఎన్క్యాప్సులేషన్ ఈ విధంగా సాధించవచ్చు. ఇప్పుడు, మరింత ముందుకు వెళ్దాం మరియు మనకు ఎన్క్యాప్సులేషన్ ఎందుకు అవసరమో చూద్దాం.
c ++ క్రమ శ్రేణి
జావాలో మనకు ఎన్క్యాప్సులేషన్ ఎందుకు అవసరం?
జావాలో ఎన్కప్సులేషన్ అవసరం ఎందుకంటే:
- ఇది డేటా ప్రాప్యత మార్గాన్ని నియంత్రిస్తుంది
- అవసరాల ఆధారంగా కోడ్‌ను సవరిస్తుంది
- వదులుగా ఉన్న జంటను సాధించడానికి మాకు సహాయపడుతుంది
- మా అప్లికేషన్ యొక్క సరళతను సాధిస్తుంది
- ప్రోగ్రామ్‌లో ఉన్న ఇతర ఫంక్షన్లకు లేదా కోడ్‌కు అంతరాయం కలిగించకుండా కోడ్ యొక్క భాగాన్ని మార్చడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది
ఇప్పుడు, ఎన్కప్సులేషన్ అవసరాన్ని వివరించే ఒక చిన్న ఉదాహరణను పరిశీలిద్దాం.
తరగతి విద్యార్థి {int id స్ట్రింగ్ పేరు} పబ్లిక్ క్లాస్ డెమో {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {విద్యార్థి s = కొత్త విద్యార్థి () s.id = 0 s.name = 's.name = శూన్య}}పై ఉదాహరణలో, ఇది యాక్సెస్ మాడిఫైయర్ వలె రెండు ఉదాహరణ వేరియబుల్స్ కలిగి ఉంది. కాబట్టి ఒకే ప్యాకేజీలోని ఏ తరగతి అయినా ఆ తరగతి యొక్క వస్తువును సృష్టించడం ద్వారా ఆ వేరియబుల్స్ యొక్క విలువలను కేటాయించవచ్చు మరియు మార్చవచ్చు. అందువల్ల, విద్యార్థి తరగతిలో నిల్వ చేయబడిన విలువలపై వేరియబుల్స్‌గా మాకు నియంత్రణ లేదు. ఈ సమస్యను పరిష్కరించడానికి, మేము విద్యార్థి తరగతిని చుట్టుముట్టాము.
కాబట్టి, ఎన్క్యాప్సులేషన్ యొక్క అవసరాన్ని వర్ణించే కొన్ని పాయింటర్లు ఇవి. ఇప్పుడు, ఎన్కప్సులేషన్ యొక్క కొన్ని ప్రయోజనాలను చూద్దాం.
ఎన్కప్సులేషన్ యొక్క ప్రయోజనాలు
- డేటా దాచడం: ఇక్కడ, తరగతి యొక్క అంతర్గత అమలు గురించి వినియోగదారుకు తెలియదు. తరగతి వేరియబుల్స్లో విలువలను ఎలా నిల్వ చేస్తుందో వినియోగదారుకు కూడా తెలియదు. మేము విలువలను సెట్టర్ పద్ధతికి పంపుతున్నామని మరియు ఆ విలువతో వేరియబుల్స్ ప్రారంభించబడుతున్నాయని అతనికి / ఆమెకు మాత్రమే తెలుసు.
- పెరిగిన వశ్యత: ఇక్కడ, మన అవసరాన్ని బట్టి తరగతి యొక్క వేరియబుల్స్ చదవడానికి-మాత్రమే లేదా వ్రాయడానికి మాత్రమే చేయవచ్చు. ఒకవేళ మీరు వేరియబుల్స్ ను రీడ్-ఓన్లీగా చేయాలనుకుంటే, అప్పుడు మేము సెట్ నేమ్ () వంటి సెట్టర్ పద్ధతులను వదిలివేయాలి,setAge() మొదలైనవి లేదా వేరియబుల్స్ ను రైట్-ఓన్లీగా చేయాలనుకుంటే, పై ప్రోగ్రామ్ నుండి getName (), getAge () వంటి గెట్ పద్ధతులను మనం వదిలివేయాలి.
- పునర్వినియోగం: ఇది తిరిగి వినియోగాన్ని మెరుగుపరుస్తుంది మరియు క్రొత్త అవసరాలతో మార్చడం సులభం.
ఇప్పుడు మేము ఎన్క్యాప్సులేషన్ యొక్క ప్రాథమికాలను అర్థం చేసుకున్నాము, ఈ వ్యాసం యొక్క చివరి అంశంలోకి ప్రవేశిద్దాం మరియు నిజ-సమయ ఉదాహరణ సహాయంతో ఎన్‌క్యాప్సులేషన్‌ను వివరంగా అర్థం చేసుకుందాం.
ఎన్కప్సులేషన్ యొక్క రియల్ టైమ్ ఉదాహరణ
టెలివిజన్ ఉదాహరణను పరిశీలిద్దాం మరియు అంతర్గత అమలు వివరాలు బయటి తరగతి నుండి ఎలా దాచబడుతున్నాయో అర్థం చేసుకుందాం.సాధారణంగా, ఈ ఉదాహరణలో, మేము అంతర్గత కోడ్ డేటాను దాచిపెడుతున్నాము, అనగా బాహ్య ప్రపంచం నుండి సర్క్యూట్లను కవర్ ద్వారా. ఇప్పుడు లోపలికి , యాక్సెస్ మాడిఫైయర్ల సహాయంతో దీనిని సాధించవచ్చు. యాక్సెస్ మాడిఫైయర్లు క్లాస్, కన్స్ట్రక్టర్స్ వేరియబుల్స్ మొదలైన వాటి యొక్క యాక్సెస్ లేదా స్థాయిని సెట్ చేస్తాయి. మీరు ఈ క్రింది కోడ్‌లో చూడగలిగినట్లుగా, క్లాస్ యొక్క యాక్సెస్ స్థాయిని పరిమితం చేయడానికి నేను ప్రైవేట్ యాక్సెస్ మాడిఫైయర్‌ను ఉపయోగించాను. ప్రైవేట్గా ప్రకటించిన వేరియబుల్స్ టెలివిజన్ తరగతిలో మాత్రమే అందుబాటులో ఉంటాయి.
పబ్లిక్ క్లాస్ టెలివిజన్ {ప్రైవేట్ డబుల్ వెడల్పు ప్రైవేట్ డబుల్ ఎత్తు ప్రైవేట్ డబుల్ స్క్రీన్‌సైజ్ ప్రైవేట్ ఇంట్ మాక్స్వాల్యూమ్ ప్రింట్ ఇంటెంట్ వాల్యూమ్ ప్రైవేట్ బూలియన్ పవర్ పబ్లిక్ టెలివిజన్ (డబుల్ వెడల్పు, డబుల్ ఎత్తు, డబుల్ స్క్రీన్‌సైజ్) {this.width this.height this.sightSize = ScreenSize} public double channelTuning . void main (స్ట్రింగ్ అర్గ్స్ []) {టెలివిజన్ t = కొత్త టెలివిజన్ (11.5,7,9) t.powerSwitch () t.channelTuning (2) t.decreaseVolume () t.increaseVolume () టెలివిజన్. // వేరియబుల్ ప్రైవేట్ అయినందున లోపం విసురుతుంది మరియు తరగతి వెలుపల యాక్సెస్ చేయబడదు}}పై ఉదాహరణలో, నేను అన్ని వేరియబుల్స్ను ప్రైవేట్ మరియు పద్ధతులు, కన్స్ట్రక్టర్లు మరియు క్లాస్ పబ్లిక్ గా ప్రకటించాను. ఇక్కడ, కన్స్ట్రక్టర్లు, పద్ధతులను తరగతి వెలుపల యాక్సెస్ చేయవచ్చు. నేను సృష్టించినప్పుడుఒక వస్తువుటెలివిజన్ క్లాస్ యొక్క, ఇది తరగతిలో ఉన్న పద్ధతులు మరియు కన్స్ట్రక్టర్లను యాక్సెస్ చేయగలదు, అయితే ప్రైవేట్ యాక్సెస్ మాడిఫైయర్‌తో ప్రకటించిన వేరియబుల్స్ దాచబడతాయి. అందుకే మీరు ప్రాప్యత చేయడానికి ప్రయత్నించినప్పుడు వెడల్పు వేరియబుల్ పై ఉదాహరణలో, అది విసురుతుందిలోపం. అంతర్గత అమలు వివరాలు ఇతర తరగతుల నుండి దాచబడతాయి. జావాలో ఎన్క్యాప్సులేషన్ ఈ విధంగా సాధించబడుతుంది.
ఇది “జావాలో ఎన్క్యాప్సులేషన్” పై ఈ వ్యాసం చివర మనలను తీసుకువస్తుంది. ఆశిస్తున్నాము, మీరు దానిని సమాచారంగా కనుగొన్నారు మరియు ఇది మీ జ్ఞానానికి విలువను జోడించడంలో సహాయపడింది. మీరు జావా గురించి మరింత తెలుసుకోవాలనుకుంటే, మీరు వీటిని చూడవచ్చు
జావాలో ప్యాకేజీల వాడకం
ఇప్పుడు మీరు “జావాలో ఎన్క్యాప్సులేషన్ అంటే ఏమిటి” అని అర్థం చేసుకున్నారు, చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలో ఎన్క్యాప్సులేషన్” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.