వారసత్వం అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో ఒక ప్రాథమిక భావన, ఇది ఇప్పటికే ఉన్న తరగతుల ఆధారంగా కొత్త తరగతులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. జావాలో, కీవర్డ్‌ని ఉపయోగించి వారసత్వం సాధించబడుతుంది extendsమరియు ఇది కోడ్‌ని మళ్లీ ఉపయోగించేందుకు మరియు సంబంధిత తరగతుల సోపానక్రమాలను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తుంది.
జావా వారసత్వం యొక్క కొన్ని కీలక అంశాలు మరియు అంశాలు ఇక్కడ ఉన్నాయి:
సూపర్‌క్లాస్ మరియు సబ్‌క్లాస్: జావాలో, ఒక తరగతి ఒక సూపర్‌క్లాస్ నుండి వారసత్వంగా పొందవచ్చు మరియు బహుళ సబ్‌క్లాస్‌లను కలిగి ఉంటుంది. సూపర్‌క్లాస్ అనేది సబ్‌క్లాస్ ఉద్భవించిన ప్రస్తుత తరగతి. సబ్‌క్లాస్ సూపర్‌క్లాస్ నుండి ఫీల్డ్‌లు, పద్ధతులు మరియు ఇతర సభ్యులను వారసత్వంగా పొందవచ్చు.
ఓవర్‌రైడింగ్ పద్ధతులు: సబ్‌క్లాస్ సూపర్‌క్లాస్ నుండి ఒక పద్ధతిని వారసత్వంగా పొందినప్పుడు, అది దాని స్వంత అమలును అందించడానికి పద్ధతిని భర్తీ చేస్తుంది. ఇది సబ్‌క్లాస్‌లో వారసత్వ పద్ధతి యొక్క ప్రవర్తనను అనుకూలీకరించడానికి మిమ్మల్ని అనుమతిస్తుంది.
యాక్సెస్ మాడిఫైయర్‌లు: జావాలో, యాక్సెస్ మాడిఫైయర్‌లు ఫీల్డ్‌లు, పద్ధతులు మరియు ఇతర సభ్యుల దృశ్యమానతను నియంత్రిస్తాయి. సబ్‌క్లాస్ సూపర్‌క్లాస్ నుండి సభ్యుడిని వారసత్వంగా పొందినప్పుడు, దాని యాక్సెస్ మాడిఫైయర్ దానిని అనుమతించినట్లయితే మాత్రమే అది సభ్యుడిని యాక్సెస్ చేయగలదు.
కన్స్ట్రక్టర్లు: జావాలో, సబ్‌క్లాస్ సృష్టించబడినప్పుడు, దాని సూపర్‌క్లాస్ కన్‌స్ట్రక్టర్‌ని కూడా అంటారు. సూపర్‌క్లాస్‌లో డిఫాల్ట్ కన్‌స్ట్రక్టర్ ఉంటే, అది స్వయంచాలకంగా పిలువబడుతుంది. సూపర్‌క్లాస్‌కు డిఫాల్ట్ కన్‌స్ట్రక్టర్ లేకపోతే, సబ్‌క్లాస్ తప్పనిసరిగా
superకీవర్డ్‌ని ఉపయోగించి సూపర్‌క్లాస్ కన్‌స్ట్రక్టర్‌లలో ఒకరిని ఖచ్చితంగా పిలవాలి.ఆబ్జెక్ట్ క్లాస్: జావాలోని ప్రతి క్లాస్ క్లాస్ నుండి వారసత్వంగా పొందుతుంది , ఇది , , మరియు
Objectవంటి పద్ధతుల యొక్క డిఫాల్ట్ అమలును అందిస్తుంది .toStringhashCodeequals
జావాలో వారసత్వాన్ని ఉపయోగించడం కోసం ఇక్కడ ఒక ఉదాహరణ ఉంది:
టైపుస్క్రిప్ట్public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void speak() {
System.out.println("Animal speaks");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void speak() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Animal("Generic Animal");
Dog dog = new Dog("Fido");
animal.speak(); // Output: "Animal speaks"
dog.speak(); // Output: "Dog barks"
}
}ఈ కోడ్ ఫీల్డ్ మరియు మెథడ్‌తో Animalక్లాస్‌ని నిర్వచిస్తుంది మరియు పద్ధతి నుండి వారసత్వంగా మరియు భర్తీ చేసే సబ్‌క్లాస్‌ని నిర్వచిస్తుంది . తరగతి ఒక ఉదాహరణను సృష్టిస్తుంది మరియు వారి పద్ధతులను పిలుస్తుంది , వారసత్వం మిమ్మల్ని కోడ్‌ని తిరిగి ఉపయోగించుకోవడానికి మరియు ప్రవర్తనను అనుకూలీకరించడానికి ఎలా అనుమతిస్తుంది అని ప్రదర్శిస్తుంది.namespeakDogAnimalspeakMainAnimalDogspeak
జావా యొక్క వారసత్వ విధానం కోడ్‌ని తిరిగి ఉపయోగించేందుకు మరియు సంబంధిత తరగతుల సోపానక్రమాలను నిర్వచించడానికి శక్తివంతమైన మార్గాన్ని అందిస్తుంది. సూపర్‌క్లాస్ నుండి ఫీల్డ్‌లు, పద్ధతులు మరియు ఇతర సభ్యులను వారసత్వంగా పొందడం ద్వారా, సబ్‌క్లాస్ దాని స్వంత అనుకూలీకరణలను అందించేటప్పుడు ఇప్పటికే ఉన్న ఫంక్షనాలిటీని నిర్మించగలదు.
