సమూహ తరగతుల వారసత్వానికి ఉదాహరణలు

హాయ్! ఈ రోజు మనం ఒక ముఖ్యమైన యంత్రాంగాన్ని పరిశీలిస్తాము: సమూహ తరగతులలో వారసత్వం. మీరు ఒక సమూహ తరగతిని మరొక తరగతిని వారసత్వంగా పొందాలంటే మీరు ఏమి చేస్తారనే దాని గురించి మీరు ఎప్పుడైనా ఆలోచించారా. కాకపోతే, నన్ను నమ్మండి: ఈ పరిస్థితి గందరగోళంగా ఉంటుంది, ఎందుకంటే చాలా సూక్ష్మ నైపుణ్యాలు ఉన్నాయి.

1. మేము ఒక సమూహ తరగతిని కొంత తరగతిని వారసత్వంగా పొందేలా చేస్తున్నామా? లేదా మేము కొన్ని తరగతిని సమూహ తరగతిగా వారసత్వంగా పొందుతున్నామా?
2. చైల్డ్/పేరెంట్ క్లాస్ సాధారణ పబ్లిక్ క్లాస్ కాదా, లేదా అది కూడా నెస్టెడ్ క్లాస్ కాదా?
3. చివరగా, ఈ అన్ని పరిస్థితులలో మేము ఏ రకమైన సమూహ తరగతులను ఉపయోగిస్తాము?

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

స్టాటిక్ సమూహ తరగతులు

వారి వారసత్వ నియమాలు సరళమైనవి. ఇక్కడ మీరు మీ హృదయం కోరుకునే దాదాపు ఏదైనా చేయవచ్చు. స్థిరమైన సమూహ తరగతి వారసత్వంగా పొందవచ్చు:

• ఒక సాధారణ తరగతి
• బయటి తరగతి లేదా దాని పూర్వీకులలో ప్రకటించబడిన స్థిరమైన సమూహ తరగతి

స్టాటిక్ నెస్టెడ్ తరగతులపై మా పాఠం నుండి ఒక ఉదాహరణను గుర్తుకు తెచ్చుకోండి.

public class Boeing737 {

   private int manufactureYear;
   private static int maxPassengersCount = 300;

   public Boeing737(int manufactureYear) {
       this.manufactureYear = manufactureYear;
   }

   public int getManufactureYear() {
       return manufactureYear;
   }

   public static class Drawing {

       public static int getMaxPassengersCount() {

           return maxPassengersCount;
       }
   }
}

కోడ్‌ని మార్చడానికి ప్రయత్నిద్దాం మరియు Drawingస్థిరమైన సమూహ తరగతిని మరియు దాని సంతతిని సృష్టించడానికి ప్రయత్నిద్దాం — Boeing737Drawing.

public class Boeing737 {

   private int manufactureYear;
   private static int maxPassengersCount = 300;

   public Boeing737(int manufactureYear) {
       this.manufactureYear = manufactureYear;
   }

   public int getManufactureYear() {
       return manufactureYear;
   }

   public static class Drawing {

   }

   public static class Boeing737Drawing extends Drawing {

       public static int getMaxPassengersCount() {

           return maxPassengersCount;
       }
   }
}

మీరు గమనిస్తే, సమస్య లేదు. మేము క్లాస్‌ని తీసివేసి Drawing, స్టాటిక్ నెస్టెడ్ క్లాస్‌కి బదులుగా సాధారణ పబ్లిక్ క్లాస్‌గా మార్చవచ్చు - ఏమీ మారదు.

public class Drawing {

}

public class Boeing737 {

   private int manufactureYear;
   private static int maxPassengersCount = 300;

   public Boeing737(int manufactureYear) {
       this.manufactureYear = manufactureYear;
   }

   public int getManufactureYear() {
       return manufactureYear;
   }

   public static class Boeing737Drawing extends Drawing {

       public static int getMaxPassengersCount() {

           return maxPassengersCount;
       }
   }
}

మేము దీనిని అర్థం చేసుకున్నాము. కానీ ఏ తరగతులు స్థిరమైన సమూహ తరగతిని వారసత్వంగా పొందగలవు? ఆచరణాత్మకంగా ఏదైనా! నెస్టెడ్/నాన్-నెస్టెడ్, స్టాటిక్/నాన్-స్టాటిక్ — ఇది పట్టింపు లేదు. ఇక్కడ మేము Boeing737Drawingఅంతర్గత తరగతిని Drawingస్థిరమైన సమూహ తరగతిని వారసత్వంగా పొందేలా చేస్తాము:

public class Boeing737 {

   private int manufactureYear;
   private static int maxPassengersCount = 300;

   public Boeing737(int manufactureYear) {
       this.manufactureYear = manufactureYear;
   }

   public int getManufactureYear() {
       return manufactureYear;
   }

   public static class Drawing {

   }

   public class Boeing737Drawing extends Drawing {

       public int getMaxPassengersCount() {

           return maxPassengersCount;
       }
   }
}

Boeing737Drawingమీరు ఇలాంటి ఉదాహరణను సృష్టించవచ్చు :

public class Main {

   public static void main(String[] args) {

      Boeing737 boeing737 = new Boeing737(1990);
      Boeing737.Boeing737Drawing drawing = boeing737.new Boeing737Drawing();
      System.out.println(drawing.getMaxPassengersCount());

   }

}

మా Boeing737Drawingతరగతి స్థిరమైన తరగతిని వారసత్వంగా పొందినప్పటికీ, అది స్థిరమైనది కాదు! ఫలితంగా, దీనికి ఎల్లప్పుడూ బాహ్య తరగతికి సంబంధించిన ఉదాహరణ అవసరం. మేము తరగతి Boeing737Drawingనుండి తరగతిని తీసివేసి Boeing737, సాధారణ పబ్లిక్ క్లాస్‌గా చేయవచ్చు. ఏమీ మారదు. ఇది ఇప్పటికీ స్థిరమైన సమూహ తరగతిని వారసత్వంగా పొందవచ్చు Drawing.

public class Boeing737 {

   private int manufactureYear;
   public static int maxPassengersCount = 300;

   public Boeing737(int manufactureYear) {
       this.manufactureYear = manufactureYear;
   }

   public int getManufactureYear() {
       return manufactureYear;
   }

   public static class Drawing {

   }
}

public class Boeing737Drawing extends Boeing737.Drawing {

   public int getMaxPassengersCount() {

       return Boeing737.maxPassengersCount;

}

ముఖ్యమైన విషయం ఏమిటంటే, ఈ సందర్భంలో మనం స్టాటిక్ వేరియబుల్‌ను పబ్లిక్‌గా మార్చాలి maxPassengersCount. ఇది ప్రైవేట్‌గా ఉన్నట్లయితే, సాధారణ పబ్లిక్ క్లాస్‌కు దీనికి యాక్సెస్ ఉండదు. మేము స్టాటిక్ తరగతులను కనుగొన్నాము! :) ఇప్పుడు లోపలి తరగతులకు వెళ్దాం. అవి 3 రకాలుగా వస్తాయి: సాధారణ అంతర్గత తరగతులు, స్థానిక తరగతులు మరియు అనామక అంతర్గత తరగతులు. మళ్ళీ, సాధారణ నుండి సంక్లిష్టంగా మారండి :)

అనామక అంతర్గత తరగతులు

అనామక అంతర్గత తరగతి మరొక తరగతిని వారసత్వంగా పొందదు. ఏ ఇతర తరగతి అనామక తరగతిని వారసత్వంగా పొందదు. ఇది మరింత సరళమైనది కాదు! :)

స్థానిక తరగతులు

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

public class PhoneNumberValidator {

   public void validatePhoneNumber(final String number) {

       class PhoneNumber {

           private String phoneNumber;

           public PhoneNumber() {
               this.phoneNumber = number;
           }

           public String getPhoneNumber() {
               return phoneNumber;
           }

           public void setPhoneNumber(String phoneNumber) {
               this.phoneNumber = phoneNumber;
           }
       }

       class CellPhoneNumber extends PhoneNumber {

       }

       class LandlinePhoneNumber extends PhoneNumber {


       }

       // ...number validation code
   }
}

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

1. ఒక సాధారణ తరగతి.
2. స్థానిక తరగతి లేదా దాని పూర్వీకులలో ఒకరిలో అదే తరగతిలో ప్రకటించబడిన అంతర్గత తరగతి.
3. అదే పద్ధతిలో (కోడ్ బ్లాక్) ప్రకటించబడిన మరో స్థానిక తరగతి.

మొదటి మరియు మూడవ పాయింట్లు స్పష్టంగా కనిపిస్తున్నాయి, కానీ రెండవది కొంచెం గందరగోళంగా ఉంది :/ రెండు ఉదాహరణలను చూద్దాం. ఉదాహరణ 1 — "స్థానిక తరగతిని స్థానిక తరగతి వలె అదే తరగతిలో ప్రకటించబడిన అంతర్గత తరగతిని వారసత్వంగా పొందేలా చేయడం":

public class PhoneNumberValidator {

   class PhoneNumber {

       private String phoneNumber;

       public PhoneNumber(String phoneNumber) {
           this.phoneNumber = phoneNumber;
       }

       public String getPhoneNumber() {
           return phoneNumber;
       }

       public void setPhoneNumber(String phoneNumber) {
           this.phoneNumber = phoneNumber;
       }
   }

   public void validatePhoneNumber(final String number) {

       class CellPhoneNumber extends PhoneNumber {

           public CellPhoneNumber(String phoneNumber) {
               super(number);
           }
       }

       class LandlinePhoneNumber extends PhoneNumber {

           public LandlinePhoneNumber(String phoneNumber) {
               super(number);
           }
       }

       // ...number validation code
   }
}

ఇక్కడ మేము పద్ధతి PhoneNumberనుండి తరగతిని తీసివేసి validatePhoneNumber(), స్థానిక తరగతికి బదులుగా అంతర్గత తరగతిగా చేసాము. ఇది మా 2 స్థానిక తరగతులను వారసత్వంగా పొందకుండా మమ్మల్ని ఆపదు. ఉదాహరణ 2 — "... లేదా ఈ తరగతి పూర్వీకులలో." ఇప్పుడు ఇది మరింత ఆసక్తికరంగా మారింది. PhoneNumberవారసత్వ గొలుసులో మనం మరింత ఎత్తుకు వెళ్లవచ్చు . AbstractPhoneNumberValidatorమన తరగతికి పూర్వీకులుగా మారే వియుక్త తరగతిని ప్రకటిస్తాము PhoneNumberValidator:

public abstract class AbstractPhoneNumberValidator {

   class PhoneNumber {

       private String phoneNumber;

       public PhoneNumber(String phoneNumber) {
           this.phoneNumber = phoneNumber;
       }

       public String getPhoneNumber() {
           return phoneNumber;
       }

       public void setPhoneNumber(String phoneNumber) {
           this.phoneNumber = phoneNumber;
       }
   }

}

మీరు చూడగలిగినట్లుగా, మేము దానిని ప్రకటించలేదు — మేము PhoneNumberలోపలి తరగతిని కూడా దానిలోకి తరలించాము. అయినప్పటికీ, దాని వారసులలో PhoneNumberValidator, పద్ధతుల్లో ప్రకటించబడిన స్థానిక తరగతులు PhoneNumberఎటువంటి సమస్య లేకుండా వారసత్వంగా పొందవచ్చు!

public class PhoneNumberValidator extends AbstractPhoneNumberValidator {

   public void validatePhoneNumber(final String number) {

       class CellPhoneNumber extends PhoneNumber {

           public CellPhoneNumber(String phoneNumber) {
               super(number);
           }
       }

       class LandlinePhoneNumber extends PhoneNumber {

           public LandlinePhoneNumber(String phoneNumber) {
               super(number);
           }
       }

       // ...number validation code
   }
}

వారసత్వ సంబంధం కారణంగా, సంతతి తరగతిలోని స్థానిక తరగతులు పూర్వీకులలోని అంతర్గత తరగతులను "చూడండి". చివరగా, చివరి సమూహానికి వెళ్దాం :)

అంతర్గత తరగతులు

అదే బాహ్య తరగతిలో (లేదా దాని వంశంలో) ప్రకటించబడిన అంతర్గత తరగతి మరొక అంతర్గత తరగతిని వారసత్వంగా పొందవచ్చు. అంతర్గత తరగతుల పాఠం నుండి సైకిళ్లతో మా ఉదాహరణను ఉపయోగించి దీన్ని అన్వేషిద్దాం.

public class Bicycle {

   private String model;
   private int maxWeight;

   public Bicycle(String model, int maxWeight) {
       this.model = model;
       this.maxWeight = maxWeight;
   }

   public void start() {
       System.out.println("Let's go!");
   }

   class Seat {

       public void up() {

           System.out.println("Seat up!");
       }

       public void down() {

           System.out.println("Seat down!");
       }
   }

   class SportSeat extends Seat {

       // ...methods
   }
}

Seatఇక్కడ మేము తరగతి లోపల అంతర్గత తరగతిని ప్రకటించాము Bicycle. రేసింగ్ సీటు యొక్క ప్రత్యేక రకం, SportSeat, దానిని వారసత్వంగా పొందుతుంది. కానీ, మేము ప్రత్యేక "రేసింగ్ సైకిల్" రకాన్ని సృష్టించవచ్చు మరియు దానిని ప్రత్యేక తరగతిలో ఉంచవచ్చు:

public class SportBicycle extends Bicycle {

   public SportBicycle(String model, int maxWeight) {
       super(model, maxWeight);
   }


   class SportSeat extends Seat {

       public void up() {

           System.out.println("Seat up!");
       }

       public void down() {

           System.out.println("Seat down!");
       }
   }
}

ఇది కూడా ఒక ఎంపిక. వారసుడి ( SportBicycle.SportSeat) యొక్క అంతర్గత తరగతి పూర్వీకుల అంతర్గత తరగతులను "చూస్తుంది" మరియు వాటిని వారసత్వంగా పొందవచ్చు. అంతర్గత తరగతులను వారసత్వంగా పొందడం చాలా ముఖ్యమైన లక్షణాన్ని కలిగి ఉంది! మునుపటి రెండు ఉదాహరణలలో, మా SportSeatతరగతి ఒక అంతర్గత తరగతి. SportSeatఅయితే అంతర్గత తరగతిని ఏకకాలంలో వారసత్వంగా పొందే సాధారణ పబ్లిక్ క్లాస్‌ని తయారు చేయాలని మేము నిర్ణయించుకుంటే Seat?

// Error! No enclosing instance of type 'Bicycle' is in scope
class SportSeat extends Bicycle.Seat {

   public SportSeat() {

   }

   public void up() {

       System.out.println("Seat up!");
   }

   public void down() {

       System.out.println("Seat down!");
   }
}

మాకు లోపం వచ్చింది! ఎందుకు అని మీరు ఊహించగలరా? :) ఇదంతా సూటిగా ఉంది. మేము అంతర్గత తరగతి గురించి మాట్లాడినప్పుడు Bicycle.Seat, బయటి తరగతికి సంబంధించిన ఒక ప్రస్తావన అంతర్గత తరగతి యొక్క నిర్మాణకర్తకు పరోక్షంగా పంపబడిందని మేము పేర్కొన్నాము. Seatఒక వస్తువును సృష్టించకుండా మీరు ఒక వస్తువును సృష్టించలేరని దీని అర్థం Bicycle. కానీ ఒక సృష్టి గురించి ఏమిటి SportSeat? వలె కాకుండా Seat, బాహ్య తరగతికి చెందిన ఒక ఉదాహరణకి సూచనగా కన్స్ట్రక్టర్‌ను పరోక్షంగా పాస్ చేయడానికి ఈ అంతర్నిర్మిత విధానం లేదు. S వరకు, ఒక Bicycleవస్తువు లేకుండా, మనం ఒక వస్తువును సృష్టించలేము SportSeat, అలాగే Seat. కాబట్టి, మనం చేయవలసినది ఒక్కటే మిగిలి ఉంది — స్పష్టంగా కన్స్ట్రక్టర్‌కి SportSeatఒక వస్తువుకు సూచనను పంపండి Bicycle. దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:

class SportSeat extends Bicycle.Seat {

   public SportSeat(Bicycle bicycle) {

       bicycle.super();
   }

   public void up() {

       System.out.println("Seat up!");
   }

   public void down() {

       System.out.println("Seat down!");
   }
}

మేము ఇప్పుడు ఉపయోగించి సూపర్‌క్లాస్ కన్‌స్ట్రక్టర్‌ని పిలుస్తాము super(); , మనం ఒక వస్తువును సృష్టించాలనుకుంటే SportSeat, దీన్ని చేయడం నుండి మనల్ని ఏదీ ఆపదు:

public class Main {

   public static void main(String[] args) {

       Bicycle bicycle = new Bicycle("Peugeot", 120);
       SportSeat peugeotSportSeat = new SportSeat(bicycle);

   }
}

అయ్యో! ఈ పాఠం చాలా పొడవుగా ఉంది :) కానీ మీరు చాలా నేర్చుకున్నారు! ఇప్పుడు కొన్ని పనులను పరిష్కరించే సమయం వచ్చింది! :)