స్టాటిక్ తరగతులు

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

స్టాటిక్ వేరియబుల్స్ మరియు స్టాటిక్ మెథడ్స్ ఉన్నాయని మీరు ఇటీవల తెలుసుకున్నారు. స్టాటిక్ తరగతులు కూడా ఉన్నాయని తేలింది. కానీ మేము ఈ అంశాన్ని దూరం నుండి సంప్రదిస్తాము.

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

class OuterClass
{
   variables of the class
   methods of the class

   class NestedClass
   {
      variables of the class
      methods of the class
   }
}

మేము కేవలం ఒక తరగతి లోపల మరొకటి ప్రకటిస్తాము. సింపుల్ గా.

ఉదాహరణ:

public class Solution
{
   static ArrayList<Point> points = new ArrayList<Point>();

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points.add(point);
   }

   static class Point
   {
      int x;
      int y;
   }
}

నెస్టెడ్ తరగతులు స్టాటిక్ లేదా నాన్ స్టాటిక్ కావచ్చు. స్టాటిక్ నెస్టెడ్ క్లాస్‌లను కేవలం స్టాటిక్ నెస్టెడ్ క్లాస్‌లు అంటారు . నాన్-స్టాటిక్ నెస్టెడ్ తరగతులను అంతర్గత తరగతులు ( అంతర్గత తరగతులు ) అంటారు .

2. స్టాటిక్ తరగతులు

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

తరగతి పేరు

మీరు స్టాటిక్ నెస్టెడ్ క్లాస్‌ని దాని బయటి తరగతి కాకుండా వేరే చోట నుండి సూచించాలనుకుంటే, మీరు క్లాస్ పేరును పేర్కొనాలి, ఇందులో బాహ్య తరగతి పేరు మరియు సమూహ తరగతి పేరు ఉంటుంది. ఈ పేరు యొక్క సాధారణ రూపం ఇక్కడ ఉంది:

OuterClass.InnerClass

ఉదాహరణలు:

com.codegym.Solution

Point

com.codegym.Solution.Point

java.util.Map

Entry

java.util.Map.Entry

java.util.Files

DirectoryStream

java.util.Files.DirectoryStream

java.nio.WindowsPath

Closeable

java.nio.WindowsPath.Closeable

ఒక సమూహ తరగతి దాని స్వంత సమూహ తరగతిని కలిగి ఉన్నట్లయితే, వారి పేర్లు కేవలం చుక్కను ఉపయోగించి చేర్చబడతాయి.

JDKలోని సమూహ తరగతికి ఒక సాధారణ ఉదాహరణ తరగతి Entryలోపల Mapతరగతి. మీరు ఆబ్జెక్ట్‌లో నిల్వ చేయబడిన కీ-విలువ జతల సెట్‌ను పొందాలనుకుంటే HashMap, పద్ధతిని ఉపయోగించండి entrySet(), ఇది a .Set<Map.Entry>

ఇది బాహ్య తరగతి మరియు సమూహ తరగతికి ఉదాహరణ అని గమనించండి .Map.Entry

ఒక వస్తువును సృష్టించడం

స్టాటిక్ నెస్టెడ్ క్లాస్ యొక్క వస్తువును సృష్టించడం చాలా సులభం. ఇది ఇలా కనిపిస్తుంది:

OuterClass.NestedClass name = new OuterClass.NestedClass();

ఇది సాధారణ తరగతుల మాదిరిగానే ఉంటుంది, కానీ పేరు రెండు భాగాలను కలిగి ఉంటుంది.

స్టాటిక్ పద్ధతులను కాల్ చేస్తోంది

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

OuterClass.NestedClass.staticMethod();

స్టాటిక్ వేరియబుల్స్‌ని యాక్సెస్ చేస్తోంది

సమూహ తరగతి యొక్క పబ్లిక్ స్టాటిక్ వేరియబుల్స్‌ని యాక్సెస్ చేయడం చాలా సులభం:

OuterParent.NestedClass.nameOfStaticVariable

3. స్టాటిక్ తరగతుల లక్షణాలు

స్టాటిక్ నెస్టెడ్ క్లాస్‌లను స్టాటిక్ అని పిలవడానికి అతి తక్కువ కారణం ఉంది. వారు సాధారణ తరగతుల మాదిరిగానే ప్రవర్తిస్తారు . నాన్-స్టాటిక్ పద్ధతుల నుండి వాటిని యాక్సెస్ చేయడానికి ఎటువంటి పరిమితులు లేవు.

మీరు దాని బయటి తరగతి లోపల స్టాటిక్ నెస్టెడ్ క్లాస్‌తో పని చేస్తున్నట్లయితే, మీరు అత్యంత సాధారణమైన (నెస్టెడ్ కాదు మరియు స్టాటిక్ కాదు) క్లాస్ నుండి ఎలాంటి తేడాను గమనించలేరు.

ఉదాహరణ:

public class Solution
{
   static ArrayList<Point> points;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points = new ArrayList<Point>();
      points.add(point);
   }

   static class Point
   {
      int x;
      int y;
   }
}

public class Solution
{
   static ArrayList<Point> points;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points = new ArrayList<Point>();
      points.add(point);
   }
}

class Point
{
   int x;
   int y;
}

మీరు కొంత స్టాటిక్ నెస్టెడ్ క్లాస్‌ని తీసుకుని, దాన్ని దాని బయటి తరగతి నుండి బయటకు తరలిస్తే, మారే ఏకైక విషయం ఏమిటంటే, కొత్త క్లాస్ ఇకపై దాని పూర్వ బాహ్య తరగతికి చెందిన వేరియబుల్స్ మరియు మెథడ్స్‌ని యాక్సెస్ చేయదు .private static

ఉదాహరణ:

public class Solution
{
   private static ArrayList<Point> points;

   static class Point
   {
      int x;
      int y;

      public static void main(String[] args)
      {
         Point point = new Point();
         point.x = 100;
         point.y = 200;

         // This will work
         points = new ArrayList<Point>();
         points.add(point);
      }
   }
}

public class Solution
{
   private static ArrayList<Point> points;
}

class Point
{
   int x;
   int y;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;

      // This will generate an error
      points = new ArrayList<Point>();
      points.add(point);
   }
}

mainసాధారణ Pointతరగతిలోని పద్ధతి క్లాస్ యొక్క వేరియబుల్‌ని యాక్సెస్ చేయదు !private static pointsSolution

స్థిరమైన సమూహ తరగతి మరియు సాధారణ తరగతి మధ్య ప్రధాన వ్యత్యాసం ఇది. స్టాటిక్ నెస్టెడ్ క్లాస్ యొక్క మెథడ్స్ అన్ని స్టాటిక్ వేరియబుల్స్ మరియు వాటి బాహ్య తరగతికి సంబంధించిన మెథడ్స్‌ను యాక్సెస్ చేయగలవు, అవి ప్రకటించబడినా కూడా private.

మరియు మీరు దాని గురించి ఆలోచిస్తే, అది ఎందుకు ఆశ్చర్యం కలిగిస్తుంది? privateఈ మాడిఫైయర్ ద్వారా గుర్తించబడిన వేరియబుల్స్ మరియు మెథడ్స్‌ని వాటి తరగతి నుండి మాత్రమే యాక్సెస్ చేయవచ్చని మాడిఫైయర్ స్పష్టంగా చెప్పింది . స్టాటిక్ నెస్టెడ్ క్లాస్ దాని బాహ్య తరగతి లోపల ఉందా? అవును, కాబట్టి సమస్య లేదు! మీకు కావలసినంత వాటిని యాక్సెస్ చేయండి.