వారసత్వం

వారసత్వం అనేది OOP యొక్క ప్రాథమిక విధానం, ఇది ఒక తరగతిని (చైల్డ్ క్లాస్ లేదా సబ్‌క్లాస్ అని పిలుస్తారు) మరొక తరగతి నుండి ఫీల్డ్‌లు మరియు పద్ధతులను వారసత్వంగా పొందేందుకు అనుమతిస్తుంది (పేరెంట్ క్లాస్ లేదా సూపర్ క్లాస్ అని పిలుస్తారు).

ఇది కోడ్ పునర్వినియోగాన్ని ప్రోత్సహిస్తుంది మరియు అనవసరమైన పునరావృత్తులు నివారిస్తుంది.

extendsతో తరగతిని పొడిగించడం

జావాలో, మేము extends కీవర్డ్‌ని ఉపయోగిస్తాము:

class Vehicle {
    protected int speed; // 'protected' makes the field visible to subclasses

    public void honk() {
        System.out.println("Beep beep!");
    }
}

class Car extends Vehicle {
    // Car automatically inherits the speed field and the honk() method
}

కన్స్ట్రక్టర్ మరియు super() కీవర్డ్

సూపర్‌క్లాస్‌లో పారామీటర్‌లను ఆమోదించే కన్‌స్ట్రక్టర్ ఉంటే, సబ్‌క్లాస్ తప్పనిసరిగా దాని కన్‌స్ట్రక్టర్‌లో super(...)ని మొదటి స్టేట్‌మెంట్గా ఉపయోగించి స్పష్టంగా కాల్ చేయాలి:

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }
}

class Student extends Person {
    int studentId;

    public Student(String name, int studentId) {
        super(name); // Invokes the constructor of Person
        this.studentId = studentId;
    }
}

పద్ధతి ఓవర్‌రైడింగ్ (@Override)

సూపర్‌క్లాస్ నుండి సంక్రమించిన పద్ధతికి సబ్‌క్లాస్ దాని స్వంత నిర్దిష్ట అమలును అందించగలదు. ఈ ఆపరేషన్‌ను ఓవర్‌రైడింగ్ (పద్ధతి ఓవర్‌రైడింగ్) అని పిలుస్తారు మరియు ఇది @Override ఉల్లేఖనం ద్వారా సూచించబడుతుంది.

class Animal {
    public void makeSound() {
        System.out.println("Rumore generico");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Miao!");
    }
}

protected మాడిఫైయర్

protected యాక్సెస్ మాడిఫైయర్ వారసత్వంలో కీలక పాత్ర పోషిస్తుంది. private కాకుండా, సభ్యులను ఒకే తరగతిలో మాత్రమే కనిపించేలా చేస్తుంది, protected వారు వేర్వేరు ప్యాకేజీలలో నివసిస్తున్నప్పటికీ, ఒకే ప్యాకేజీలో మరియు అన్ని సబ్‌క్లాస్‌ల ద్వారా ఫీల్డ్‌లు మరియు పద్ధతులకు ప్రాప్యతను అనుమతిస్తుంది.

superతో తల్లిదండ్రుల సభ్యులను యాక్సెస్ చేస్తోంది

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

class Animal {
    public void sleep() {
        System.out.println("Zzz");
    }
}

class Cat extends Animal {
    @Override
    public void sleep() {
        super.sleep(); // Executes the behavior of Animal
        System.out.println("The cat purrs while sleeping.");
    }
}

జావాలో ఒకే వారసత్వం

జావాలో, ఒక తరగతి ఒక తరగతి మాత్రమే (ఒకే వారసత్వం) విస్తరించవచ్చు. బహుళ తరగతుల (బహుళ వారసత్వం) నుండి ప్రత్యక్ష వారసత్వం అనుమతించబడదు; ఉదాహరణకు, class Cat extends Animal, Mammal సంకలన దోషాన్ని కలిగిస్తుంది. ఈ డిజైన్ ఎంపిక "డైమండ్ సమస్య" అని పిలవబడే అస్పష్టతలను నివారిస్తుంది (రెండు సూపర్ క్లాస్‌లు ఒకే పద్ధతిని వేర్వేరు అమలులతో నిర్వచించినప్పుడు). ఈ పరిమితిని అధిగమించడానికి, జావా ఇంటర్‌ఫేస్‌లు అనే కాన్సెప్ట్‌ను పరిచయం చేస్తుంది, దీనిని మేము తదుపరి మాడ్యూల్‌లో అన్వేషిస్తాము.

మీరే ప్రయత్నించండి