பரம்பரை

1. பெகாசஸ்

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

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

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

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

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

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

2. பொதுவான அடிப்படை வகுப்பு

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

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

சதுரங்க காய்கள்

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

நீங்கள் எப்போதாவது சதுரங்கம் விளையாடியிருந்தால், தெளிவான பதில் கிங், குயின், பிஷப், நைட், ரூக் மற்றும் பான்.

ஆனால் வகுப்புகள் ஒவ்வொரு பகுதியைப் பற்றிய தகவலையும் இன்னும் சேமிக்க வேண்டும். எடுத்துக்காட்டாக, x மற்றும் y ஒருங்கிணைப்புகள் மற்றும் துண்டு மதிப்பு. எல்லாவற்றிற்கும் மேலாக, சில துண்டுகள் மற்றவர்களை விட மதிப்புமிக்கவை.

கூடுதலாக, துண்டுகள் வித்தியாசமாக நகரும், அதாவது வகுப்புகள் வெவ்வேறு நடத்தைகளை செயல்படுத்தும். அவற்றை வகுப்புகளாக எப்படி வரையறுக்கலாம் என்பது இங்கே:

class King
{
   int x;
   int y;
   int worth;

   void kingMove()
   {
     // Code that decides
     // how to move
     // the king
   }
}

class Queen
{
   int x;
   int y;
   int worth;

   void queenMove()
   {
     // Code that decides
     // how to move
     // the queen
   }
}

class Rook
{
   int x;
   int y;
   int worth;

   void rookMove()
   {
     // Code that decides
     // how to move
     // the rook
   }
}

class Knight
{
   int x;
   int y;
   int worth;

   void knightMove()
   {
     // Code that decides
     // how to move
     // the knight
   }
}

class Bishop
{
   int x;
   int y;
   int worth;

   void bishopMove()
   {
     // Code that decides
     // how to move
     // the bishop
   }
}

class Pawn
{
   int x;
   int y;
   int worth;

   void pawnMove()
   {
     // Code that decides
     // how to move
     // the pawn
   }
}

இது செஸ் காய்களின் மிகவும் பழமையான விளக்கம்.

பொதுவான அடிப்படை வகுப்பு

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

class King extends ChessItem
{
   void kingMove()
   {
     // Code that decides
     // how to move the king
   }
}

class Queen extends ChessItem
{
   void queenMove()
   {
     // Code that decides
     // how to move the queen
   }
}

class Rook extends ChessItem
{
   void rookMove()
   {
     // Code that decides
     // how to move the rook
   }
}

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

class Knight extends ChessItem
{
   void knightMove()
   {
     // Code that decides
     // how to move the knight
   }
}

class Bishop extends ChessItem
{
   void bishopMove()
   {
     // Code that decides
     // how to move the bishop
   }
}

class Pawn extends ChessItem
{
   void pawnMove()
   {
     // Code that decides
     // how to move the pawn
   }
}

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

3. வர்க்க மரபு -extends

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

class Descendant extends Parent

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

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

ஜாவாவிற்கு பல மரபுகள் இல்லை: ஒரு வர்க்கம் இரண்டு வகுப்புகளைப் பெற முடியாது. ஒவ்வொரு வகுப்பிலும் ஒரு பெற்றோர் வகுப்பு மட்டுமே இருக்க முடியும். பெற்றோர் வகுப்பு எதுவும் குறிப்பிடப்படவில்லை என்றால், பெற்றோர் வகுப்பு Object.

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