Statische Klassen

1. Innere Klassen

Sie haben kürzlich erfahren, dass es statische Variablen und statische Methoden gibt. Es stellt sich heraus, dass es auch statische Klassen gibt. Aber wir werden dieses Thema aus der Distanz angehen.

In Java ist es Ihnen völlig gestattet, Klassen innerhalb von Klassen zu deklarieren. Und sogar Klassen innerhalb von Klassen, die innerhalb von Klassen innerhalb von Klassen sind. Es sieht alles ganz einfach aus:

class OuterClass
{
   variables of the class
   methods of the class

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

Wir deklarieren einfach eine Klasse innerhalb einer anderen. So einfach ist das.

Beispiel:

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

Verschachtelte Klassen können statisch oder nicht statisch sein. Statisch verschachtelte Klassen werden einfach als statisch verschachtelte Klassen bezeichnet . Nicht statische verschachtelte Klassen werden als innere Klassen ( innere Klassen ) bezeichnet.

2. Statische Klassen

Statisch verschachtelte Klassen können außerhalb ihrer äußeren Klasse verwendet werden. Wenn eine solche Klasse über den öffentlichen Zugriffsmodifikator verfügt, kann sie überall im Programm verwendet werden. Solche Klassen sind von gewöhnlichen Klassen kaum zu unterscheiden. Aber es gibt ein paar Unterschiede.

Klassenname

Wenn Sie von einer anderen Stelle als der äußeren Klasse auf eine statische verschachtelte Klasse verweisen möchten, müssen Sie den Klassennamen angeben, der aus dem Namen der äußeren Klasse und dem Namen der verschachtelten Klasse besteht. Hier ist das allgemeine Erscheinungsbild dieses Namens:

OuterClass.InnerClass

Beispiele:

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

Wenn eine verschachtelte Klasse über eine eigene verschachtelte Klasse verfügt, werden deren Namen einfach mit einem Punkt verbunden.

Ein typisches Beispiel für eine verschachtelte Klasse im JDK ist die EntryKlasse innerhalb der MapKlasse. Wenn Sie den Satz von Schlüssel-Wert-Paaren in einem Objekt speichern möchten HashMap, verwenden Sie die entrySet()Methode, die eine zurückgibt .Set<Map.Entry>

Beachten Sie, dass dies ein Beispiel für eine äußere Klasse und eine verschachtelte Klasse ist.Map.Entry

Ein Objekt erstellen

Es ist sehr einfach, ein Objekt einer statischen verschachtelten Klasse zu erstellen. So sieht es aus:

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

Es ist alles das Gleiche wie bei gewöhnlichen Klassen, aber der Name besteht aus zwei Teilen.

Aufruf statischer Methoden

Wenn eine statische Klasse über statische Methoden verfügt, können Sie auf diese auf die gleiche Weise zugreifen wie auf die statischen Methoden gewöhnlicher Klassen (der Klassenname besteht jedoch aus zwei Teilen).

OuterClass.NestedClass.staticMethod();

Zugriff auf statische Variablen

Auch der Zugriff auf die öffentlichen statischen Variablen einer verschachtelten Klasse ist einfach:

OuterParent.NestedClass.nameOfStaticVariable

3. Merkmale statischer Klassen

Statisch verschachtelte Klassen haben den geringsten Grund, statisch genannt zu werden. Sie verhalten sich genau wie normale Klassen . Es gibt keine Einschränkungen für den Zugriff mit nicht statischen Methoden.

Wenn Sie mit einer statisch verschachtelten Klasse innerhalb ihrer äußeren Klasse arbeiten, werden Sie keinen Unterschied zur gewöhnlichsten (nicht verschachtelten und nicht statischen) Klasse bemerken.

Beispiel:

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

Wenn Sie eine statisch verschachtelte Klasse nehmen und sie aus ihrer äußeren Klasse verschieben, ändert sich nur, dass die neue Klasse nicht mehr auf die Variablen und Methoden ihrer früheren äußeren Klasse zugreifen kann .private static

Beispiel:

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

Die mainMethode in der gewöhnlichen PointKlasse kann nicht auf die private static pointsVariable der SolutionKlasse zugreifen!

Dies ist der Hauptunterschied zwischen einer statischen verschachtelten Klasse und einer gewöhnlichen Klasse. Methoden einer statisch verschachtelten Klasse können auf alle statischen Variablen und Methoden ihrer äußeren Klasse zugreifen, auch wenn diese deklariert sind private.

Und wenn Sie darüber nachdenken, warum sollte das überraschend sein? Der privateModifikator besagt ausdrücklich, dass auf die durch diesen Modifikator markierten Variablen und Methoden nur innerhalb ihrer Klasse zugegriffen werden kann. Befindet sich eine statisch verschachtelte Klasse innerhalb ihrer äußeren Klasse? Ja, also kein Problem! Greifen Sie so oft darauf zu, wie Sie möchten.