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

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

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;
       }
   }
}

ఈ ఉదాహరణలో, మనకు Boeing737బాహ్య తరగతి ఉంది, ఇది ఈ రకమైన విమానాన్ని సూచిస్తుంది. ఇది ఒక పరామితితో కన్స్ట్రక్టర్‌ను కలిగి ఉంది: తయారీ సంవత్సరం ( int manufactureYear). ఒక స్టాటిక్ వేరియబుల్ కూడా ఉంది: గరిష్ట సంఖ్యలో ప్రయాణీకుల సంఖ్య ( int maxPassengersCount). ఇది ఒకే మోడల్ యొక్క అన్ని విమానాలకు ఒకే విలువను కలిగి ఉంటుంది, కాబట్టి మనకు ఒక ఉదాహరణ మాత్రమే అవసరం. అదనంగా, ఇది స్టాటిక్ నెస్టెడ్ క్లాస్‌ని కలిగి ఉంది: Drawing(విమానం యొక్క ఇంజనీరింగ్ బ్లూప్రింట్‌లను సూచిస్తుంది). విమానం గురించిన మొత్తం అధికారిక సమాచారాన్ని పొందుపరచడానికి మేము ఈ తరగతిని ఉపయోగిస్తాము. మా ఉదాహరణలో, సరళత కోసం, మేము ఈ తరగతిని తయారీ సంవత్సరానికి పరిమితం చేసాము, కానీ ఇది చాలా ఇతర సమాచారాన్ని కలిగి ఉండవచ్చు. మేము గత పాఠంలో చెప్పినట్లుగా, అటువంటి సమూహ తరగతిని సృష్టించడం ఎన్‌క్యాప్సులేషన్‌ను మెరుగుపరుస్తుంది మరియు మరింత వాస్తవిక సంగ్రహణకు దోహదం చేస్తుంది. స్టాటిక్ మరియు నాన్-స్టాటిక్ నెస్టెడ్ క్లాస్‌ల మధ్య తేడా ఏమిటి? 1. స్టాటిక్ క్లాస్ యొక్క వస్తువు Drawingబాహ్య తరగతి యొక్క నిర్దిష్ట ఉదాహరణకి సూచనను నిల్వ చేయదు. చివరి పాఠం నుండి సైకిల్ ఉదాహరణను గుర్తుంచుకో:

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!");
   }

   public class Handlebar {

       public void right() {
           System.out.println("Steer right!");
       }

       public void left() {

           System.out.println("Steer left!");
       }
   }

}

Handlebarఆ పాఠంలో, అంతర్గత తరగతిలోని ప్రతి సందర్భం, మనకు కనిపించకుండా, బయటి తరగతి యొక్క ఉదాహరణకి సూచనగా ఉత్తీర్ణత చెందుతుందనే వాస్తవం గురించి మేము మాట్లాడాము Bicycle. బాహ్య తరగతి యొక్క ఉదాహరణ లేకుండా, అంతర్గత తరగతి యొక్క వస్తువు ఉనికిలో ఉండదు. స్టాటిక్ నెస్టెడ్ క్లాస్‌ల కోసం, ఇది అలా కాదు. స్టాటిక్ నెస్టెడ్ క్లాస్ యొక్క వస్తువు పూర్తిగా దాని స్వంతదానిని కలిగి ఉంటుంది. ఈ విషయంలో, స్టాటిక్ తరగతులు నాన్-స్టాటిక్ కంటే "స్వతంత్రమైనవి". మీరు తెలుసుకోవలసిన ఏకైక విషయం ఏమిటంటే, అటువంటి వస్తువును సృష్టించేటప్పుడు, మీరు తప్పనిసరిగా బయటి తరగతి పేరును పేర్కొనాలి:

public class Main {

   public static void main(String[] args) {

       Boeing737.Drawing drawing1 = new Boeing737.Drawing();
       Boeing737.Drawing drawing2 = new Boeing737.Drawing();
   }
}

Drawingచివరి పాఠంలో మనం క్లాస్‌ని ఎందుకు స్టాటిక్‌గా చేసాముSeatతరగతి (సైకిల్ సీటుకు ప్రాతినిధ్యం వహిస్తుంది) నాన్-స్టాటిక్? చివరిసారి లాగా, ఉదాహరణను అర్థం చేసుకోవడానికి కొద్దిగా "తత్వశాస్త్రం" జోడిద్దాం :) సైకిల్ సీటు వలె కాకుండా, ఇంజనీరింగ్ డ్రాయింగ్ భావన విమానం యొక్క భావనతో కఠినంగా ముడిపడి లేదు. సైకిల్ లేకుండా, ప్రత్యేక సైకిల్ సీటు వస్తువు చాలా తరచుగా అర్థరహితంగా ఉంటుంది (ఎల్లప్పుడూ కానప్పటికీ, మేము చివరి పాఠంలో దీని గురించి మాట్లాడాము). ఇంజనీరింగ్ డ్రాయింగ్ యొక్క భావన దాని స్వంత అర్ధమే. ఉదాహరణకు, విమానం నిర్వహణను ప్లాన్ చేసే ఇంజనీర్లకు ఇది ఉపయోగకరంగా ఉంటుంది. ప్లాన్‌ను రూపొందించడానికి విమానం అవసరం లేదు మరియు ఎక్కడైనా కనుగొనవచ్చు. ఇంజనీరింగ్ డ్రాయింగ్ మాత్రమే అవసరం. అదనంగా, ఒకే మోడల్‌లోని అన్ని విమానాలు ఒకే ఇంజనీర్ డ్రాయింగ్‌ను కలిగి ఉంటాయి, కాబట్టి సైకిల్ సీటుతో ఉన్నటువంటి గట్టి సంబంధం లేదు. కాబట్టి, ఎDrawingవస్తువుకు నిర్దిష్ట విమానం వస్తువుకు సూచన అవసరం లేదు. 2. బయటి తరగతి యొక్క వేరియబుల్స్ మరియు పద్ధతులకు విభిన్న యాక్సెస్. స్టాటిక్ నెస్టెడ్ క్లాస్ బాహ్య తరగతి యొక్క స్టాటిక్ ఫీల్డ్‌లను మాత్రమే యాక్సెస్ చేయగలదు. మా ఉదాహరణలో, తరగతి బాహ్య తరగతి యొక్క స్టాటిక్ వేరియబుల్ విలువను తిరిగి ఇచ్చే పద్ధతిని Drawingకలిగి ఉంది . అయినప్పటికీ, విలువను తిరిగి ఇవ్వడానికి మేము తరగతిలో పద్ధతిని సృష్టించలేము . అన్నింటికంటే, వేరియబుల్ నాన్-స్టాటిక్, అంటే ఇది ఒక నిర్దిష్ట ఉదాహరణకి చెందినదిగా ఉండాలి . మరియు మేము ఇప్పటికే కనుగొన్నట్లుగా, స్టాటిక్ నెస్టెడ్ క్లాస్‌ల విషయంలో, బాహ్య తరగతి యొక్క వస్తువు సులభంగా లేకపోవచ్చు. అందువల్ల, పరిమితి :) ఔటర్ క్లాస్‌లో స్టాటిక్ వేరియబుల్ ఏ యాక్సెస్ మాడిఫైయర్‌ని కలిగి ఉన్నా అది పట్టింపు లేదు. అది కూడాgetMaxPassengersCount()maxPassengersCountgetManufactureYear()DrawingmanufactureYearmanufactureYearBoeing737private, స్టాటిక్ నెస్టెడ్ క్లాస్ ఇప్పటికీ యాక్సెస్‌ను కలిగి ఉంటుంది. పైన పేర్కొన్నవన్నీ స్టాటిక్ వేరియబుల్స్‌కు మాత్రమే కాకుండా, స్టాటిక్ పద్ధతులకు కూడా వర్తిస్తాయి. ముఖ్యమైనది! ఇన్నర్ క్లాస్ డిక్లరేషన్‌లో, staticమీరు ఒక వస్తువును మాత్రమే సృష్టించగలరని కీవర్డ్ అర్థం కాదు. వస్తువులను వేరియబుల్స్‌తో కంగారు పెట్టవద్దు. మేము స్టాటిక్ వేరియబుల్స్ గురించి మాట్లాడుతున్నట్లయితే, అవును, స్టాటిక్ క్లాస్ వేరియబుల్ యొక్క ఒకే ఉదాహరణ ఉంది, ఉదాహరణకు, maxPassangersCount. కానీ staticసమూహ తరగతికి వర్తింపజేసినప్పుడు, దాని వస్తువులు బాహ్య తరగతికి చెందిన వస్తువులకు సూచనలను కలిగి ఉండవని మాత్రమే అర్థం. మరియు మనకు కావలసినన్ని వస్తువులను మనం స్వయంగా సృష్టించవచ్చు:

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 {

       private int id;

       public Drawing(int id) {
           this.id = id;
       }

       public static int getPassengersCount() {

           return maxPassengersCount;
       }

       @Override
       public String toString() {
           return "Drawing{" +
                   "id=" + id +
                   '}';
       }

       public static void main(String[] args) {

           for (int i = 1; i < 6; i++) {

               Boeing737.Drawing drawing = new Boeing737.Drawing(i);
               System.out.println(drawing);
           }
       }
   }
}

మేము main()పద్ధతిని నేరుగా సమూహ తరగతిలో ప్రకటించాము (దీనికి ప్రత్యేక కారణం ఏమీ లేదు — ఇది సాధ్యమేనని మీకు తెలియజేయడానికి మాత్రమే), మరియు 5 Drawingవస్తువులను సృష్టించాము. మన దగ్గర బయటి తరగతికి చెందిన ఒక్క వస్తువు కూడా లేదు. మీరు గమనిస్తే, ఇది ఎటువంటి సమస్యలను సృష్టించలేదు :) కన్సోల్ అవుట్‌పుట్:

Drawing{id=1} 
Drawing{id=2} 
Drawing{id=3} 
Drawing{id=4} 
Drawing{id=5}

మరియు అది మా పాఠాన్ని ముగించింది! ఒకవేళ, నేను ఒరాకిల్ డాక్యుమెంటేషన్‌లో వాటి గురించిన విభాగానికి లింక్‌ను మీకు వదిలివేస్తాను . ఇంకా ఏదైనా అస్పష్టంగా ఉంటే, దాన్ని చదవండి. ఇప్పుడు నేను కొన్ని పనులను పరిష్కరించాల్సిన సమయం వచ్చింది! :)