జావాలో ఉదాహరణ మరియు వారసత్వం

హాయ్! మునుపటి పాఠాలలో, మేము ఇప్పటికే వారసత్వ భావనతో క్లుప్తంగా పరిచయం చేసుకున్నాము. ఈ రోజు, మేము ఈ అంశంపై మళ్లీ తాకుతాము, కానీ మళ్లీ చాలా లోతుగా కాదు. భవిష్యత్తులో దీని గురించి మరింత వివరణాత్మక పాఠాన్ని మేము కలిగి ఉన్నాము. ఈ రోజు మనం కొన్ని ఆచరణాత్మక ఉదాహరణలను శీఘ్రంగా పరిశీలిస్తాము మరియు జావాలోని ఆసక్తికరమైన ఆపరేటర్‌తో పరిచయం పొందుతాము.

వారసత్వం

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

• ప్రతి తరగతిలో ఈ ఫీల్డ్‌లను సృష్టించండి (మీరు సృష్టించిన ప్రతి కొత్త కార్ క్లాస్‌కి వాటిని జోడించడం)
• అన్ని కార్లకు ఉమ్మడిగా ఉండే ఫీల్డ్‌లను Carపేరెంట్ క్లాస్‌లోకి తీసుకురండి, ఆపై క్లాస్ నుండి నిర్దిష్ట రకాల కార్ల కోసం అన్ని క్లాస్‌లను పొందేందుకు విస్తరించినCar కీవర్డ్‌ని ఉపయోగించండి .

సహజంగానే, రెండవ ఎంపిక చాలా సౌకర్యవంతంగా ఉంటుంది:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }
}

public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

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

public class Car {

   public void gas() {
       // Accelerate
   }

   public void brake() {
       // Brake
   }
}


public class F1Car extends Car {

   public void pitStop() {
      
       // Only race cars make pit stops
   }

   public static void main(String[] args) {
      
       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

మేము అన్ని కార్లకు సాధారణ పద్ధతులను తరగతికి జోడించాము Car. F1Carకానీ, "ఫార్ములా 1" రేస్ కార్లను సూచించే తరగతిని చూడండి . పిట్ స్టాప్‌లు (అత్యవసర కారు నిర్వహణ కోసం స్టాప్‌లు) రేసుల్లో మాత్రమే చేయబడతాయి, కాబట్టి మేము ఈ నిర్దిష్ట కార్యాచరణను సంబంధిత ఉత్పన్న తరగతికి జోడించాము.

ఆపరేటర్ యొక్క ఉదాహరణ

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

public class Truck extends Car {

   public static void main(String[] args) {

       Truck truck = new Truck();
       System.out.println(truck instanceof Car);
   }
}

అవుట్‌పుట్: నిజమేనని ఆపరేటర్ instanceofతిరిగి ఇస్తాడు , ఎందుకంటే మన దగ్గర ఒక వస్తువు ఉంది మరియుTruck అన్ని ట్రక్కులు కార్లు. తరగతి తరగతి Truckనుండి ఉద్భవించింది Car. అన్ని ట్రక్కులు సాధారణ పేరెంట్, తరగతి ఆధారంగా సృష్టించబడతాయి Car. instanceofఆపరేటర్ ఎలా ఉపయోగించబడుతుందో నిశితంగా పరిశీలించండి . మీరు దీన్ని వ్యవధి లేకుండా వ్రాస్తారు, ఎందుకంటే ఇది ఆపరేటర్, పద్ధతి కాదు ("ఆబ్జెక్ట్ ఇన్‌స్టాన్స్ ఆఫ్ క్లాస్"). మరొక విధంగా ప్రయత్నిద్దాం:

public static void main(String[] args) {

   Car car = new Car();
   System.out.println(car instanceof Truck);
}

అవుట్‌పుట్: తప్పు తరగతి Car(మరియు కారు వస్తువులు) తరగతి నుండి ఉద్భవించలేదు Truck. అన్ని ట్రక్కులు కార్లు, కానీ అన్ని కార్లు ట్రక్కులు కావు. Carవస్తువులు తరగతిపై ఆధారపడి ఉండవు Truck. మరో ఉదాహరణ:

public static void main(String[] args) {

   Car car = new Car();
   Truck truck = new Truck();
   System.out.println(car instanceof Object && truck instanceof Object);
}

అవుట్‌పుట్: నిజమే ఇక్కడ లాజిక్ కూడా చాలా సులభం: జావాలోని అన్ని తరగతులు, మీరు సృష్టించే తరగతులతో సహా, తరగతి నుండి క్రిందికి వస్తాయి Object(మీరు "ఆబ్జెక్ట్‌ని పొడిగిస్తుంది" అని వ్రాయనప్పటికీ-ఇది ఇప్పటికే సూచించబడింది). ఇది ఎలా మరియు ఎప్పుడు ఉపయోగపడుతుంది? పద్ధతిని అధిగమించేటప్పుడు ఆపరేటర్ instanceofసాధారణంగా ఉపయోగించబడుతుంది equals(). ఉదాహరణకు, equalsతరగతిలో పద్ధతి ఎలా అమలు చేయబడుతుందో ఇక్కడ ఉంది String:

public boolean equals(Object anObject) {
   if (this == anObject) {
       return true;
   }
   if (anObject instanceof String) {
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                       return false;
               i++;
           }
           return true;
       }
   }
   return false;
}

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