பரம்பரை. பரம்பரை நன்மைகள்

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

அறியாதவர்களுக்கு, நிரலாக்கமானது மந்திரம் போன்றது. எனவே நான் ஒரு ஒப்புமையுடன் ஆரம்பிக்கிறேன்…

நீங்கள் பறக்கும் குதிரையை உருவாக்க விரும்பும் மந்திரவாதி என்று வைத்துக்கொள்வோம். நீங்கள் ஒரு பெகாசஸை கற்பனை செய்ய முயற்சி செய்யலாம். ஆனால் பறக்கும் குதிரைகள் இயற்கையாக இல்லை என்பதால், உங்களுக்கு மிகவும் கடினமான நேரம் இருக்கும். உங்களுக்கு நிறைய வேலைகள் இருக்கும். குதிரையுடன் தொடங்கி சில இறக்கைகளை வரவழைப்பது மிகவும் எளிதாக இருக்கும்.

நிரலாக்கத்தில், இந்த செயல்முறையை "பரம்பரை" என்று அழைக்கிறோம் . நீங்கள் மிகவும் சிக்கலான வகுப்பை எழுத வேண்டும் என்று வைத்துக்கொள்வோம். நீங்கள் புதிதாக குறியீட்டை எழுத நீண்ட நேரம் செலவிடலாம், பின்னர் பிழைகளைக் கண்டறிய நீண்ட சோதனை செய்யலாம். ஆனால் அதை ஏன் கடினமான முறையில் செய்ய வேண்டும்? நீங்கள் தேடும் வகுப்பு ஏற்கனவே உள்ளதா என்று சுற்றிப் பார்ப்பது நல்லது?

உங்களுக்குத் தேவையான 80% செயல்பாட்டைச் செயல்படுத்தும் ஒரு வகுப்பை நீங்கள் கண்டுபிடித்தீர்கள் என்று வைத்துக்கொள்வோம். நீங்கள் அதன் குறியீட்டை உங்கள் வகுப்பில் நகலெடுக்கலாம். ஆனால் இது பல குறைபாடுகளைக் கொண்டிருக்கும்:

1) நீங்கள் கண்டறிந்த வகுப்பு ஏற்கனவே பைட்கோடில் தொகுக்கப்பட்டிருக்கலாம். அதன் மூலக் குறியீட்டிற்கான அணுகல் உங்களிடம் இல்லாமல் இருக்கலாம்.

2) வகுப்பிற்கான மூலக் குறியீடு உங்களிடம் இருக்கலாம், ஆனால் நீங்கள் வேறொருவரின் குறியீட்டின் 6 வரிகளைப் பயன்படுத்தினால் சில பில்லியன்களுக்கு வழக்குத் தொடரக்கூடிய நிறுவனத்தில் பணிபுரியலாம். பின்னர் அவர்கள் உங்கள் மீது வழக்கு தொடுப்பார்கள்.

3) இது நிறைய குறியீடுகளின் தேவையற்ற நகல்களுக்கு வழிவகுக்கிறது. மற்ற வகுப்பின் ஆசிரியர் பிழையைக் கண்டுபிடித்து அதைச் சரிசெய்தால், உங்களிடம் இன்னும் பிழை உள்ளது.

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

"மிகவும் சுவாரஸ்யமானது. தயவுசெய்து தொடரவும்."

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

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

"நாங்கள் ஒரு செஸ் திட்டத்தை எழுதுகிறோம் என்று வைத்துக்கொள்வோம். எங்களுக்கு செஸ் துண்டுகளுக்கு வகுப்புகள் தேவைப்படும். எந்த வகுப்புகளை நீங்கள் பரிந்துரைக்கிறீர்கள், அமிகோ?"

"ராஜா, ராணி, பிஷப், நைட், ரூக் மற்றும் சிப்பாய்."

"வெரி குட். நீங்கள் எதையும் தவறவிடவில்லை."

"இந்த வகுப்புகளில் எந்தத் தரவைச் சேமிக்க பரிந்துரைக்கிறீர்கள்?"

"ஒவ்வொரு துண்டின் போர்டு நிலையும் (x மற்றும் y) மற்றும் மதிப்பு. எல்லாவற்றிற்கும் மேலாக, சில துண்டுகள் மற்றவற்றை விட மதிப்புமிக்கவை."

"இந்த வகுப்புகளுக்கு இடையிலான வேறுபாடுகள் என்ன?"

"அவர்கள் காய்களை எவ்வாறு நகர்த்துகிறார்கள் என்பதில் அவர்கள் வேறுபடுகிறார்கள். அவர்களின் நடத்தையில்."

"ஆம். நீங்கள் அவற்றை இது போன்ற வகுப்புகளாக வரையறுக்கலாம்:"

class King
{
int x;
int y;
int worth;
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen
{
int x;
int y;
int worth;
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook
{
int x;
int y;
int worth;
void rookMove()
{
//code that defines,
//how the rook moves
}
}

class Knight
{
int x;
int y;
int worth;
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop
{
int x;
int y;
int worth;
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn
{
int x;
int y;
int worth;
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"ஆம், நான் அப்படித்தான் எழுதுவேன்."

"ஆனால், குறைவான குறியீட்டை எழுதுவதற்கு நீங்கள் மரபுரிமையை எவ்வாறு பயன்படுத்தலாம் என்பதைப் பாருங்கள். ஒரே மாதிரியான முறைகள் மற்றும் தரவை நாம் பொதுவான வகுப்பிற்கு நகர்த்தலாம். அதை ChessItem என்று அழைக்கலாம். ChessItem பொருட்களை உருவாக்குவதில் அர்த்தமில்லை, ஏனெனில் அவை எதனுடனும் ஒத்துப்போவதில்லை. சதுரங்க துண்டு. ஆனால் வகுப்பு மிகவும் உதவியாக இருக்கும்:"

class King extends ChessItem
{
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen extends ChessItem
{
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook extends ChessItem
{
void rookMove()
{
//code that defines,
//how the rook moves
}
}

class ChessItem
{
int x;
int y;
int worth;
}

class Knight extends ChessItem
{
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop extends ChessItem
{
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn extends ChessItem
{
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"எவ்வளவு சுவராஸ்யமான!"

"நிச்சயமாக! ஆயிரக்கணக்கான வெவ்வேறு பொருள்கள் மற்றும் நூற்றுக்கணக்கான வகுப்புகளைக் கொண்ட திட்டங்களில் நன்மை குறிப்பாக பெரியது. இந்த விஷயத்தில், சரியாக தேர்ந்தெடுக்கப்பட்ட வகுப்புகள் தர்க்கத்தை கணிசமாக எளிதாக்குவது மட்டுமல்லாமல், தேவையான குறியீட்டை பத்து மடங்கு குறைக்கலாம்."

"அப்படியானால், ஒரு வகுப்பைப் பெறுவதற்கு நீங்கள் என்ன செய்ய வேண்டும்?"

"ஒரு வகுப்பை அறிவித்த பிறகு, நாங்கள் ' நீட்டிப்புகள் ' என்ற முக்கிய சொல்லைப் பயன்படுத்துகிறோம் , அதைத் தொடர்ந்து பெற்றோர் வகுப்பின் பெயரைப் பயன்படுத்துகிறோம். நீங்கள் ஒரு வகுப்பிலிருந்து மட்டுமே பெற முடியும் .

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

"ஆனால் நான் இரண்டு வகுப்புகளில் இருந்து மரபுரிமை பெற விரும்பினால் என்ன செய்வது? என்னால் ஏதாவது செய்ய முடியுமா?!"

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

"நான் பார்க்கிறேன். இடைமுகம் என்றால் என்ன?"

"இன்டர்ஃபேஸ்கள் பற்றி நாளை சொல்கிறேன். இப்போதைக்கு, பரம்பரையில் ஆராய்வோம்."

3

பணி

Java உள்ளகம், நிலை 1, பாடம் 5

பூட்டப்பட்டது

Code entry

Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and assimilate some material. What's more, you combat laziness.

திற

3

பணி

Java உள்ளகம், நிலை 1, பாடம் 5

பூட்டப்பட்டது

Code typing

Your attention, please! Now recruiting code entry personnel for CodeGym. Turn up your focus, let your fingers relax, read the code, and then... type it into the appropriate box. Code entry is far from a useless exercise, though it might seem so at first glance: it allows a beginner to get used to and remember syntax (modern IDEs seldom make this possible).

திற