విషయము

• పోలిక చార్ట్
• ఇంటర్ఫేస్ యొక్క నిర్వచనం
• వియుక్త తరగతి యొక్క నిర్వచనం
• ముగింపు:

ఇంటర్ఫేస్ మరియు వియుక్త తరగతి రెండూ OOP లో “అసంపూర్ణ రకానికి” దోహదం చేస్తాయి. కొన్నిసార్లు "ఏమి చేయాలో" నిర్వచించటానికి మాకు సూపర్ క్లాస్ అవసరం, కానీ "ఎలా చేయాలో" కాదు, ఇది ఎలా చేయాలో దాని నుండి ఉత్పన్న తరగతి దాని అవసరానికి అనుగుణంగా అమలు చేయబడుతుంది, "ఇంటర్ఫేస్”దీనికి ఒక పరిష్కారాన్ని అందించండి. కొన్నిసార్లు మనకు సూపర్ క్లాస్ క్లాస్ అవసరం, ఇది ఉత్పన్నమైన తరగతుల ద్వారా అమలు చేయగల కొన్ని సాధారణీకరించిన నిర్మాణాన్ని మరియు ఉత్పన్నమైన తరగతులచే ఉపయోగించబడే కొన్ని నిర్దిష్ట నిర్మాణాన్ని నిర్వచిస్తుంది, “నైరూప్య తరగతి”దీనికి ఒక పరిష్కారాన్ని అందిస్తుంది. ఇంటర్ఫేస్ మరియు నైరూప్య తరగతి మధ్య ప్రాథమిక వ్యత్యాసం ఏమిటంటే ఇంటర్ఫేస్ పూర్తిగా అసంపూర్ణంగా ఉంది మరియు నైరూప్య తరగతి పాక్షికంగా అసంపూర్ణంగా ఉంటుంది.

1. పోలిక చార్ట్
2. నిర్వచనం
3. కీ తేడాలు
4. ముగింపు

పోలిక చార్ట్

పోలిక కోసం ఆధారం	ఇంటర్ఫేస్	వియుక్త తరగతి
ప్రాథమిక	దాని అమలు గురించి కాకుండా అవసరాల పరిజ్ఞానం మీకు మాత్రమే ఉన్నప్పుడు, మీరు "ఇంటర్ఫేస్" ను ఉపయోగిస్తారు.	మీరు "వియుక్త తరగతులు" ఉపయోగించే అమలు గురించి పాక్షికంగా తెలుసుకున్నప్పుడు.
పద్ధతులు	ఇంటర్ఫేస్ నైరూప్య పద్ధతులను మాత్రమే కలిగి ఉంటుంది.	వియుక్త తరగతిలో నైరూప్య పద్ధతులు మరియు కాంక్రీట్ పద్ధతులు ఉన్నాయి.
పద్ధతుల యాక్సెస్ మాడిఫైయర్	ఇంటర్ఫేస్ పద్ధతులు ఎల్లప్పుడూ "పబ్లిక్" మరియు "వియుక్త", మేము ప్రకటించకపోయినా. అందువల్ల, దీనిని 100%, స్వచ్ఛమైన నైరూప్య తరగతి అని చెప్పవచ్చు.	నైరూప్య తరగతిలో పద్ధతి బహిరంగంగా మరియు నైరూప్యంగా ఉండటం తప్పనిసరి కాదు. ఇది కాంక్రీట్ పద్ధతులను కూడా కలిగి ఉంటుంది.
పద్ధతుల కోసం పరిమితం చేయబడిన మాడిఫైయర్	కింది మాడిఫైయర్లతో ఇంటర్ఫేస్ పద్ధతిని ప్రకటించలేము: పబ్లిక్: ప్రైవేట్ మరియు ప్రొటెక్టెడ్ వియుక్త: ఫైనల్, స్టాటిక్, సింక్రొనైజ్డ్, నేటివ్, స్ట్రిక్ట్ఫ్.	నైరూప్య తరగతి వేరియబుల్ యొక్క మాడిఫైయర్లపై ఎటువంటి పరిమితులు లేవు.
వేరియబుల్స్ యొక్క యాక్సెస్ మాడిఫైయర్	ఇంటర్ఫేస్ వేరియబుల్స్ కోసం అనుమతించబడిన యాక్సెస్ మాడిఫైయర్ పబ్లిక్, స్టాటిక్ & ఫైనల్, మేము ప్రకటిస్తున్నామో లేదో.	నైరూప్య తరగతిలో వేరియబుల్స్ పబ్లిక్, స్టాటిక్, ఫైనల్ కానవసరం లేదు.
వేరియబుల్స్ కోసం పరిమితం చేయబడిన మాడిఫైయర్లు	ఇంటర్ఫేస్ వేరియబుల్స్ ప్రైవేట్, రక్షిత, అస్థిరమైన, అస్థిరతగా ప్రకటించబడవు.	నైరూప్య తరగతి వేరియబుల్స్ యొక్క మాడిఫైయర్లపై ఎటువంటి పరిమితి లేదు.
వేరియబుల్స్ ప్రారంభించడం	ఇంటర్ఫేస్ వేరియబుల్స్ దాని డిక్లరేషన్ సమయంలో ప్రారంభించబడాలి.	నైరూప్య తరగతి వేరియబుల్స్ దాని డిక్లరేషన్ సమయంలో ప్రారంభించబడటం తప్పనిసరి కాదు.
ఉదాహరణ మరియు స్టాటిక్ బ్లాక్స్	ఇంటర్ఫేస్ లోపల, మీరు ఒక ఉదాహరణ లేదా స్టాటిక్ బ్లాక్‌ను ప్రకటించలేరు.	వియుక్త తరగతి దాని లోపల ఒక ఉదాహరణ లేదా స్టాటిక్ బ్లాక్‌ను అనుమతిస్తుంది.
తయారీదారుల	మీరు ఇంటర్ఫేస్ లోపల కన్స్ట్రక్టర్ను ప్రకటించలేరు.	మీరు వియుక్త తరగతి లోపల కన్స్ట్రక్టర్‌ను ప్రకటించవచ్చు.

ఇంటర్ఫేస్ యొక్క నిర్వచనం

బహుళ వారసత్వాన్ని జావా అనుమతించదు. అంటే, ఒకే తరగతి ఒకేసారి ఒకటి కంటే ఎక్కువ తరగతులను వారసత్వంగా పొందలేము. దీని వెనుక గల కారణాన్ని ఉదాహరణతో వివరించవచ్చు. మనకు రెండు పేరెంట్ క్లాస్, ఎ మరియు బి మరియు ఉత్పన్నమైన క్లాస్ సి ఉన్నాయని అనుకుందాం. ఉత్పన్నమైన క్లాస్ సి ఎ మరియు బి తరగతులను వారసత్వంగా పొందుతుంది.ఇప్పుడు, రెండింటికి క్లాస్ ఎ మరియు బి లకు పద్ధతి సెట్ () ఉంది, అప్పుడు క్లాస్ సి కి ఇది ఏ క్లాస్ సెట్ () పద్ధతి వారసత్వంగా ఉండాలి అనే ప్రశ్న అవుతుంది. ఈ సమస్యకు పరిష్కారం “ఇంటర్ఫేస్”.

ఇంటర్ఫేస్ స్వచ్ఛమైన నైరూప్య తరగతి. ఇంటర్ఫేస్ సృష్టించడానికి ఉపయోగించే కీవర్డ్ “ఇంటర్ఫేస్”. ఇంటర్ఫేస్ లోపల అన్ని పద్ధతి పూర్తిగా వియుక్తంగా ఉంటుంది. ఇంటర్ఫేస్ ఒక తరగతి ఏమి చేయాలో మాత్రమే నిర్దేశిస్తుంది కానీ, అది ఎలా చేస్తుందో అది నిర్వచించదు. ఇంటర్ఫేస్ లోపల ప్రకటించిన అన్ని పద్ధతులు నైరూప్యంగా ఉన్నందున, ఇంటర్ఫేస్ కోసం ఉదాహరణ సృష్టించబడదు. జావాలో “ఇంటర్ఫేస్” యొక్క సాధారణ రూపం:

access_specifier ఇంటర్ఫేస్ ఇంటర్ఫేస్_పేరు {రిటర్న్-టైప్ మెథడ్-నేమ్ 1 (పారామితి-జాబితా); రిటర్న్-టైప్ మెథడ్-నేమ్ 2 (పారామితి-జాబితా); టైప్ ఫైనల్-వర్నేమ్ 1 = విలువ; టైప్ ఫైనల్-వర్నేమ్ 2 = విలువ; // ... రిటర్న్-టైప్ మెథడ్-నేమ్ ఎన్ (పారామితి-జాబితా); టైప్ ఫైనల్- varnameN = విలువ; }

తరగతులు ఇంటర్ఫేస్ను అమలు చేయాల్సిన అవసరం ఉన్నందున యాక్సెస్ స్పెసిఫైయర్ పబ్లిక్ గా ప్రకటించబడింది.

C ++ లో “ఇంటర్ఫేస్” అనే భావన మాకు లేదు. కానీ, జావా మరియు సి # ఇంటర్ఫేస్ను బాగా నిర్వచించాయి.

జావాలో ఇంటర్ఫేస్:

• ఇంటర్ఫేస్ యొక్క వేరియబుల్స్ అప్రమేయంగా ఎల్లప్పుడూ పబ్లిక్, స్టాటిక్ మరియు ఫైనల్.
• వేరియబుల్స్ దాని డిక్లరేషన్ సమయంలో ప్రారంభించబడాలి.
• వేరియబుల్స్ ఎప్పుడూ ప్రైవేట్, రక్షిత, అస్థిరమైన మరియు అస్థిరతగా ప్రకటించబడవు.
• ఇంటర్ఫేస్ యొక్క పద్ధతులు ఎల్లప్పుడూ పబ్లిక్ మరియు నైరూప్యంగా ఉంటాయి, అయితే వాటిని ఎప్పుడూ ప్రైవేట్, రక్షిత, తుది, స్టాటిక్, సింక్రొనైజ్డ్, స్థానిక మరియు కఠినమైనవిగా ప్రకటించలేము.
• ఇంటర్ఫేస్ లోపల మీరు ఏ కన్స్ట్రక్టర్‌ను డిక్లేర్ చేయలేరు ఎందుకంటే కన్స్ట్రక్టర్ యొక్క ముఖ్య ఉద్దేశ్యం క్లాస్ వేరియబుల్స్ యొక్క ప్రారంభించడం, అయితే, ఇంటర్ఫేస్ వేరియబుల్స్ దాని డిక్లరేషన్ సమయంలో ప్రారంభించబడతాయి.
• ఇంటర్ఫేస్ ఇతర ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందగలదు, అయితే, అటువంటి ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతి తప్పనిసరిగా వారసత్వంగా వచ్చిన అన్ని ఇంటర్‌ఫేస్‌ల పద్ధతులను అమలు చేయాలి.
• ఒక తరగతి ఒక సమయంలో ఒకటి కంటే ఎక్కువ ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందగలదు మరియు ఇది వారసత్వంగా వచ్చిన అన్ని ఇంటర్‌ఫేస్‌ల యొక్క అన్ని పద్ధతులను అమలు చేయాలి.

జావాలో ఇంటర్ఫేస్ను అమలు చేసే సాధారణ రూపం:

తరగతి తరగతి_పేరు ఇంటర్ఫేస్_పేరు {// తరగతి-శరీరం}

ఇంటర్ఫేస్ను వారసత్వంగా పొందటానికి, ఒక తరగతి “పనిముట్లు” అనే కీవర్డ్‌ని ఉపయోగిస్తుంది మరియు తరగతి వారసత్వంగా పొందిన ఇంటర్‌ఫేస్ ద్వారా ప్రకటించిన అన్ని పద్ధతులను అమలు చేస్తుంది.

సి # లో ఇంటర్ఫేస్:

C # లోని ఇంటర్ఫేస్ జావాలో ఇంటర్ఫేస్కు దాదాపు సమానంగా ఉంటుంది:

• సి # లోని ఇంటర్ఫేస్ వేరియబుల్స్ డిక్లేర్ చేయదు.
• ఇంటర్ఫేస్ పేరు క్యాపిటల్ I తో ప్రిఫిక్స్ చేయబడింది మరియు పెద్దప్రేగు (:) గుర్తుతో వారసత్వంగా వస్తుంది.

C # లో ఇంటర్ఫేస్ను అమలు చేసే సాధారణ రూపం:

తరగతి తరగతి_పేరు: ఇంటర్ఫేస్_పేరు {// తరగతి-శరీరం}

వియుక్త తరగతి యొక్క నిర్వచనం

ఒకటి లేదా అంతకంటే ఎక్కువ నైరూప్య పద్ధతులను కలిగి ఉన్న తరగతిని అబ్‌స్ట్రాక్ట్ క్లాస్ అని పిలుస్తారు, మరియు క్లాస్ డిక్లరేషన్ ప్రారంభంలో “క్లాస్” కీవర్డ్ ముందు “అబ్‌స్ట్రాక్ట్” అనే కీవర్డ్‌ని ఉపయోగించి ఒక తరగతిని నైరూప్యంగా ప్రకటిస్తారు. నైరూప్య తరగతి నైరూప్య పద్ధతిని కలిగి ఉన్నందున ఇది అసంపూర్ణ రకానికి చెందినది. అందువల్ల, మీరు ఒక నైరూప్య తరగతి యొక్క వస్తువులను సృష్టించలేరు. ఒక తరగతి ఒక నైరూప్య తరగతిని వారసత్వంగా పొందినప్పుడు, అది నైరూప్య తరగతి యొక్క అన్ని నైరూప్య పద్ధతులను అమలు చేయాలి, అది కాకపోతే అది కూడా నైరూప్యంగా ప్రకటించబడాలి. నైరూప్య పద్ధతుల యొక్క పూర్తి అమలు సాధించే వరకు నైరూప్య లక్షణం వారసత్వంగా వస్తుంది.

నైరూప్య తరగతి కాంక్రీట్ పద్ధతులను కూడా కలిగి ఉంటుంది, ఇది ఉత్పన్నమైన తరగతికి ఉపయోగపడుతుంది. కానీ, మీరు ఒక నైరూప్య తరగతి లోపల ఒక నైరూప్య కన్స్ట్రక్టర్ లేదా ఒక నైరూప్య స్టాటిక్ పద్ధతిని ప్రకటించలేరు. జావాలోని నైరూప్య తరగతి యొక్క సాధారణ రూపం క్రింది విధంగా ఉంటుంది:

నైరూప్య తరగతి తరగతి_పేరు {నైరూప్య పద్ధతి_పేరు 1 (); నైరూప్య పద్ధతి_పేరు 2 (); : return_type method_name3 (పారామితి_ జాబితా) {// కాంక్రీట్ పద్ధతి} return_type method_name4 (పారామితి_ జాబితా) {// కాంక్రీట్ పద్ధతి}};

నైరూప్య తరగతి భావన జావా మరియు సి # రెండింటిలోనూ సమానంగా ఉంటుంది. సి ++ లో ఒక నైరూప్య తరగతి కొద్దిగా భిన్నంగా ఉంటుంది.

C ++ లో ఒక తరగతికి కనీసం ఒక వర్చువల్ ఫంక్షన్ ఉంటే తరగతి ఒక నైరూప్య తరగతి అవుతుంది. “నైరూప్య” కీవర్డ్‌కు బదులుగా, “వర్చువల్” అనే కీవర్డ్ ఒక నైరూప్య పద్ధతిని ప్రకటించడానికి ఉపయోగించబడుతుంది.

1. మీకు “ఏమి కావాలి” అనే జ్ఞానం ఉన్నప్పుడు “అది ఎలా అమలు చేయబడుతుంది” అనే దాని గురించి కాదు, అప్పుడు ఇంటర్ఫేస్ ఉపయోగించాలి. మరోవైపు, మీకు ఏమి అవసరమో తెలిస్తే మరియు అది ఎలా అమలు చేయబడుతుందో పాక్షికంగా తెలిస్తే అప్పుడు ఒక నైరూప్య తరగతిని ఉపయోగించండి.
2. ఇంటర్ఫేస్ దాని అన్ని పద్ధతులను నైరూప్యంగా కలిగి ఉంది, కానీ, ఒక నైరూప్య తరగతికి కొన్ని నైరూప్య పద్ధతులు మరియు కొన్ని కాంక్రీట్ పద్ధతులు ఉన్నాయి.
3. ఇంటర్ఫేస్ లోపల ఉన్న పద్ధతులు పబ్లిక్ మరియు నైరూప్యమైనవి, కనుక దీనిని స్వచ్ఛమైన నైరూప్య తరగతి అని కూడా పిలుస్తారు. మరోవైపు, ఒక నైరూప్యంలోని పద్ధతులు బహిరంగంగా మరియు నైరూప్యంగా మాత్రమే పరిమితం చేయబడవు.
4. ఇంటర్ఫేస్ పద్ధతి ఎప్పుడూ ప్రైవేట్, రక్షిత, తుది, స్టాటిక్, సమకాలీకరించబడిన, స్థానిక లేదా కఠినమైనదిగా ఉండకూడదు. మరోవైపు, ఒక నైరూప్య తరగతి యొక్క పద్ధతులకు ఎటువంటి పరిమితులు లేవు.
5. ఇంటర్ఫేస్లోని వేరియబుల్స్ పబ్లిక్ మరియు ఫైనల్, మేము వాటిని ప్రకటించినా లేదా చేయకపోయినా, ఒక నైరూప్య తరగతి యొక్క వేరియబుల్స్ పబ్లిక్ మరియు ఫైనల్ గా మాత్రమే ఉండటానికి అలాంటి పరిమితి లేదు.
6. ఇంటర్‌ఫేస్‌లోని వేరియబుల్స్ ఎప్పటికీ ప్రైవేట్ రక్షిత తాత్కాలిక లేదా అస్థిరత కావు, అయితే, నైరూప్య తరగతిలో వేరియబుల్స్‌కు పరిమితి లేదు.
7. డిక్లరేషన్ సమయంలో ఇంటర్ఫేస్ యొక్క వేరియబుల్ ప్రారంభించబడాలి. మరోవైపు, ఒక నైరూప్య తరగతిలో వేరియబుల్స్ ఎప్పుడైనా ప్రారంభించబడతాయి.
8. ఇంటర్ఫేస్ లోపల, ఒక ఉదాహరణ లేదా స్టాటిక్ బ్లాక్ ప్రకటించబడదు కాని, మీరు ఒక నైరూప్య తరగతి లోపల ఉదాహరణ లేదా స్టాటిక్ బ్లాక్‌ను ప్రకటించవచ్చు.
9. మీరు ఇంటర్ఫేస్ లోపల కన్స్ట్రక్టర్‌ను నిర్వచించలేరు, అయితే మీరు ఒక నైరూప్య తరగతి లోపల కన్స్ట్రక్టర్‌ను నిర్వచించవచ్చు.

ముగింపు:

మీరు ఒక బేస్ క్లాస్‌ని సృష్టించాల్సిన అవసరం వచ్చినప్పుడు, వాటి అవసరానికి అనుగుణంగా ఉత్పన్నమైన తరగతులచే అమలు చేయగలిగే సాధారణ పద్ధతుల పద్ధతులను కలిగి ఉన్నప్పుడు, ఇంటర్ఫేస్ మరియు నైరూప్య తరగతి భావన అలా చేయడంలో సహాయపడుతుంది.