பாலிமார்பிசம் மற்றும் மேலெழுதல்

"அமிகோ, உனக்கு திமிங்கலங்கள் பிடிக்குமா?"

"திமிங்கலங்களா? இல்லை, அவற்றைப் பற்றி கேள்விப்பட்டதே இல்லை."

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

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

1) முறை மீறல்.

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

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

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

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

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

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

இது எவ்வாறு செயல்படுகிறது என்பது இங்கே:

class Cow
{
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a cow");
}
}class Whale extends Cow
{
public void printName()
{
System.out.println("I'm a whale");
}
}

public static void main(String[] args)
{
Cow cow = new Cow();
cow.printName();
}

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printName();
}

இது மரபுரிமை Cowமற்றும் மேலெழுதப்பட்ட பிறகு printName, Whaleவர்க்கம் உண்மையில் பின்வரும் தரவு மற்றும் முறைகளைக் கொண்டுள்ளது:

class Whale
{
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a whale");
}
}

"உண்மையாக, அதைத்தான் நான் எதிர்பார்த்தேன்."

2) ஆனால் அது எல்லாம் இல்லை.

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

திரை காண்பிக்கும்:
நான் வெள்ளை,
நான் ஒரு திமிங்கலம்

class Cow
{
public void printAll()
{
printColor();
printName();
}
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a cow");
}
}

class Whale extends Cow
{
public void printName()
{
System.out.println("I'm a whale");
}
}

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printAll();
}

ஒரு திமிங்கலப் பொருளில் Cow class இன் printAll () முறை அழைக்கப்படும் போது, ​​Whale's printName() முறை பயன்படுத்தப்படும், பசுவை அல்ல.

முக்கிய விஷயம் என்னவென்றால், அந்த முறை எழுதப்பட்ட வகுப்பில் அல்ல, மாறாக அந்த முறை அழைக்கப்படும் பொருளின் வகை (வகுப்பு) ஆகும்.

"நான் பார்க்கிறேன்."

"நிலையற்ற முறைகளை மட்டுமே நீங்கள் பெறலாம் மற்றும் மேலெழுத முடியும். நிலையான முறைகள் மரபுரிமையாக இல்லை, எனவே மேலெழுத முடியாது."

நாம் மரபுரிமையைப் பயன்படுத்திய பிறகு மற்றும் முறைகளை மேலெழுதிய பிறகு திமிங்கல வகுப்பு எப்படி இருக்கும் என்பது இங்கே:

class Whale
{
public void printAll()
{
printColor();
printName();
}
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a whale");
}
}

3) வகை வார்ப்பு.

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

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printColor();
}

public static void main(String[] args)
{
Cow cow = new Whale();
cow.printColor();
}

public static void main(String[] args)
{
Object o = new Whale();
System.out.println(o.toString());
}

"நல்ல பொருள். ஆனால் இது ஏன் உங்களுக்குத் தேவை?"

"இது ஒரு மதிப்புமிக்க அம்சம். இது மிகவும் மதிப்புமிக்கது என்பதை நீங்கள் பின்னர் புரிந்துகொள்வீர்கள்."

4) லேட் பைண்டிங் (டைனமிக் டிஸ்பாட்ச்).

அது எப்படி இருக்கிறது என்பது இங்கே:

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printName();
}

public static void main(String[] args)
{
Cow cow = new Whale();
cow.printName();
}

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

மாடு மாறி ஒரு திமிங்கலப் பொருளைப் பற்றிய குறிப்பைச் சேமிக்கிறது , மேலும் திமிங்கல வகுப்பில் வரையறுக்கப்பட்ட அச்சுப்பெயர் முறை அழைக்கப்படும்.

"சரி, அவர்கள் தெளிவுக்காக அதைச் சேர்க்கவில்லை."

"ஆம், அது அவ்வளவு தெளிவாக இல்லை. இந்த முக்கியமான விதியை நினைவில் வையுங்கள்:"

ஒரு மாறியில் நீங்கள் அழைக்கக்கூடிய முறைகளின் தொகுப்பு மாறியின் வகையால் தீர்மானிக்கப்படுகிறது. ஆனால் எந்த குறிப்பிட்ட முறை/செயல்பாடு அழைக்கப்படுகிறது என்பது மாறியால் குறிப்பிடப்பட்ட பொருளின் வகை/வகுப்பால் தீர்மானிக்கப்படுகிறது.

"நான் முயற்சி செய்கிறேன்."

"நீங்கள் தொடர்ந்து இதை எதிர்கொள்வீர்கள், எனவே நீங்கள் அதை விரைவில் புரிந்துகொள்வீர்கள், மறக்க மாட்டீர்கள்."

5) வகை வார்ப்பு.

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

Cow cow = new Whale();

Cow cow = new Whale();
if (cow instanceof Whale)
{
Whale whale = (Whale) cow;
}

Cow cow = new Cow();
Whale whale = (Whale) cow; //exception

6) இப்போது சுவையான ஒன்று. அசல் முறையை அழைக்கிறது.

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

இந்த வழக்கில், புதிய முறையின் குறியீடு அதே முறையை அழைக்க வேண்டும், ஆனால் அடிப்படை வகுப்பில். மற்றும் ஜாவா இதை நீங்கள் செய்யலாம். இது இவ்வாறு செய்யப்படுகிறது:  super.method().

இங்கே சில உதாரணங்கள்:

class Cow
{
public void printAll()
{
printColor();
printName();
}
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a cow");
}
}

class Whale extends Cow
{
public void printName()
{
System.out.print("This is false: ");
super.printName();

System.out.println("I'm a whale");
}
}

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printAll();
}

"ம்ம். சரி, அது ஒரு பாடம். என் ரோபோ காதுகள் கிட்டத்தட்ட உருகிவிட்டன."

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