
Animal
దీన్ని అర్థం చేసుకోవడానికి, జంతువులను సూచించే మాతృ తరగతిని తీసుకుందాం మరియు speak
దానిలో ఒక పద్ధతిని రూపొందించండి:
public class Animal {
public void speak() {
System.out.println("Hello!");
}
}
మేము ఇప్పుడే మా ప్రోగ్రామ్ను వ్రాయడం ప్రారంభించినప్పటికీ, మీరు బహుశా సంభావ్య సమస్యను చూడవచ్చు: ప్రపంచం చాలా జంతువులతో నిండి ఉంది మరియు అవన్నీ విభిన్నంగా "మాట్లాడతాయి": పిల్లులు మియావ్, బాతులు క్వాక్, పాములు హిస్ మొదలైనవి. మా లక్ష్యం సులభం: 
meow()
మియావింగ్, హిస్సింగ్ మొదలైనవాటికి ఒక పద్ధతిని సృష్టించే బదులు , ఈ పద్ధతిని పిలిస్తే hiss()
పాము ఈల చేయడానికి, పిల్లి మియావ్ చేయడానికి మరియు కుక్క మొరిగేలా కోరుకుంటున్నాము . ఓవర్రైడింగ్ పద్ధతినిspeak()
ఉపయోగించి మనం దీన్ని సులభంగా సాధించవచ్చు . వికీపీడియా ఈ పదాన్ని ఈ క్రింది విధంగా వివరిస్తుంది: పద్ధతి ఓవర్రైడింగ్, ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్లో, సబ్క్లాస్ లేదా చైల్డ్ క్లాస్ దాని సూపర్ క్లాస్లు లేదా పేరెంట్ క్లాస్లలో ఒకదాని ద్వారా ఇప్పటికే అందించబడిన పద్ధతి యొక్క నిర్దిష్ట అమలును అందించడానికి అనుమతించే భాషా లక్షణం. అది ప్రాథమికంగా సరైనది. ఓవర్రైడింగ్ చేయడం వలన మీరు పేరెంట్ క్లాస్ యొక్క కొంత పద్ధతిని తీసుకోవచ్చు మరియు ప్రతి ఉత్పన్న తరగతిలో మీ స్వంత అమలును వ్రాయవచ్చు. పిల్లల తరగతిలో కొత్త అమలు పేరెంట్లో ఉన్నదాన్ని "భర్తీ చేస్తుంది". ఒక ఉదాహరణతో ఇది ఎలా ఉంటుందో చూద్దాం. మన తరగతికి చెందిన 4 మంది వారసులను సృష్టిద్దాం Animal
:
public class Bear extends Animal {
@Override
public void speak() {
System.out.println("Growl!");
}
}
public class Cat extends Animal {
@Override
public void speak() {
System.out.println("Meow!");
}
}
public class Dog extends Animal {
@Override
public void speak() {
System.out.println("Woof!");
}
}
public class Snake extends Animal {
@Override
public void speak() {
System.out.println("Hiss!");
}
}
భవిష్యత్తు కోసం ఇక్కడ ఒక చిన్న లైఫ్హాక్ ఉంది: పేరెంట్ క్లాస్ యొక్క పద్ధతులను భర్తీ చేయడానికి, IntelliJ IDE లో ఉత్పన్నమైన తరగతి కోడ్లోకి వెళ్లి , Ctrl+O నొక్కండి మరియు మెను నుండి ఓవర్రైడ్ పద్ధతులను ఎంచుకోండి... మొదటి నుండి హాట్కీలను ఉపయోగించడం అలవాటు చేసుకోండి. వారు కోడింగ్ని వేగవంతం చేస్తారు! కావలసిన ప్రవర్తనను పొందడానికి, మేము కొన్ని పనులను చేసాము:
- ప్రతి డిసెండెంట్ క్లాస్లో, పేరెంట్ క్లాస్లోని పద్ధతి వలె అదే పేరుతో మేము ఒక పద్ధతిని సృష్టించాము.
-
మేము కేవలం పేరెంట్ క్లాస్లో ఉన్న పద్ధతికి అదే పేరు పెట్టడం లేదని కంపైలర్కి చెప్పాము, కానీ మేము దాని ప్రవర్తనను భర్తీ చేయాలనుకుంటున్నాము. కంపైలర్కి ఈ "సందేశం" @Override ఉల్లేఖనం ద్వారా తెలియజేయబడుతుంది.
ఒక పద్ధతి పైన ఉన్న @ఓవర్రైడ్ ఉల్లేఖనం కంపైలర్కి (అలాగే మీ కోడ్ని చదివే ఇతర ప్రోగ్రామర్లు) చెబుతుంది, "చింతించకండి. ఇది పొరపాటు లేదా పర్యవేక్షణ కాదు. ఈ పద్ధతి ఇప్పటికే ఉందని నాకు తెలుసు మరియు నేను దానిని భర్తీ చేయాలనుకుంటున్నాను . - మేము ప్రతి సంతతి తరగతికి అవసరమైన అమలును వ్రాసాము. పద్ధతి
speak()
అని పిలిచినప్పుడు, పాము బుసలు కొట్టాలి, ఎలుగుబంటి కేకలు వేయాలి, మొదలైనవి.
public class Main {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
Animal animal3 = new Bear();
Animal animal4 = new Snake();
animal1.speak();
animal2.speak();
animal3.speak();
animal4.speak();
}
}
కన్సోల్ అవుట్పుట్: వూఫ్! మిఅవ్! కేక! హిస్! అద్భుతం, ప్రతిదీ తప్పక పని చేస్తుంది! మేము మాతృ తరగతికి చెందిన 4 రిఫరెన్స్ వేరియబుల్లను సృష్టించాము Animal
మరియు వాటికి సంతతి తరగతులకు చెందిన 4 విభిన్న వస్తువులను కేటాయించాము. ఫలితంగా, ప్రతి వస్తువు భిన్నంగా ప్రవర్తిస్తుంది. ప్రతి ఉత్పన్నమైన తరగతులకు, ఓవర్రైడ్ speak()
పద్ధతి ఇప్పటికే ఉన్న speak()
క్లాస్ పద్ధతిని భర్తీ చేస్తుంది Animal
(ఇది కన్సోల్లో "మాట్లాడటం:"ని ప్రదర్శిస్తుంది). 
-
ఓవర్రైడ్ పద్ధతి తప్పనిసరిగా పేరెంట్ క్లాస్లోని పద్ధతి వలె అదే వాదనలను కలిగి ఉండాలి.
speak
పేరెంట్ క్లాస్ యొక్క పద్ధతిని ఇన్పుట్గా తీసుకుంటే ,String
డిసెండెంట్ క్లాస్లోని ఓవర్రైడ్ పద్ధతి కూడా తప్పనిసరిగాString
ఇన్పుట్గా తీసుకోవాలి. లేకపోతే, కంపైలర్ లోపాన్ని సృష్టిస్తుంది:public class Animal { public void speak(String s) { System.out.println("Speaking: " + s); } } public class Cat extends Animal { @Override // Error! public void speak() { System.out.println("Meow!"); } }
-
ఓవర్రైడ్ పద్ధతి తప్పనిసరిగా పేరెంట్ క్లాస్లోని పద్ధతి వలె తిరిగి వచ్చే రకాన్ని కలిగి ఉండాలి.
లేకపోతే, మేము సంకలన దోషాన్ని పొందుతాము:
public class Animal { public void speak() { System.out.println("Hello!"); } } public class Cat extends Animal { @Override public String speak() { // Error! System.out.println("Meow!"); return "Meow!"; } }
-
ఓవర్రైడ్ పద్ధతి యొక్క యాక్సెస్ మాడిఫైయర్ కూడా అసలైన దానికి భిన్నంగా ఉండకూడదు:
public class Animal { public void speak() { System.out.println("Hello!"); } } public class Cat extends Animal { @Override private void speak() { // Error! System.out.println("Meow!"); } }
speak()
విభిన్న పద్ధతుల సమూహం కాకుండా అందరికీ ఒకే పద్ధతి, ఉదా bark()
, meow()
మొదలైనవి.
GO TO FULL VERSION