Statikus osztályok

1. Belső osztályok

Nemrég tanulta meg, hogy vannak statikus változók és statikus módszerek. Kiderült, hogy vannak statikus osztályok is. De ezt a témát távolról közelítjük meg.

A Java-ban teljes mértékben megengedett az osztályok osztályokon belüli deklarálása. És még az osztályokon belüli osztályok is, amelyek az osztályokon belül vannak. Minden nagyon egyszerűnek tűnik:

class OuterClass
{
   variables of the class
   methods of the class

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

Csak deklaráljuk az egyik osztályt a másikban. Ilyen egyszerű az egész.

Példa:

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

A beágyazott osztályok lehetnek statikusak vagy nem statikusak. A statikus beágyazott osztályokat egyszerűen statikus beágyazott osztályoknak nevezzük . A nem statikus beágyazott osztályokat belső osztályoknak ( inner class ) nevezzük .

2. Statikus osztályok

A statikus beágyazott osztályok a külső osztályukon kívül is használhatók. Ha egy ilyen osztály rendelkezik a nyilvános hozzáférés módosítóval, akkor a programban bárhol használható. Az ilyen osztályok szinte megkülönböztethetetlenek minden hétköznapi osztálytól. De van egy-két különbség.

Osztály név

Ha egy statikus beágyazott osztályra a külső osztályon kívül máshonnan szeretne hivatkozni, meg kell adnia az osztály nevét, amely a külső osztály nevéből és a beágyazott osztály nevéből áll. Íme a név általános megjelenése:

OuterClass.InnerClass

Példák:

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

Ha egy beágyazott osztálynak saját beágyazott osztálya van, akkor a nevüket egyszerűen egy ponttal egyesítik.

A JDK beágyazott osztályának tipikus példája az Entryosztályon belüli Maposztály. Ha szeretné lekérni a kulcs-érték párok készletét egy objektumban HashMap, akkor használja a entrySet()metódust, amely egy .Set<Map.Entry>

Vegye figyelembe, hogy ez egy példa egy külső osztályra és egy beágyazott osztályra.Map.Entry

Objektum létrehozása

Nagyon egyszerű létrehozni egy statikus beágyazott osztály objektumát. Így néz ki:

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

Ugyanaz, mint a hagyományos osztályoknál, de a név két részből áll.

Statikus metódusok hívása

Ha egy statikus osztálynak vannak statikus metódusai, akkor ezeket ugyanúgy érheti el, mint a közönséges osztályok statikus metódusait (de az osztálynév két részből áll).

OuterClass.NestedClass.staticMethod();

Statikus változók elérése

A beágyazott osztály nyilvános statikus változóinak elérése is egyszerű:

OuterParent.NestedClass.nameOfStaticVariable

3. A statikus osztályok jellemzői

A statikus beágyazott osztályoknak van a legkevesebb oka statikusnak nevezni őket. Úgy viselkednek, mint a szokásos osztályok . Nincs korlátozás a nem statikus metódusokból történő elérésére.

Ha statikus beágyazott osztállyal dolgozik a külső osztályán belül, akkor nem fog észrevenni különbséget a legáltalánosabb (nem beágyazott és nem statikus) osztályhoz képest.

Példa:

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

Ha veszünk egy statikus beágyazott osztályt, és áthelyezzük a külső osztályából, akkor csak az fog változni, hogy az új osztály többé nem fogja tudni elérni a private statickorábbi külső osztály változóit és metódusait.

Példa:

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

A mainközönséges Pointosztály metódusa nem fér hozzá private static pointsaz osztály változójához Solution!

Ez a fő különbség a statikus beágyazott osztály és a közönséges osztály között. A statikus beágyazott osztályok metódusai hozzáférhetnek külső osztályuk összes statikus változójához és metódusához, még akkor is, ha deklarálva vannak private.

És ha belegondolsz, miért lenne ez meglepő? A privatemódosító kifejezetten azt mondja, hogy az ezzel a módosítóval megjelölt változók és metódusok csak az osztályukon belül érhetők el. A statikus beágyazott osztály a külső osztályán belül van? Igen, szóval semmi gond! Annyira érheti el őket, amennyit csak akar.