నిర్దిష్ట ప్రవర్తనకు మద్దతు ఇవ్వడానికి ఇంటర్‌ఫేస్‌లు ఉన్నాయి

"హలో, అమిగో! ఈ రోజు నేను మీకు ఇంటర్‌ఫేస్‌లు ఎందుకు ఉనికిలో ఉన్నాయో చెప్పాలనుకుంటున్నాను. నిర్దిష్ట తరగతి, వస్తువు లేదా ఎంటిటీ నిర్దిష్ట ఇంటర్‌ఫేస్‌కు మద్దతు ఇస్తుందని మీరు తరచుగా వింటూనే ఉంటారు. ఇంటర్‌ఫేస్‌కు మద్దతు ఇవ్వడం అంటే ఏమిటి ? "

విస్తృత కోణంలో, ఏదైనా ఇంటర్‌ఫేస్ అనేది వేరొక దానితో పరస్పర చర్య చేయడానికి ఒక మెకానిజం. ఉదాహరణకు, టీవీ రిమోట్ అనేది రిమోట్ ఇంటర్‌ఫేస్. కుక్క ఆదేశాలను అర్థం చేసుకుంటుంది మరియు అమలు చేస్తుంది, అంటే కుక్క వాయిస్ (నియంత్రణ) ఇంటర్‌ఫేస్‌కు మద్దతు ఇస్తుంది. అన్నింటినీ సంక్షిప్తీకరించడానికి, ఇంటర్‌ఫేస్ అనేది రెండు విషయాల పరస్పర చర్యకు ప్రామాణిక మార్గం అని మేము చెప్పగలం, ఇక్కడ రెండు పార్టీలకు ప్రమాణం తెలుసు. ఒక వ్యక్తి కుక్కను "కూర్చుని" అని చెప్పినప్పుడు, అతని లేదా ఆమె ఆదేశం «కుక్క వాయిస్-నియంత్రణ ఇంటర్‌ఫేస్»లో భాగం, మరియు కుక్క ఆదేశాన్ని పాటిస్తే, కుక్క ఇంటర్‌ఫేస్‌కు మద్దతు ఇస్తుందని మేము చెబుతాము.

కాబట్టి ఇది ప్రోగ్రామింగ్‌లో ఉంది. పద్ధతులు అంటే ఒక వస్తువుపై, దాని డేటాపై చేసే చర్యలు. మరియు ఒక తరగతి కొన్ని పద్ధతులను అమలు చేస్తే, అది కొన్ని ఆదేశాలను "అమలు చేయడానికి మద్దతు ఇస్తుంది". పద్ధతులను ఇంటర్‌ఫేస్‌గా కలపడం ద్వారా మనం ఏమి పొందుతాము?

1) ప్రతి ఇంటర్‌ఫేస్ , ఒక తరగతి వలె , ఒక ప్రత్యేక పేరును కలిగి ఉంటుంది. ఇతర పక్షాలు తమకు తెలిసిన ఖచ్చితమైన ఇంటర్‌ఫేస్‌కు మద్దతు ఇస్తాయని మరియు సారూప్య ఇంటర్‌ఫేస్‌కు కాదని రెండు పార్టీలు 100% ఖచ్చితంగా చెప్పగలవు.

2) ప్రతి ఇంటర్‌ఫేస్ దానికి సపోర్ట్ చేయబోయే క్లాస్‌పై కొన్ని పరిమితులను విధిస్తుంది. తరగతి (దాని డెవలపర్) ఇంటర్‌ఫేస్ నుండి వారసత్వంగా పొందిన పద్ధతులను పిలిచినప్పుడు అది ఏమి చేస్తుందో నిర్ణయిస్తుంది, అయితే ఫలితం సహేతుకమైన అంచనాల పరిధిలో ఉండాలి. మనం కుక్కను "కూర్చుని" ఆదేశిస్తే, అది 5 నిమిషాల పాటు చుట్టుముట్టి, ఆపై కూర్చుంటే, అది ఇంటర్‌ఫేస్‌కు మద్దతు ఇస్తుంది. కానీ అది మిమ్మల్ని కాలుతో పట్టుకుంటే, అది ఇంటర్‌ఫేస్‌కు మద్దతు ఇస్తుందని మేము చెప్పలేము. ఆదేశాన్ని అమలు చేయడం ఆశించిన ఫలితాన్ని అందించలేదు.

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

interface Saveable
{
 void saveToMap(Map<String, Object> map);
 void loadFromMap(Map<String, Object> map);
}

interface Drawable
{
 void draw(Screen screen);
}

class PacMan implements Saveable, Drawable
{
…
}

మరో మాటలో చెప్పాలంటే, ఏదైనా ఇంటర్‌ఫేస్‌కు (ఇంటర్‌ఫేస్‌ల సమూహం) మద్దతు ఇవ్వడానికి, మీ తరగతి తప్పనిసరిగా:

1) వాటిని వారసత్వంగా పొందండి

2) వాటిలో ప్రకటించిన పద్ధతులను అమలు చేయండి

3) పద్ధతులు వారు చేయాలనుకున్నది చేయాలి.

మీ తరగతి మరియు దాని వస్తువుల గురించి ఏమీ తెలియని ప్రోగ్రామ్ యొక్క మిగిలిన కోడ్ మీ తరగతితో పని చేయగలదు.

"కోడ్‌కి నా క్లాస్ గురించి ఎందుకు తెలియదు?"

"ఒక సంవత్సరం క్రితం ఎవరో వ్రాసిన ప్రోగ్రామ్ నుండి మీరు కోడ్ తీసుకున్నారని అనుకుందాం. లేదా మీ స్నేహితులు వేరొకరి నుండి గేమ్ ఇంజిన్‌ను కొనుగోలు చేసి/లైసెన్స్ తీసుకున్నారని అనుకుందాం. మీ వద్ద గేమ్ కోసం వర్కింగ్ కోడ్ ఉంది. ఒకదానితో ఒకటి పరస్పర చర్య చేసే వేలాది వస్తువులు. మరియు అవి మీ తరగతులు సరిగ్గా అమలు చేసిన ఇంటర్‌ఫేస్‌ల ద్వారా పరస్పర చర్య జరిగేలా చేస్తే మీ వస్తువులతో సులభంగా సంభాషించవచ్చు."

"చాలా దూరం! అది సాధ్యమవుతుందని నాకు తెలియదు."

"అన్ని పెద్ద ప్రాజెక్టులు ఇలాగే పనిచేస్తాయి. చాలా కాలం క్రితం ప్రజలు మొదటి నుండి రాయడం మానేశారు."

ప్రజలు ప్రతిసారీ గణితాన్ని మరియు వర్ణమాలలను కూడా మళ్లీ ఆవిష్కరించరు. బదులుగా, వారు తమ ముందు కనుగొనబడిన ప్రతిదాన్ని అధ్యయనం చేస్తారు.