జావాలో OOP భావనలు

జావా యొక్క గొప్ప బలాలలో ఒకటి ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP). అందుకే ఈ భాష బాగా ప్రాచుర్యం పొందింది మరియు ఏ పరిమాణంలోనైనా ప్రాజెక్ట్‌లకు బాగా సరిపోతుంది. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ అంటే ఏమిటి? ఇది మ్యాజిక్ కాదు, కానీ మీరు నిజంగా దానిలోకి ప్రవేశిస్తే అది మాయాజాలంగా అనిపించవచ్చు. OOP అనేది మీ సాఫ్ట్‌వేర్‌ను ఎలా నిర్మించాలనే దాని గురించి. ఇది సాఫ్ట్‌వేర్‌ను సమర్థవంతంగా అభివృద్ధి చేయడానికి మరియు ఉపయోగించడానికి జావా వస్తువుల మధ్య కొన్ని నిర్దిష్ట పరస్పర చర్యలను మరియు సంబంధాలను సృష్టించడానికి మిమ్మల్ని అనుమతించే జావాలోని ఓప్ కాన్సెప్ట్‌ల సమూహం లేదా ఇది ఒక భావన. క్లాసికల్ OOP 3 + 1 ప్రధాన భావనలను కలిగి ఉంటుంది. క్లాసిక్‌లతో ప్రారంభిద్దాం.

ఎన్కప్సులేషన్

డేటా ఎన్‌క్యాప్సులేషన్ అనేది బాహ్య ప్రపంచం నుండి అంతర్గత డేటాను దాచడం మరియు పబ్లిక్‌గా బహిర్గతమయ్యే పద్ధతుల ద్వారా మాత్రమే దాన్ని యాక్సెస్ చేయడం. అంటే ఏమిటి? ఏ డేటా? ఎవరి నుండి దాస్తున్నారు? దాచడం అంటే తరగతిలోని డేటా సభ్యులకు (ఫీల్డ్‌లు) ప్రత్యక్ష ప్రాప్యతను పరిమితం చేయడం.

జావాలో ఇది ఎలా పని చేస్తుంది:

1. ఫీల్డ్‌లు ప్రైవేట్‌గా ఉంటాయి
2. తరగతిలోని ప్రతి ఫీల్డ్ రెండు ప్రత్యేక పద్ధతులను పొందుతుంది: పొందేవాడు మరియు సెట్టర్. పొందే పద్ధతులు ఫీల్డ్ విలువను తిరిగి ఇస్తాయి. సెట్టర్ పద్ధతులు ఫీల్డ్ విలువను పరోక్షంగా కానీ అనుమతించదగిన విధంగా మార్చడానికి మిమ్మల్ని అనుమతిస్తాయి.

జావా కోడ్‌లో ఎన్‌క్యాప్సులేషన్ యొక్క ఉదాహరణ:

public class Student {
private int age;
private String name;

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this:  firstStudent.name = "John";
}
}

మీరు ఎన్‌క్యాప్సులేషన్‌ను ఎందుకు ఉపయోగించాలి?

మీ కోడ్‌ని మార్చడాన్ని సులభతరం చేయడమే ప్రధాన కారణం. మీరు హాకీ పాఠశాల కోసం దరఖాస్తును కలిగి ఉన్నారని ఊహించుకోండి మరియు అతను లేదా ఆమె పాఠశాలలో నమోదు చేసుకున్నప్పుడు విద్యార్థి పేరు మరియు వయస్సును నిల్వ చేసే రెండు ఫీల్డ్‌లతో హాకీ స్టూడెంట్ క్లాస్ ఉంది . ఇలాంటిది ఏదైనా:

public class HockeyStudent {
public String name;
public  int ageOfEnrollment;
}

ageOfEnrollment ఫీల్డ్ పబ్లిక్‌గా ఉంది, గెట్టర్‌లు లేదా సెట్టర్‌లు లేవు... ఈ తరగతిని అనేక ఇతర తరగతులు ఉపయోగిస్తున్నారు మరియు కొంతమంది డెవలపర్ ఒక పూర్ణాంక ఫీల్డ్ సరిపోదని నిర్ణయించే వరకు ప్రతిదీ సరిగ్గానే ఉంది . కొహోర్ట్‌లోని కొంతమంది హాకీ ఆటగాళ్ళు వారి తోటివారి కంటే దాదాపు ఒక సంవత్సరం పెద్దవారు, కాబట్టి వారు పుట్టిన నెలను బట్టి వారిని రెండు గ్రూపులుగా విభజించడం మరింత సౌకర్యవంతంగా ఉంటుంది. కాబట్టి ageOfEnrollment ఫీల్డ్‌ను పూర్ణాంక శ్రేణికి మార్చాలి (int[][]) : మొదటి సంఖ్య పూర్తి సంవత్సరాలకు మరియు రెండవది నెలలకు. ఇప్పుడు మీరు విద్యార్థి తరగతిని ఉపయోగించే అన్ని కోడ్‌లను రీఫాక్టర్ చేయాలి ! కానీ మీ వయస్సు నమోదు అయితేఫీల్డ్ ప్రైవేట్ మరియు మీకు గెట్టర్‌లు మరియు సెట్టర్‌లు ఉన్నాయి, అప్పుడు ప్రతిదీ సులభం అవుతుంది. విద్యార్థి వయస్సును నిర్ణయించాల్సిన అవసరం మారినట్లయితే, setAgeOfEnrollment() సెట్టర్ పద్ధతిలో లాజిక్‌ను అప్‌డేట్ చేయండి మరియు మీ తరగతులు ఎలాంటి సమస్యలు లేకుండా విద్యార్థిని ఉపయోగించడం కొనసాగించవచ్చు ! ఈ ఉదాహరణ కొంతవరకు రూపొందించబడింది, అయితే ఎన్‌క్యాప్సులేషన్‌ను ఉపయోగించడం గొప్ప ఆలోచన అని ఇది వివరిస్తుందని నేను ఆశిస్తున్నాను.

వారసత్వం

ఈ సూత్రం ఎటువంటి ఆచరణాత్మక అనుభవం లేకుండా కూడా అర్థం చేసుకోవడం సులభం. మిమ్మల్ని మీరు పునరావృతం చేయవద్దు (DRY) వారసత్వ భావన యొక్క నినాదం కావచ్చు. మాతృ తరగతి యొక్క ఫీల్డ్‌లు మరియు పద్ధతులను పునర్నిర్వచించకుండా వారసత్వంగా పొందే పిల్లల తరగతిని సృష్టించడానికి వారసత్వం మిమ్మల్ని అనుమతిస్తుంది. ఖచ్చితంగా, మీరు పిల్లల తరగతిలో పేరెంట్ క్లాస్ ఫీల్డ్‌లు మరియు పద్ధతులను భర్తీ చేయవచ్చు, కానీ ఇది అవసరం లేదు. ఇంకా ఏమిటంటే, మీరు పిల్లల తరగతిలో కొత్త రాష్ట్రాలు మరియు ప్రవర్తనలను జోడించవచ్చు. పేరెంట్ క్లాస్‌లను కొన్నిసార్లు సూపర్‌క్లాస్‌లు లేదా బేస్ క్లాస్‌లు అని పిలుస్తారు మరియు పిల్లల తరగతులను సబ్‌క్లాస్‌లుగా పిలుస్తారు. జావా యొక్క విస్తారిత కీవర్డ్ కోడ్‌లో వారసత్వ సూత్రాన్ని అమలు చేయడానికి ఉపయోగించబడుతుంది.

జావాలో ఇది ఎలా పని చేస్తుంది:

1. మాతృ తరగతిని సృష్టించండి.
2. విస్తరించిన కీవర్డ్‌ని ఉపయోగించి పిల్లల తరగతిని సృష్టించండి .
3. చైల్డ్ క్లాస్ కన్స్ట్రక్టర్‌లో, పేరెంట్ ఫీల్డ్‌లను సెట్ చేయడానికి సూపర్(పేరెంట్‌ఫీల్డ్1, పేరెంట్‌ఫీల్డ్2, ...) పద్ధతిని ఉపయోగించండి.

కొన్ని నియమాలు:

1. ఒక తరగతికి ఒక పేరెంట్ మాత్రమే ఉండాలి.
2. ఒక పేరెంట్ క్లాస్ అనేక చైల్డ్ క్లాస్‌లను కలిగి ఉండవచ్చు.
3. పిల్లల తరగతి దాని స్వంత పిల్లల తరగతులను కలిగి ఉంటుంది.

జావా కోడ్‌లో వారసత్వానికి ఉదాహరణ

ఫోన్ క్లాస్‌ని క్రియేట్ చేద్దాం .

public class Phone {
    int price;
    double weight;

// Constructor
public Phone(int price, double weight) {
        this.price = price;
        this.weight = weight;
    }

    void orderPhone(){
        System.out.println("Ordering phone...");
    }
}

వాస్తవానికి, వివిధ రకాల ఫోన్‌లు ఉన్నాయి, కాబట్టి రెండు చైల్డ్ క్లాస్‌లను క్రియేట్ చేద్దాం: ఒకటి ఆండ్రాయిడ్ ఫోన్‌ల కోసం మరియు రెండవది ఐఫోన్‌ల కోసం. అప్పుడు మేము పేరెంట్ వద్ద లేని కొన్ని ఫీల్డ్‌లు మరియు పద్ధతులను జోడిస్తాము. మరియు మాతృ తరగతి కలిగి ఉన్న ఫీల్డ్‌లను ప్రారంభించడం కోసం కన్‌స్ట్రక్టర్‌లను కాల్ చేయడానికి సూపర్()ని ఉపయోగిస్తాము .

జావాలో వారసత్వానికి ఉదాహరణ

public class Android extends Phone {

// Some new fields
String androidVersion;
int screenSize;

    String secretDeviceCode;

// Constructor
    public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
        super(price, weight); // Android inherits Phone’s fields

        //this - reference to the current object
        //super - reference to the parent object

        this.androidVersion = androidVersion;
        this.screenSize = screenSize;
        this.secretDeviceCode = secretDeviceCode;
    }

	// New Android-specific method, does not exist in the Phone class
    void installNewAndroidVersion() {
        System.out.println("installNewAndroidVersion invoked...");

    }

}

public class IPhone extends Phone {

    boolean fingerPrint;

    public IPhone(int price, double weight, boolean fingerPrint) {
        super(price, weight);
        System.out.println("IPhone constructor was invoked...");
        this.fingerPrint = fingerPrint;
    }

    void deleteIPhoneFromDb() {
        System.out.println("deleteIPhoneFromDb invoked...");
    }

@Override // This is about polymorphism, see below
void orderPhone(){
        System.out.println("Ordering my new iPhone and deleting the old one...");
    }
}

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

బహురూపత

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

జావాలో దీని అర్థం ఏమిటి మరియు ఇది ఎలా పని చేస్తుంది:

జావాలో పాలిమార్ఫిజం అంటే ఏమిటి? సాధారణంగా, మీరు వివిధ ప్రయోజనాల కోసం ఒకే పద్ధతి పేరును ఉపయోగించవచ్చు. జావాలో రెండు రకాల పాలిమార్ఫిజం ఉన్నాయి: మెథడ్ ఓవర్‌రైడింగ్ (డైనమిక్ పాలిమార్ఫిజం) మరియు మెథడ్ ఓవర్‌లోడింగ్ (స్టాటిక్ పాలిమార్ఫిజం).

పద్ధతి ఓవర్‌రైడింగ్

మీరు చైల్డ్ క్లాస్‌లో పేరెంట్ క్లాస్ పద్ధతిని ఓవర్‌రైడ్ చేయవచ్చు, అది వేరే విధంగా పని చేయవలసి వస్తుంది. ప్లే() పద్ధతితో మ్యూజిషియన్ పేరెంట్ క్లాస్‌ని క్రియేట్ చేద్దాం .

జావా కోడ్‌లో పాలిమార్ఫిజం యొక్క ఉదాహరణ

public class Musician {
    String name;
    int age;

    // Default constructor
    public Musician() {
    }

    // Parameterized constructor
    public Musician(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void play() {
        System.out.println("I am playing my instrument...");
    }
}

వేర్వేరు సంగీతకారులు వేర్వేరు వాయిద్యాలను ఉపయోగిస్తారు. పియానిస్ట్ మరియు వయోలిన్ వాద్యకారుడు అనే రెండు పిల్లల తరగతులను క్రియేట్ చేద్దాం . పాలిమార్ఫిజమ్‌కు ధన్యవాదాలు, ప్రతి ఒక్కటి ప్లే() పద్ధతి యొక్క దాని స్వంత వెర్షన్‌ను అమలు చేస్తుంది . ఓవర్‌రైడ్ చేస్తున్నప్పుడు, మీరు @Override ఉల్లేఖనాన్ని ఉపయోగించవచ్చు , కానీ ఇది అవసరం లేదు.

public class Pianist extends Musician {

    String favoritePianoType;

    public Pianist(String name, int age, String favoritePianoType) {
        super(name, age);
        this.favoritePianoType = favoritePianoType;
    }


    @Override
void play(){
        System.out.println("I am playing the piano...");
    }
}

వయోలిన్ ప్లేయర్ సోలో వాద్యకారుడు లేదా ఆర్కెస్ట్రా సభ్యుడు కావచ్చు. మన నాటకం() పద్ధతిని భర్తీ చేసేటప్పుడు దానిని పరిగణలోకి తీసుకుందాం .

public class Violinist extends Musician {
    boolean isSoloist;

public Violinist(String name, int age, boolean isSoloist) {
            super(name, age);
            this.isSoloist = isSoloist;
        }


    @Override
void play(){
if (isSoloist)
        System.out.println("I am playing the violin solo...");
else
System.out.println("I am playing the violin in an orchestra...");

    }
}

డెమో క్లాస్‌ని క్రియేట్ చేద్దాం , అందులో మనం మూడు ఆబ్జెక్ట్‌లను క్రియేట్ చేస్తాము, గతంలో సృష్టించిన క్లాస్‌లలో ఒక్కోదానికి ఒక్కో ఉదాహరణ. ఎలాంటి ఫలితాలు వస్తాయో చూడాలి.

public class Demo {
  public static void main(String[] args) {
  Musician musician = new Musician();
  Violinist violinist = new Violinist("John", 32, true);
  Pianist pianist = new Pianist("Glen", 30, "Acoustic");

  System.out.println("Musician said:");
  musician.play();
  System.out.println("Violinist said:");
  violinist.play();
  System.out.println("Pianist said:");
  pianist.play();
    }
}

మనం పొందేది ఇక్కడ ఉంది:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo…
Pianist said:
I am playing the piano...

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

public class Pianist extends Musician {

    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
}

ఇప్పుడు డెమో క్లాస్‌లో మన మెయిన్() పద్ధతిని పిలుద్దాం . ఇక్కడ ఫలితం ఉంది:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...

ఓవర్‌లోడింగ్ పద్ధతి

పద్ధతి ఓవర్‌లోడింగ్ అంటే ఒకే తరగతిలో ఒకే పేరుతో వివిధ పద్ధతులను ఉపయోగించడం. వాటి పారామితుల సంఖ్య, క్రమం లేదా రకాల పరంగా అవి తప్పనిసరిగా భిన్నంగా ఉండాలి. ఒక పియానిస్ట్ అకౌస్టిక్ పియానో ​​మరియు ఎలక్ట్రిక్ పియానో ​​వాయించగలడని అనుకుందాం. ఎలక్ట్రిక్ ప్లే చేయడానికి, సంగీతకారుడికి విద్యుత్ అవసరం. రెండు వేర్వేరు ప్లే() పద్ధతులను రూపొందిద్దాం . పారామితులు లేకుండా మొదటిది, అకౌస్టిక్ పియానో ​​కోసం, మరియు రెండవది విద్యుత్ అందుబాటులో ఉందో లేదో సూచించే పారామీటర్‌తో.

public class Pianist extends Musician {

    String name;
    int age;
    String favoritePianoType;

    @Override
    void play(){
        super.play();
        System.out.println("I am playing the piano...");
    }
    void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            System.out.println("I am playing the piano...");
        }
        else System.out.println("I can't play this without electricity.");
    }
}

మార్గం ద్వారా, మీరు ఈ పద్ధతిలో రెండవ ప్లే(బూలియన్) పద్ధతిలో మొదటి ప్లే() పద్ధతిని ఉపయోగించవచ్చు:

void play(boolean isElectricity){
        if (isElectricity) {
            System.out.println("The electricity is on.");
            play();
        }
        else System.out.println("I can't play this without electricity.");
    }

మా ఓవర్‌లోడింగ్‌ని ప్రదర్శించడానికి మా డెమో క్లాస్‌కి కొన్ని లైన్‌లను జోడిద్దాం :

public class Demo {
    public static void main(String[] args) {

        Musician musician = new Musician();
        Violinist violinist = new Violinist("John", 23, true);
        Pianist pianist = new Pianist("Glen", 30, "Acoustic");

        System.out.println("Musician said:");
        musician.play();
        System.out.println("Violinist said:");
        violinist.play();
        System.out.println("Pianist said:");
        pianist.play();
        System.out.println("The pianist will now try the electric piano:");
        pianist.play(true);
        System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
        pianist.play(false);
    }
}

ఇక్కడ ఫలితం ఉంది:

Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.

దాని పారామితులు మరియు ఆబ్జెక్ట్ రకం ఆధారంగా ఏ పద్ధతిని ఉపయోగించాలో జావాకు తెలుసు. అది బహురూపం.

సంగ్రహణ

మేము తరగతిని నిర్వచించినప్పుడు, మేము ఏదో ఒక నమూనాను రూపొందించడానికి ప్రయత్నిస్తున్నాము. ఉదాహరణకు, మేము వివిధ రేస్ కార్లతో MyRacer అనే వీడియో గేమ్‌ని వ్రాస్తున్నామని అనుకుందాం. ఒక ఆటగాడు వాటిలో ఒకదాన్ని ఎంచుకోవచ్చు, ఆపై దాన్ని నవీకరించవచ్చు లేదా వేరొకదాన్ని కొనుగోలు చేయవచ్చు. కాబట్టి... కారు అంటే ఏమిటి? కారు అనేది చాలా క్లిష్టమైన విషయం, కానీ మనం రేసింగ్ వీడియో గేమ్‌ని (డ్రైవింగ్ సిమ్యులేటర్‌కి విరుద్ధంగా) రూపొందించడానికి ప్రయత్నిస్తుంటే, అందులో ఉన్న అన్ని వేల గేర్లు మరియు గ్యాస్‌కెట్‌లను మనం వివరించాల్సిన అవసరం లేదు. మాకు దాని మోడల్, టాప్ స్పీడ్, యుక్తి లక్షణాలు, ధర, రంగు అవసరం… మరియు బహుశా అది సరిపోతుంది. అది మా ఆట కోసం కారు మోడల్. తరువాత MyRacer 2లో, రహదారిపై నిర్వహణను ప్రభావితం చేసే టైర్లను జోడించాలని మేము నిర్ణయించుకున్నాము. ఇక్కడ మోడల్ భిన్నంగా ఉంటుంది, ఎందుకంటే మేము మరిన్ని వివరాలను జోడించాము. వీలు' s ఒక వస్తువు యొక్క ముఖ్యమైన (లేదా అవసరమైన) లక్షణాలను మాత్రమే గుర్తించే ప్రక్రియ మరియు ఏదైనా అసంబద్ధమైన వివరాలను విస్మరించే ప్రక్రియగా డేటా సంగ్రహణను నిర్వచిస్తుంది. సంగ్రహణ యొక్క వివిధ స్థాయిలు ఉన్నాయి. ఉదాహరణకు, మీరు బస్సులో ప్రయాణీకులైతే, మీ బస్సు ఎలా ఉంటుందో మరియు ఎక్కడికి వెళుతుందో మీరు తెలుసుకోవాలి, కానీ దానిని ఎలా నడపాలి అని మీరు తెలుసుకోవలసిన అవసరం లేదు. మీరు బస్సు డ్రైవర్ అయితే, మీరు కొత్త బస్సును ఎలా సృష్టించాలో తెలుసుకోవాల్సిన అవసరం లేదు — మీరు దానిని ఎలా నడపాలి అని మాత్రమే తెలుసుకోవాలి. కానీ మీరు బస్సు తయారీదారు అయితే, మీరు తక్కువ స్థాయి సంగ్రహణకు వెళ్లాలి, ఎందుకంటే బస్సు డిజైన్ యొక్క వివరాలు మీకు చాలా ముఖ్యమైనవి. నా ఉద్దేశ్యం మీకు అర్థమైందని ఆశిస్తున్నాను. మీ బస్సు ఎలా ఉంటుందో మరియు అది ఎక్కడికి వెళుతుందో మీరు తెలుసుకోవాలి, కానీ దానిని ఎలా నడపాలి అని మీరు తెలుసుకోవలసిన అవసరం లేదు. మీరు బస్సు డ్రైవర్ అయితే, మీరు కొత్త బస్సును ఎలా సృష్టించాలో తెలుసుకోవాల్సిన అవసరం లేదు — మీరు దానిని ఎలా నడపాలి అని మాత్రమే తెలుసుకోవాలి. కానీ మీరు బస్సు తయారీదారు అయితే, మీరు తక్కువ స్థాయి సంగ్రహణకు వెళ్లాలి, ఎందుకంటే బస్సు డిజైన్ యొక్క వివరాలు మీకు చాలా ముఖ్యమైనవి. నా ఉద్దేశ్యం మీకు అర్థమైందని ఆశిస్తున్నాను. మీ బస్సు ఎలా ఉంటుందో మరియు అది ఎక్కడికి వెళుతుందో మీరు తెలుసుకోవాలి, కానీ దానిని ఎలా నడపాలి అని మీరు తెలుసుకోవలసిన అవసరం లేదు. మీరు బస్సు డ్రైవర్ అయితే, మీరు కొత్త బస్సును ఎలా సృష్టించాలో తెలుసుకోవాల్సిన అవసరం లేదు — మీరు దానిని ఎలా నడపాలి అని మాత్రమే తెలుసుకోవాలి. కానీ మీరు బస్సు తయారీదారు అయితే, మీరు తక్కువ స్థాయి సంగ్రహణకు వెళ్లాలి, ఎందుకంటే బస్సు డిజైన్ యొక్క వివరాలు మీకు చాలా ముఖ్యమైనవి. నా ఉద్దేశ్యం మీకు అర్థమైందని ఆశిస్తున్నాను.

జావాలో ఇది ఎలా పని చేస్తుంది:

జావాలో లేదా OOPలో - అత్యల్ప (అత్యంత నిర్దిష్టమైన) నుండి అత్యధిక (అత్యంత వియుక్త) వరకు నాలుగు స్థాయిల సంగ్రహణను రూపొందిద్దాం.

1. సంగ్రహణ యొక్క అత్యల్ప స్థాయి ఒక నిర్దిష్ట వస్తువు. ఇది ఒక నిర్దిష్ట తరగతికి చెందిన లక్షణాల సమితితో కూడిన ఎంటిటీ. ఇది నిర్దిష్ట ఫీల్డ్ విలువలను కలిగి ఉంది

2. వస్తువులను సృష్టించడానికి ఒక టెంప్లేట్ ఒక తరగతి. ఇది సారూప్య లక్షణాలు మరియు అంతర్గత నిర్మాణంతో కూడిన వస్తువుల సమితి యొక్క వివరణ.

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

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

BTW, జావా 8 లేదా తర్వాత, ఇంటర్‌ఫేస్‌లు అబ్‌స్ట్రాక్ట్ పద్ధతులు మరియు స్థిరాంకాలు మాత్రమే కాకుండా డిఫాల్ట్ మరియు స్టాటిక్ పద్ధతులను కూడా కలిగి ఉంటాయి. జావాలో, ఒక ఇంటర్‌ఫేస్ ఒక ప్రవర్తనను నిర్వచిస్తుంది, అయితే ఒక నైరూప్య తరగతి ఒక సోపానక్రమాన్ని సృష్టించడానికి ఉపయోగించబడుతుంది. బహుళ తరగతుల ద్వారా ఒక ఇంటర్‌ఫేస్‌ని అమలు చేయవచ్చు.

జావా కోడ్‌లోని ఇంటర్‌ఫేస్‌కి ఉదాహరణ

interface Human {
	public void struggle();
	public void protect();
}

interface Vulcan {
	int angleOfPointyEars;
	public void turnOffEmotions(boolean isOn);
	public void telepathy();
}

మీరు ఒకటి కంటే ఎక్కువ ఇంటర్‌ఫేస్‌లను అమలు చేయవచ్చు

The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
	public void protect() {
System.out.println("You are under my protection!”);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
	public void telepathy() {
System.out.println("Connecting to your brain...");
}

}

ప్రారంభ విద్యార్థుల కోసం, ఇది జావాలో ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క అన్ని ప్రధాన భావనలను కవర్ చేస్తుంది. 4 ప్రధాన OOP సూత్రాలతో పాటు, జావాలో అనుబంధం, అగ్రిగేషన్ మరియు కూర్పు కూడా ఉన్నాయి. మీరు వాటిని "అదనపు OOP సూత్రాలు" అని పిలవవచ్చు. వారు వారి స్వంత ప్రత్యేక కథనానికి అర్హులు.