జావాలో వియుక్త తరగతులకు కాంక్రీట్ ఉదాహరణలు

హాయ్! జావాలో వియుక్త తరగతుల గురించి మాట్లాడుకుందాం .

తరగతులను "నైరూప్య" అని ఎందుకు పిలుస్తారు?

సంగ్రహణ అంటే ఏమిటో మీకు బహుశా గుర్తుండే ఉంటుంది — మేము ఇంతకు ముందు చర్చించాము :) మీరు మరచిపోయినట్లయితే, చింతించకండి. గుర్తుంచుకోండి, ఇది OOP సూత్రం అని చెబుతుంది, తరగతులను డిజైన్ చేసేటప్పుడు మరియు వస్తువులను సృష్టించేటప్పుడు, మీరు ఎంటిటీ యొక్క ప్రధాన లక్షణాలను మాత్రమే సూచించాలి మరియు ద్వితీయ వాటిని విస్మరించాలి. ఉదాహరణకు, మేము SchoolTeacherతరగతిని డిజైన్ చేస్తున్నట్లయితే, ఎత్తు అనేది ఉపాధ్యాయునికి అవసరమైన ఆస్తి కాదు. నిజానికి, ఈ లక్షణం ఉపాధ్యాయునికి ముఖ్యమైనది కాదు. కానీ మేము ఒక తరగతిని సృష్టిస్తున్నట్లయితే BasketballPlayer, ఎత్తు చాలా ముఖ్యమైన లక్షణాలలో ఒకటిగా ఉంటుంది. బాగా, ఒక వియుక్త తరగతిభవిష్యత్ తరగతుల సమూహానికి అత్యంత వియుక్తమైన, "కఠినమైన వర్క్‌పీస్". వర్క్‌పీస్ నేరుగా ఉపయోగించబడదు - ఇది చాలా "కఠినమైనది". కానీ ఇది భవిష్యత్ తరగతులు - నైరూప్య తరగతి యొక్క వారసులు - కలిగి ఉండే నిర్దిష్ట లక్షణ స్థితి మరియు ప్రవర్తనను నిర్వచిస్తుంది.

జావాలోని వియుక్త తరగతుల ఉదాహరణలు

కార్లతో ఒక సాధారణ ఉదాహరణను పరిగణించండి:

public abstract class Car {

   private String model;
   private String color;
   private int maxSpeed;
  
   public abstract void gas();

   public abstract void brake();

   public String getModel() {
       return model;
   }

   public void setModel(String model) {
       this.model = model;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getMaxSpeed() {
       return maxSpeed;
   }

   public void setMaxSpeed(int maxSpeed) {
       this.maxSpeed = maxSpeed;
   }
}

సరళమైన నైరూప్య తరగతి ఇలా కనిపిస్తుంది. మీరు గమనిస్తే, ప్రత్యేకంగా ఏమీ లేదు :) మనకు ఇది ఎందుకు అవసరం కావచ్చు? మొదట, ఇది మనకు అవసరమైన ఎంటిటీ యొక్క అత్యంత వియుక్త వివరణను అందిస్తుంది - కారు. వియుక్త కీవర్డ్ ఇక్కడ ఏదో అర్థం . వాస్తవ ప్రపంచంలో, "కేవలం కారు" లాంటిదేమీ లేదు. ట్రక్కులు, రేస్ కార్లు, సెడాన్లు, కూపేలు మరియు SUVలు ఉన్నాయి. మా అబ్‌స్ట్రాక్ట్ క్లాస్ కేవలం "బ్లూప్రింట్" మాత్రమే, దీనిని మేము నిర్దిష్ట కార్ క్లాస్‌లను రూపొందించడానికి ఉపయోగిస్తాము.

public class Sedan extends Car {
  
   @Override
   public void gas() {
       System.out.println("The sedan is accelerating!");
   }

   @Override
   public void brake() {
       System.out.println("The sedan is slowing down!");
   }
  
}

అనేక విధాలుగా, ఇది వారసత్వంపై పాఠాలలో మనం మాట్లాడిన దానితో సమానంగా ఉంటుంది. ఆ సందర్భంలో మాత్రమే మేము ఒక Carతరగతిని కలిగి ఉన్నాము, దీని పద్ధతులు వియుక్తమైనవి కావు. కానీ అటువంటి పరిష్కారం నైరూప్య తరగతులలో పరిష్కరించబడిన అనేక నష్టాలను కలిగి ఉంది. మొట్టమొదట, వియుక్త తరగతి యొక్క ఉదాహరణ సృష్టించబడదు:

public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // Error! The Car class is abstract!
   }
}

జావా సృష్టికర్త ఉద్దేశపూర్వకంగానే ఈ "లక్షణాన్ని" రూపొందించారు. మరోసారి, గుర్తుంచుకోండి: వియుక్త తరగతి అనేది భవిష్యత్ "సాధారణ" తరగతులకు బ్లూప్రింట్ మాత్రమే . మీకు బ్లూప్రింట్ కాపీలు అవసరం లేదు, సరియైనదా? అదేవిధంగా, అబ్‌స్ట్రాక్ట్ క్లాస్ యొక్క ఇన్‌స్టాన్స్‌లను సృష్టించాల్సిన అవసరం లేదు :) మరియు Carక్లాస్ అబ్‌స్ట్రాక్ట్ కాకపోతే, మేము దాని ఉదాహరణలను సులభంగా సృష్టించవచ్చు:

public class Car {

   private String model;
   private String color;
   private int maxSpeed;
  
   public void go() {
       // ...some logic
   }

   public  void brake() {
       // ...some logic
   }
}


public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // This is okay. The car is created.
   }
}

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

public abstract class Car {

   private String model;
   private String color;
   private int maxSpeed;

   public void gas() {
       System.out.println("Accelerating!");
   }

   public abstract void brake();
  
   // Getters and setters
}


public class Sedan extends Car {

   @Override
   public void brake() {
       System.out.println("The sedan is slowing down!");
   }

}

public class Main {

   public static void main(String[] args) {

       Sedan sedan = new Sedan();
       sedan.gas();
   }
}

కన్సోల్ అవుట్‌పుట్:

Accelerating!

మీరు చూడగలిగినట్లుగా, మేము వియుక్త తరగతిలో ఒక పద్ధతిని అమలు చేసాము, కానీ మరొకటి కాదు. ఫలితంగా, మా Sedanతరగతి యొక్క ప్రవర్తన రెండు భాగాలుగా విభజించబడింది: మేము దాని పద్ధతిని పిలిస్తే gas(), ప్రవర్తన వియుక్త Carమాతృ తరగతి నుండి "పైకి లాగబడుతుంది" మరియు మేము brake()తరగతిలో పద్ధతిని అమలు చేస్తాము Sedan. అది చాలా సౌకర్యవంతంగా మరియు అనువైనది. కానీ ఇప్పుడు మా తరగతి అంత అబ్‌స్ట్రాక్ట్ కాదు, అవునా ? అన్ని తరువాత, ఇది వాస్తవానికి సగం పద్ధతులను అమలు చేసింది. వాస్తవం - మరియు ఇది చాలా ముఖ్యమైన లక్షణం - ఒక తరగతి దాని పద్ధతుల్లో ఒకటి కూడా వియుక్తంగా ఉంటే నైరూప్యమైనది.. రెండు ఒకటి, లేదా వెయ్యి ఒకటి - ఇది పట్టింపు లేదు. మేము అన్ని పద్ధతులను కూడా అమలు చేయగలము, ఏదీ వియుక్తంగా ఉండకూడదు. ఫలితం ఏ నైరూప్య పద్ధతులు లేకుండా ఒక వియుక్త తరగతి అవుతుంది. ఇది సూత్రప్రాయంగా సాధ్యమవుతుంది - కంపైలర్ ఎటువంటి లోపాలను సృష్టించదు - కానీ దీన్ని చేయకపోవడమే మంచిది, ఎందుకంటే ఇది నైరూప్య పదాన్ని దాని అర్థాన్ని కోల్పోతుంది. మీ తోటి ప్రోగ్రామర్లు కూడా దీన్ని చూసి చాలా ఆశ్చర్యపోతారు :/ ఒక పద్ధతిని అబ్‌స్ట్రాక్ట్‌గా గుర్తించినట్లయితే, ప్రతి సంతతి తరగతి తప్పనిసరిగా దానిని అమలు చేయాలి లేదా వియుక్తంగా ప్రకటించాలి. లేకపోతే, కంపైలర్ లోపాన్ని విసురుతుంది. వాస్తవానికి, ప్రతి తరగతి ఒక వియుక్త తరగతిని మాత్రమే వారసత్వంగా పొందగలదు, కాబట్టి వారసత్వం పరంగా వియుక్త మరియు సాధారణ తరగతుల మధ్య తేడా లేదు. మనం ఒక అబ్‌స్ట్రాక్ట్ క్లాస్‌ని లేదా రెగ్యులర్ క్లాస్‌ని వారసత్వంగా పొందినట్లయితే పర్వాలేదు — ఒకే పేరెంట్ క్లాస్ మాత్రమే ఉంటుంది.

జావాకు బహుళ తరగతి వారసత్వం ఎందుకు లేదు

జావాలో బహుళ వారసత్వం లేదని మేము ఇంతకు ముందే చెప్పాము, కాని ఎందుకు అని మేము నిజంగా పరిశోధించలేదు. ఇప్పుడు అలా చేయడానికి ప్రయత్నిద్దాం. వాస్తవం ఏమిటంటే, జావాకు బహుళ వారసత్వం ఉంటే, ఏ ప్రవర్తనను ఎంచుకోవాలో పిల్లల తరగతులు నిర్ణయించలేవు. మనకు రెండు తరగతులు ఉన్నాయని అనుకుందాం: Toasterమరియు NuclearBomb:

public class Toaster {
  
  
 public void on() {

       System.out.println("The toaster is on. We're toasting!");
   }
  
   public void off() {

       System.out.println("The toaster is off!");
   }
}


public class NuclearBomb {

   public void on() {

       System.out.println("Boom!");
   }
}

మీరు గమనిస్తే, రెండు తరగతులకు ఒక on()పద్ధతి ఉంది. టోస్టర్ కోసం, పద్ధతి టోస్ట్ తయారు చేయడం ప్రారంభిస్తుంది, కానీ అణు బాంబు విషయంలో, అది పేలుడుకు దారి తీస్తుంది. ఉహ్-ఓహ్ :/ ఇప్పుడు మీరు మధ్యలో ఏదైనా సృష్టించాలని నిర్ణయించుకున్నారని (నన్ను ఎందుకు అడగవద్దు!) ఊహించుకోండి. ఇదిగో మీ తరగతి: MysteriousDevice! ఈ కోడ్ పని చేయదు. మేము దానిని "ఏమై ఉండవచ్చు" అనేదానికి ఉదాహరణగా అందిస్తున్నాము:

public class MysteriousDevice extends Toster, NuclearBomb {

   public static void main(String[] args) {
      
       MysteriousDevice mysteriousDevice = new MysteriousDevice();
       mysteriousDevice.on(); // And what should happen here? Will we get toast or a nuclear apocalypse?
   }
}

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