బహుళ ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందడం

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

మీరు కంప్యూటర్ గేమ్ వ్రాస్తున్నారని ఊహించుకోండి. మరియు దాని అక్షరాలు (మీ వస్తువులు) చాలా క్లిష్టమైన మార్గాల్లో ప్రవర్తించాలి: మ్యాప్ చుట్టూ నడవడం, వస్తువులను సేకరించడం, అన్వేషణలు చేయడం, ఇతర పాత్రలతో కమ్యూనికేట్ చేయడం, ఒకరిని చంపడం, మరొకరిని రక్షించడం. మీరు అన్ని వస్తువులను 20 వర్గాలుగా విభజించగలిగారు అనుకుందాం. దీనర్థం, మీరు అదృష్టవంతులైతే, మీ వస్తువులను నిర్వచించడానికి మీరు కేవలం 20 తరగతులతో మాత్రమే పొందగలుగుతారు. అయితే ఇక్కడ క్యాచ్ ఉంది: ఈ వస్తువులు ఎన్ని ప్రత్యేకమైన పరస్పర చర్యలను కలిగి ఉంటాయి? ప్రతి రకమైన వస్తువు 20 ఇతర రకాల వస్తువులతో ప్రత్యేక పరస్పర చర్యలను కలిగి ఉంటుంది (మేము అదే రకమైన వస్తువులతో పరస్పర చర్యలను కూడా లెక్కిస్తున్నాము). మరో మాటలో చెప్పాలంటే, మీరు 20 x 20 = 400 పరస్పర చర్యల కోసం కోడ్‌ని వ్రాయవలసి ఉంటుంది! మరియు ప్రత్యేకమైన ఆబ్జెక్ట్ రకాల సంఖ్య 20 కాదు, 100 అయితే, పరస్పర చర్యల సంఖ్య 10,000 కావచ్చు!

"ఓహో! ప్రోగ్రామింగ్ ఎందుకు అంత కష్టమైన పని అని నాకు ఇప్పుడు అర్థమైంది."

"ఇది చాలా సులభం. చాలా సంగ్రహణలకు ధన్యవాదాలు. మరియు ఇంటర్‌ఫేస్‌ల బహుళ వారసత్వానికి చిన్న కృతజ్ఞతలు లేకుండా."

పాత్రలు మరియు/లేదా సామర్థ్యాలు వస్తువులు కాకుండా పరస్పర చర్య చేస్తే మనం తరచుగా వస్తువు పరస్పర చర్యను సులభతరం చేయవచ్చు. మరియు మనకు ఇప్పటికే తెలిసినట్లుగా, కొన్ని ఇంటర్‌ఫేస్‌లను అమలు చేసినప్పుడు సామర్థ్యాలను తరగతికి సులభంగా జోడించవచ్చు.

పెద్ద ప్రోగ్రామ్‌ను వ్రాసేటప్పుడు, డెవలపర్లు సాధారణంగా దీన్ని మొదటి నుండి చేస్తారు:

1) అన్ని సామర్థ్యాలు/పాత్రలను గుర్తించండి.

2) ఈ పాత్రల మధ్య పరస్పర చర్యను నిర్వచించండి.

3) ఆపై అన్ని తరగతులకు పాత్రలను కేటాయించండి.

"బహుశా ఒక ఉదాహరణ?"

"అయితే. కార్టూన్ «టామ్ అండ్ జెర్రీ»లో పాత్రలను చూద్దాం."

interface Moveable
{}

interface Eatable
{}

interface Eat
{}

class Tom extends Cat implements Moveable, Eatable, Eat
{}

class Jerry extends Mouse implements Moveable, Eatable
{}

class Killer extends Dog implements Moveable, Eat
{}

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