பல இடைமுகங்களைப் பெறுதல்

"ஹலோ, அமிகோ! நாங்கள் இறுதியாக உண்மையிலேயே சுவாரஸ்யமான ஒன்றுக்கு வந்துள்ளோம். இன்று நான் உங்களுக்கு பல பரம்பரை பற்றி சொல்லப் போகிறேன் . பல பரம்பரை உண்மையில் மிகவும் கவர்ச்சிகரமான மற்றும் சக்திவாய்ந்த கருவியாகும். மேலும் இது பல சிக்கல்களுக்கு இல்லை என்றால், ஜாவா வகுப்புகளின் பல மரபுகளை ஆதரிக்கும். ஆனால் அது இல்லை, எனவே பல இடைமுகங்களின் பரம்பரையில் நாம் திருப்தியடைய வேண்டும் . இதுவும் மிகவும் அருமை."

நீங்கள் ஒரு கணினி விளையாட்டை எழுதுகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். மற்றும் அதன் எழுத்துக்கள் (உங்கள் பொருள்கள்) மிகவும் சிக்கலான வழிகளில் நடந்து கொள்ள வேண்டும்: ஒரு வரைபடத்தை சுற்றி நடக்க, பொருட்களை சேகரிக்க, தேடல்கள் செய்ய, மற்ற கதாபாத்திரங்கள் தொடர்பு, ஒருவரை கொல்ல, மற்றொரு காப்பாற்ற. நீங்கள் அனைத்து பொருட்களையும் 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
{}

இந்த மூன்று பாத்திரங்களை (இடைமுகங்கள்) மட்டுமே அறிந்து, நீங்கள் ஒரு நிரலை எழுதலாம் மற்றும் இந்த பாத்திரங்களுக்கு இடையிலான சரியான தொடர்புகளை விவரிக்கலாம். எடுத்துக்காட்டாக, ஒரு பொருள் "நீங்கள் உண்ணக்கூடிய ஒன்றை" பின்தொடர்ந்து (அசைக்கக்கூடிய இடைமுகம் வழியாக) "உன்னை உண்ணக்கூடிய ஒருவரிடமிருந்து" ஓடிவிடும். மேலும் இவை அனைத்தும் குறிப்பிட்ட பொருட்களைப் பற்றி தெரியாமல். நீங்கள் நிரலில் அதிக பொருட்களை (வகுப்புகள்) சேர்த்து, இந்த பாத்திரங்களை வைத்திருந்தால், அது இன்னும் அழகாக வேலை செய்யும், உங்கள் பொருட்களின் நடத்தையை கட்டுப்படுத்துகிறது.