பாலிமார்பிசம், பகுதி 3

1. தட்டச்சு செய்தல்

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

குறிப்பு வகைகளின் தட்டச்சு மற்றும் பழமையானவை விரிவுபடுத்துதல் மற்றும் குறுகுதல் என வகைப்படுத்தப்படுகின்றன.

பூனை வர்க்கம் செல்லப்பிராணி வகுப்பையும், செல்லப்பிராணி வர்க்கம் விலங்கு வகுப்பையும் பெறுவதை நாம் காண்கிறோம்.

இப்படி குறியீடு எழுதினால்:

Animal kitten = new Cat();

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

குறுகலான மாற்றம் (அல்லது வெளிப்படையான நடிகர்கள்) எதிர் திசையில் நிகழ்கிறது:

Cat cat = (Cat) kitten;

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

2. ஒரு பொருளின் வகையைச் சரிபார்த்தல்

ஆனால் இங்கே நீங்கள் மிகவும் கவனமாக இருக்க வேண்டும். நீங்கள் இதைச் செய்தால்:

Animal beast = new Cat();
Wolf grayWolf = (Wolf) beast;

கம்பைலர் இந்தக் குறியீட்டை அனுமதிக்கும், ஆனால் நிரல் இயங்கும்போது பிழை ஏற்படும் ! JVM விதிவிலக்கு அளிக்கும்:

Exception in thread "main" java.lang.ClassCastException: Cat cannot be cast to a Wolf

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

அது ஏன்?

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

ஆனால், ஜேவிஎம் ஒரு பூனைப் பொருளைப் பற்றிய குறிப்பை Wolf மாறியில் சேமிக்க அனுமதித்தால், அந்த மாறியில் சேமிக்கப்பட்டுள்ள Cat ஆப்ஜெக்ட்டில் இல்லாத ஒரு முறையைக் கூப்பிட grayWolf மாறியைப் பயன்படுத்த முயற்சி செய்யலாம். . அதனால்தான் இந்த ஏற்பாடு அனுமதிக்கப்படவில்லை.

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

variable instanceof Type

உதாரணமாக:

Animal beast = new Cat();
if (beast instanceof Wolf)
{
   Wolf grayWolf = (Wolf) beast;
}

இந்த குறியீடு பிழைகளை ஏற்படுத்தாது — இயக்க நேரத்திலும் கூட.

நிலைமையை விளக்கும் இன்னும் சில எடுத்துக்காட்டுகள் இங்கே:

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

3. அசல் முறையை அழைக்கிறது: superமுக்கிய சொல்

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

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

மற்றும் ஜாவா நம்மை அதை அனுமதிக்கிறது. பெற்றோர் வகுப்பின் முறையை அழைக்க, இதைச் செய்யுங்கள்:

super.method(arguments);

எடுத்துக்காட்டுகள்:

class PeaceTime
{
   public double getPi()
   {
      return 3.14;
   }
}

class WarTime extends PeaceTime
{
   public double getPi()
   {
      return super.getPi()*2;  // 3.14*2
   }
}

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

விஷயங்களைக் கொஞ்சம் தெளிவுபடுத்த இன்னும் இரண்டு எடுத்துக்காட்டுகள் இங்கே:

class Cow
{
   public void printAll()
   {
      printColor();
      printName();
   }

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

   public void printName()
   {
      System.out.println("I'm a cow");
   }
}

class Whale extends Cow
{
   public void printName()
   {
      System.out.print("This is incorrect: ");
      super.printName();
      System.out.println("I'm a whale");
   }
}

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

I'm a white whale
This is incorrect: I'm a cow
I'm a whale

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