పాలిమార్ఫిజం మరియు ఓవర్‌రైడింగ్

"ఏమిగో, నీకు తిమింగలాలు ఇష్టమా?"

"తిమింగలాలు? వద్దు, వాటి గురించి ఎప్పుడూ వినలేదు."

"ఇది ఆవు లాంటిది, పెద్దది మాత్రమే మరియు అది ఈదుతుంది. యాదృచ్ఛికంగా, తిమింగలాలు ఆవుల నుండి వచ్చాయి. ఉహ్, లేదా కనీసం అవి ఉమ్మడి పూర్వీకులను పంచుకుంటాయి. అది పట్టింపు లేదు."

"వినండి. 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();
}

వేల్ ఆబ్జెక్ట్‌పై కౌ క్లాస్ ప్రింట్‌ఆల్ () పద్ధతిని పిలిచినప్పుడు, వేల్ ప్రింట్‌నేమ్() పద్ధతి ఉపయోగించబడుతుంది, ఆవు కాదు.

ముఖ్యమైన విషయం ఏమిటంటే పద్ధతి వ్రాసిన తరగతి కాదు, కానీ పద్ధతి అని పిలువబడే వస్తువు యొక్క టైప్ (తరగతి).

"అలాగా."

"మీరు నాన్-స్టాటిక్ పద్ధతులను మాత్రమే వారసత్వంగా పొందగలరు మరియు భర్తీ చేయగలరు. స్టాటిక్ పద్ధతులు వారసత్వంగా పొందబడవు మరియు అందువల్ల భర్తీ చేయలేము."

మేము వారసత్వాన్ని వర్తింపజేసి, పద్ధతులను భర్తీ చేసిన తర్వాత వేల్ క్లాస్ ఎలా ఉంటుందో ఇక్కడ ఉంది:

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();
}

"హ్మ్. సరే, అది కొంత పాఠం. నా రోబోట్ చెవులు దాదాపు కరిగిపోయాయి."

"అవును, ఇది సాధారణ విషయం కాదు. ఇది మీరు ఎదుర్కొనే అత్యంత క్లిష్టమైన మెటీరియల్‌లో కొన్ని. ఇతర రచయితల నుండి మెటీరియల్‌లకు లింక్‌లను అందజేస్తానని ప్రొఫెసర్ వాగ్దానం చేశాడు, తద్వారా మీకు ఇంకా ఏదైనా అర్థం కాకపోతే, మీరు దాన్ని పూరించవచ్చు ఖాళీలు."