Classi statiche

1. Classi interne

Di recente hai appreso che esistono variabili statiche e metodi statici. Si scopre che ci sono anche classi statiche. Ma affronteremo questo argomento da lontano.

In Java, sei completamente autorizzato a dichiarare classi all'interno di classi. E anche classi all'interno di classi che sono all'interno di classi all'interno di classi. Sembra tutto molto semplice:

class OuterClass
{
   variables of the class
   methods of the class

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

Dichiariamo semplicemente una classe all'interno di un'altra. Così semplice.

Esempio:

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

Le classi annidate possono essere statiche o non statiche. Le classi nidificate statiche sono chiamate semplicemente classi nidificate statiche . Le classi nidificate non statiche sono chiamate classi interne ( inner classes ).

2. Classi statiche

Le classi nidificate statiche possono essere utilizzate al di fuori della loro classe esterna. Se tale classe ha il modificatore di accesso pubblico, può essere utilizzata ovunque nel programma. Tali classi sono quasi indistinguibili da qualsiasi classe ordinaria. Ma ci sono un paio di differenze.

Nome della classe

Se vuoi fare riferimento a una classe nidificata statica da un punto diverso dalla sua classe esterna, devi specificare il nome della classe, che consiste nel nome della classe esterna e nel nome della classe nidificata. Ecco l'aspetto generale di questo nome:

OuterClass.InnerClass

Esempi:

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

Se una classe nidificata ha una propria classe nidificata, i loro nomi vengono semplicemente uniti usando un punto.

Un tipico esempio di una classe nidificata nel JDK è la Entryclasse all'interno della Mapclasse. Se vuoi ottenere l'insieme di coppie chiave-valore memorizzate in un HashMapoggetto, usa il entrySet()metodo, che restituisce un file .Set<Map.Entry>

Si noti che è un esempio di una classe esterna e di una classe nidificata.Map.Entry

Creazione di un oggetto

È molto semplice creare un oggetto di una classe nidificata statica. Ecco come appare:

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

È lo stesso delle classi ordinarie, ma il nome è composto da due parti.

Chiamare metodi statici

Se una classe statica ha metodi statici, puoi accedervi allo stesso modo dei metodi statici delle classi ordinarie (ma il nome della classe sarà composto da due parti).

OuterClass.NestedClass.staticMethod();

Accesso alle variabili statiche

Anche l'accesso alle variabili statiche pubbliche di una classe nidificata è facile:

OuterParent.NestedClass.nameOfStaticVariable

3. Caratteristiche delle classi statiche

Le classi nidificate statiche hanno il minimo motivo per essere chiamate statiche. Si comportano proprio come classi normali . Non ci sono restrizioni sull'accesso da metodi non statici.

Se stai lavorando con una classe annidata statica all'interno della sua classe esterna, non noterai alcuna differenza rispetto alla classe più ordinaria (non annidata e non statica).

Esempio:

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

Se prendi una classe nidificata statica e la sposti fuori dalla sua classe esterna, l'unica cosa che cambierà è che la nuova classe non sarà più in grado di accedere alle private staticvariabili e ai metodi della sua precedente classe esterna.

Esempio:

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

Il mainmetodo nella Pointclasse ordinaria non può accedere alla private static pointsvariabile della Solutionclasse!

Questa è la principale differenza tra una classe nidificata statica e una classe ordinaria. I metodi di una classe nidificata statica possono accedere a tutte le variabili statiche e ai metodi della loro classe esterna, anche se sono dichiarati private.

E se ci pensi, perché dovrebbe essere sorprendente? Il privatemodificatore dice esplicitamente che è possibile accedere alle variabili e ai metodi contrassegnati da questo modificatore solo dall'interno della loro classe. Una classe nidificata statica è all'interno della sua classe esterna? Sì, quindi nessun problema! Accedili quanto vuoi.