పాలీమార్ఫిజం, పార్ట్ 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

పిల్లి ఆబ్జెక్ట్‌కు సంబంధించిన రిఫరెన్స్‌లు క్యాట్ క్లాస్ యొక్క పూర్వీకులు అయిన వేరియబుల్స్‌లో మాత్రమే నిల్వ చేయబడతాయి: పెట్, యానిమల్ లేదా ఆబ్జెక్ట్.

అది ఎందుకు?

ఇక్కడ సంబంధిత అంశం ఏమిటంటే, ఆ వస్తువు యొక్క పద్ధతులు మరియు వేరియబుల్‌లను సూచించడానికి ఆబ్జెక్ట్ రిఫరెన్స్ ఉపయోగించబడుతుంది . మరియు మేము పిల్లి వస్తువుకు సూచనను నిల్వ చేయడానికి యానిమల్ వేరియబుల్‌ని ఉపయోగిస్తే ఎటువంటి సమస్యలు ఉండవు: పిల్లి రకం ఎల్లప్పుడూ జంతు రకం యొక్క వేరియబుల్స్ మరియు పద్ధతులను కలిగి ఉంటుంది — ఇది వాటిని వారసత్వంగా పొందింది!

కానీ JVM మాకు వోల్ఫ్ వేరియబుల్‌లో క్యాట్ ఆబ్జెక్ట్‌కు సూచనను నిల్వ చేయడానికి అనుమతించినట్లయితే, ఆ వేరియబుల్‌లో నిల్వ చేయబడిన క్యాట్ ఆబ్జెక్ట్‌లో లేని పద్ధతిని పిలవడానికి గ్రే వోల్ఫ్ వేరియబుల్‌ని ఉపయోగించడానికి ప్రయత్నించే పరిస్థితి మనకు ఉండవచ్చు. . అందుకే ఈ ఏర్పాటుకు అనుమతి లేదు.

జావా ప్రత్యేక 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 లో కష్టతరమైన విషయాలలో ఒకటి . మీరు దానిని తెలుసుకోవాలి మరియు అర్థం చేసుకోవాలి.