వారసత్వం మరియు పాలిమార్ఫిజం మధ్య వ్యత్యాసం
విషయము
వారసత్వం అనుమతిస్తుంది, కోడ్ పునర్వినియోగం మరియు పాలిమార్ఫిజం, వివిధ రూపాలతో ఒక ఫంక్షన్ సంభవించడం. వారసత్వం మరియు పాలిమార్ఫిజం మధ్య ఉన్న ప్రాథమిక వ్యత్యాసం ఏమిటంటే, వారసత్వం ఇప్పటికే ఉన్న కోడ్‌ను ఒక ప్రోగ్రామ్‌లో మళ్లీ తిరిగి ఉపయోగించుకోవడానికి అనుమతిస్తుంది, మరియు పాలిమార్ఫిజం ఏ విధమైన ఫంక్షన్‌ను ప్రారంభించాలో డైనమిక్‌గా నిర్ణయించే యంత్రాంగాన్ని అందిస్తుంది.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- ముగింపు
పోలిక చార్ట్
| పోలిక కోసం ఆధారం | ఇన్హెరిటెన్స్ | పాలీ మార్ఫిజం |
|---|---|---|
| ప్రాథమిక | ఇప్పటికే ఉన్న తరగతి లక్షణాలను ఉపయోగించి వారసత్వం క్రొత్త తరగతిని సృష్టిస్తోంది. | పాలిమార్ఫిజం ప్రాథమికంగా బహుళ రూపానికి ఒక సాధారణ ఇంటర్ఫేస్. |
| అమలు | వారసత్వం ప్రాథమికంగా తరగతులపై అమలు చేయబడుతుంది. | పాలిమార్ఫిజం ప్రాథమికంగా ఫంక్షన్ / పద్ధతులపై అమలు చేయబడుతుంది. |
| వా డు | OOP లో పునర్వినియోగ భావనకు మద్దతు ఇవ్వడానికి మరియు కోడ్ యొక్క పొడవును తగ్గిస్తుంది. | కంపైల్ సమయంలో (ఓవర్‌లోడింగ్) అలాగే రన్ టైమ్ (ఓవర్రైడింగ్) చేసినప్పుడు ఏ విధమైన ఫంక్షన్‌ను ప్రారంభించాలో నిర్ణయించడానికి ఆబ్జెక్ట్‌ను అనుమతిస్తుంది. |
| పత్రాలు | వారసత్వం ఒకే వారసత్వం, బహుళ వారసత్వం, బహుళస్థాయి వారసత్వం, క్రమానుగత వారసత్వం మరియు హైబ్రిడ్ వారసత్వం కావచ్చు. | పాలిమార్ఫిజం కంపైల్ టైమ్ పాలిమార్ఫిజం (ఓవర్‌లోడింగ్) లేదా రన్-టైమ్ పాలిమార్ఫిజం (ఓవర్రైడింగ్) కావచ్చు. |
| ఉదాహరణ | క్లాస్ టేబుల్ క్లాస్ ఫర్నిచర్ యొక్క లక్షణాన్ని వారసత్వంగా పొందగలదు, ఎందుకంటే టేబుల్ ఫర్నిచర్. | క్లాస్ స్టడీ_టేబుల్ ఫంక్షన్ సెట్_కలర్ () ను కలిగి ఉంటుంది మరియు క్లాస్ డైనింగ్_టేబుల్ ఫంక్షన్ సెట్_ కలర్ () ను కూడా కలిగి ఉంటుంది, కాబట్టి, ఏ సెట్_కలర్ () ఫంక్షన్‌ను ఇన్వోక్ చేయాలో రెండింటిలోనూ నిర్ణయించవచ్చు, కంపైల్ సమయం మరియు రన్ టైమ్. |
వారసత్వ నిర్వచనం:
OOP యొక్క కీలకమైన లక్షణాలలో వారసత్వం ఒకటి, ఇది “పునర్వినియోగతకు” గట్టిగా మద్దతు ఇస్తుంది. పునర్వినియోగతను ప్రస్తుత తరగతి యొక్క లక్షణాలను తిరిగి ఉపయోగించడం ద్వారా క్రొత్త తరగతిని సృష్టించినట్లు వర్ణించవచ్చు. వారసత్వంగా, ఒక బేస్ క్లాస్ ఉంది, ఇది ఉత్పన్నమైన తరగతి వారసత్వంగా వస్తుంది. ఒక తరగతి ఏ ఇతర తరగతిని వారసత్వంగా పొందినప్పుడు, బేస్ క్లాస్ యొక్క సభ్యుడు (లు) ఉత్పన్నమైన తరగతి యొక్క సభ్యుడు (లు) అవుతారు.
తరగతిని వారసత్వంగా పొందే సాధారణ రూపం క్రింది విధంగా ఉంటుంది:
తరగతి ఉత్పన్న-తరగతి-పేరు: యాక్సెస్-స్పెసిఫైయర్ బేస్-క్లాస్-పేరు {// తరగతి యొక్క శరీరం};
ఇక్కడ, యాక్సెస్ స్పెసిఫైయర్ బేస్ క్లాస్‌లోని సభ్యులకు (ల) ఉత్పన్నమైన తరగతికి యాక్సెస్ మోడ్ (ప్రైవేట్, పబ్లిక్, ప్రొటెక్టెడ్) ను అందిస్తుంది. యాక్సెస్ స్పెసిఫైయర్ లేకపోతే, అప్రమేయంగా, ఇది “ప్రైవేట్” గా పరిగణించబడుతుంది. C ++ లో, ఉత్పన్నమైన తరగతి “struct” అయితే యాక్సెస్ స్పెసిఫైయర్ అప్రమేయంగా “పబ్లిక్”.
సి ++ లో, వారసత్వాన్ని ఐదు రూపాల్లో సాధించవచ్చు. వాటిని ఇలా వర్గీకరించవచ్చు: -
- సింగిల్ ఇన్హెరిటెన్స్ (ఒకే ఒక సూపర్ క్లాస్)
- బహుళ వారసత్వం (అనేక సూపర్ క్లాసులు)
- క్రమానుగత వారసత్వం (ఒక సూపర్ క్లాస్, చాలా ఉపవర్గాలు)
- బహుళ వారసత్వం (ఉత్పన్నమైన తరగతి నుండి తీసుకోబడింది)
జావాలో, తరగతి “విస్తరిస్తుంది” అనే కీవర్డ్‌ని ఉపయోగించి ఇతర తరగతిని వారసత్వంగా పొందుతుంది. జావాలో, బేస్ క్లాస్ ను సూపర్ క్లాస్ గా సూచిస్తారు, మరియు ఉత్పన్నమైన క్లాస్ ను సబ్ క్లాస్ గా సూచిస్తారు. ఉపవర్గం బేస్ క్లాస్ యొక్క సభ్యులను యాక్సెస్ చేయదు, అవి “ప్రైవేట్” గా ప్రకటించబడతాయి. జావాలో తరగతిని వారసత్వంగా పొందిన సాధారణ రూపం క్రింది విధంగా ఉంటుంది.
తరగతి ఉత్పన్న-తరగతి-పేరు బేస్-క్లాస్-పేరు s // తరగతి యొక్క శరీరాన్ని విస్తరిస్తుంది};
బహుళ వారసత్వ వారసత్వానికి జావా మద్దతు ఇవ్వదు, అయితే ఇది బహుళస్థాయి సోపానక్రమానికి మద్దతు ఇస్తుంది. జావాలో, కొన్నిసార్లు ఒక సూపర్ క్లాస్ దాని అమలు వివరాలను దాచాలనుకోవచ్చు మరియు అది ఆ డేటాలో కొంత భాగాన్ని “ప్రైవేట్” గా చేస్తుంది. జావాలో వలె, ఒక సబ్ క్లాస్ సూపర్ క్లాస్ యొక్క ప్రైవేట్ సభ్యులను యాక్సెస్ చేయదు మరియు ఒక సబ్ క్లాస్ ఆ సభ్యులను యాక్సెస్ చేయాలనుకుంటే లేదా ప్రారంభించాలనుకుంటే, జావా ఒక పరిష్కారాన్ని అందిస్తుంది. “సూపర్” అనే కీవర్డ్‌ని ఉపయోగించడం ద్వారా సబ్‌క్లాస్ దాని తక్షణ సూపర్ క్లాస్ సభ్యులను సూచించవచ్చు. గుర్తుంచుకోండి, మీరు తక్షణ సూపర్ క్లాస్ సభ్యులను మాత్రమే యాక్సెస్ చేయవచ్చు.
‘సూపర్’ రెండు సాధారణ రూపాలను కలిగి ఉంది. మొదటిది, ఇది సూపర్ క్లాస్ యొక్క కన్స్ట్రక్టర్ను పిలవడానికి ఉపయోగిస్తుంది. రెండవది, సబ్‌క్లాస్ సభ్యుడు దాచిన సూపర్ క్లాస్ సభ్యుడిని యాక్సెస్ చేయడం.
// కన్స్ట్రక్టర్ను పిలిచే మొదటి రూపం. తరగతి supper_class {supper_class (ఆర్గ్యుమెంట్_లిస్ట్) {.. super // సూపర్ క్లాస్ యొక్క కన్స్ట్రక్టర్}; క్లాస్ సబ్_క్లాస్ సప్పర్_క్లాస్ {సబ్_క్లాస్ (ఆర్గ్యుమెంట్_లిస్ట్) {..} // సబ్_క్లాస్ సూపర్ (ఆర్గ్యుమెంట్_లిస్ట్) యొక్క కన్స్ట్రక్టర్; // సబ్ క్లాస్ సూపర్ క్లాస్ యొక్క కన్స్ట్రక్టర్ను పిలుస్తుంది}};
సూపర్ క్లాస్ సప్పర్_క్లాస్ యొక్క // సెకను {int i; } క్లాస్ సబ్_క్లాస్ సప్పర్_క్లాస్‌ను విస్తరిస్తుంది {int i; sub_class (int a, int b) {super.i = a; సూపర్ క్లాస్ యొక్క // నేను i = బి; // నేను సబ్ క్లాస్}};
పాలిమార్ఫిజం యొక్క నిర్వచనం
పాలిమార్ఫిజం అనే పదానికి ‘ఒక ఫంక్షన్, బహుళ రూపాలు’ అని అర్ధం. కంపైల్ సమయం మరియు రన్ సమయం రెండింటిలోనూ పాలిమార్ఫిజం సాధించబడుతుంది. కంపైల్ టైమ్ పాలిమార్ఫిజం “ఓవర్‌లోడింగ్” ద్వారా సాధించబడుతుంది, అయితే రన్ టైమ్ పాలిమార్ఫిజం “ఓవర్రైడింగ్” ద్వారా సాధించబడుతుంది.
రెండింటి వద్ద, సమయాన్ని కంపైల్ చేసి, రన్ చేసే సమయాన్ని “ఏ విధమైన ఫంక్షన్‌ను ప్రారంభించాలో” నిర్ణయించడానికి పాలిమార్ఫిజం వస్తువును అనుమతిస్తుంది.
ఓవర్‌లోడింగ్ యొక్క మొదటి భావన గురించి చర్చిద్దాం. ఓవర్‌లోడింగ్‌లో, క్లాస్‌లో ఒక ఫంక్షన్‌ను ఒకటి కంటే ఎక్కువ సార్లు వేర్వేరు, డేటా రకం మరియు పారామితుల సంఖ్యతో నిర్వచించాము, అయితే ఓవర్లోడ్ చేయాల్సిన ఫంక్షన్ ఒకే రిటర్న్ రకాన్ని కలిగి ఉండాలి. ఓవర్లోడ్ చేయబడిన విధులు చాలా సార్లు తరగతి యొక్క కన్స్ట్రక్టర్లు.
తరగతి ఓవర్లోడ్ {int a, b; పబ్లిక్: int ఓవర్లోడ్ (int x) {// మొదటి ఓవర్లోడ్ () కన్స్ట్రక్టర్ a = x; తిరిగి a; } int ఓవర్లోడ్ (int x, int y) second // రెండవ ఓవర్లోడ్ () కన్స్ట్రక్టర్ a = x; బి = y; return a * b; }}; int main () {ఓవర్లోడ్ O1; O1.overload (20); // మొదటి ఓవర్లోడ్ () కన్స్ట్రక్టర్ కాల్ O1.overload (20,40); // రెండవ ఓవర్లోడ్ () కన్స్ట్రక్టర్ కాల్}
ఇప్పుడు, పాలిమార్ఫిజం యొక్క రెండవ రూపాన్ని చర్చిద్దాం, అనగా భర్తీ చేయడం. ఓవర్రైడింగ్ భావన తరగతుల పనితీరుకు మాత్రమే అమలు చేయబడుతుంది, ఇది వారసత్వ భావనను కూడా అమలు చేస్తుంది. C ++ లో, ఓవర్‌రైడ్ చేయవలసిన ఫంక్షన్ బేస్ క్లాస్‌లో “వర్చువల్” అనే కీవర్డ్‌తో ముందే ఉంటుంది మరియు “వర్చువల్” అనే కీవర్డ్ మినహా అదే ప్రోటోటైప్‌తో ఉత్పన్నమైన క్లాస్‌లో పునర్నిర్వచించబడింది.
క్లాస్ బేస్ {పబ్లిక్: వర్చువల్ శూన్య ఫంక్ట్ () base // బేస్ క్లాస్ కౌట్ యొక్క వర్చువల్ ఫంక్షన్ << "ఇది బేస్ క్లాస్ ఫంక్ట్ ()"; }}; తరగతి ఉత్పన్నం 1: పబ్లిక్ బేస్ {పబ్లిక్: శూన్య ఫంక్ట్ () {// బేస్ క్లాస్ యొక్క వర్చువల్ ఫంక్షన్ ఉత్పన్న 1 క్లాస్ కౌట్‌లో పునర్నిర్వచించబడింది << "ఇది ఉత్పన్న 1 తరగతుల ఫంక్షన్ ()"; }}; int main () {base * p, b; ఉత్పన్నం 1 డి 1; * P = & బి; P-> funct (); // బేస్ క్లాస్ ఫంక్ట్ () కు కాల్ చేయండి. * P = & d1; తిరిగి 0; }
- ఇప్పటికే ఉన్న తరగతి నుండి దాని లక్షణాన్ని పొందిన తరగతిని వారసత్వం సృష్టిస్తోంది. మరోవైపు, పాలిమార్ఫిజం అనేది బహుళ రూపాల్లో నిర్వచించగల ఇంటర్ఫేస్.
- తరగతులపై వారసత్వం అమలు చేయబడుతుంది, అయితే పాలిమార్ఫిజం పద్ధతులు / విధులపై అమలు చేయబడుతుంది.
- వారసత్వం ఒక ఉత్పన్న తరగతిని మూల తరగతిలో నిర్వచించిన మూలకాలను మరియు పద్ధతులను ఉపయోగించడానికి అనుమతిస్తుంది కాబట్టి, ఉత్పన్నమైన తరగతికి ఆ అంశాలను నిర్వచించాల్సిన అవసరం లేదు లేదా దాన్ని మళ్లీ పద్దతి చేయాల్సిన అవసరం లేదు, కాబట్టి ఇది కోడ్ పునర్వినియోగతను పెంచుతుందని మేము చెప్పగలం మరియు అందువల్ల కోడ్ యొక్క పొడవును తగ్గిస్తుంది . మరోవైపు, కంపైల్ సమయం మరియు రన్ టైమ్ రెండింటిలోనూ ఒక వస్తువు ఏ విధమైన పద్ధతిని అమలు చేయాలనుకుంటుందో నిర్ణయించడానికి పాలిమార్ఫిజం సాధ్యపడుతుంది.
- వారసత్వాన్ని ఒకే వారసత్వం, బహుళ వారసత్వం, బహుళస్థాయి వారసత్వం, క్రమానుగత వారసత్వం మరియు హైబ్రిడ్ వారసత్వం అని వర్గీకరించవచ్చు. మరోవైపు, పాలిమార్ఫిజం ఓవర్‌లోడింగ్ మరియు ఓవర్రైడింగ్ అని వర్గీకరించబడింది.
ముగింపు:
వారసత్వ భావనను అమలుచేసే తరగతులకు డైనమిక్ పాలిమార్ఫిజం వర్తిస్తుంది కాబట్టి, వారసత్వం మరియు పాలిమార్ఫిజం పరస్పర సంబంధం ఉన్న అంశాలు.
