Classes statiques

1. Classes internes

Vous avez récemment appris qu'il existe des variables statiques et des méthodes statiques. Il s'avère qu'il existe également des classes statiques. Mais nous aborderons ce sujet à distance.

En Java, vous êtes entièrement autorisé à déclarer des classes dans des classes. Et même des classes dans des classes qui sont dans des classes dans des classes. Tout a l'air très simple :

class OuterClass
{
   variables of the class
   methods of the class

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

Nous déclarons juste une classe à l'intérieur d'une autre. Aussi simple que cela.

Exemple:

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

Les classes imbriquées peuvent être statiques ou non statiques. Les classes imbriquées statiques sont simplement appelées classes imbriquées statiques . Les classes imbriquées non statiques sont appelées classes internes ( classes internes ).

2. Classes statiques

Les classes imbriquées statiques peuvent être utilisées en dehors de leur classe externe. Si une telle classe a le modificateur d'accès public, elle peut être utilisée n'importe où dans le programme. Ces classes sont presque impossibles à distinguer de toute classe ordinaire. Mais il y a quelques différences.

Nom du cours

Si vous souhaitez faire référence à une classe imbriquée statique à partir d'un endroit autre que sa classe externe, vous devez spécifier le nom de la classe, qui se compose du nom de la classe externe et du nom de la classe imbriquée. Voici l'aspect général de ce nom :

OuterClass.InnerClass

Exemples:

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

Si une classe imbriquée a sa propre classe imbriquée, leurs noms sont simplement joints à l'aide d'un point.

Un exemple typique d'une classe imbriquée dans le JDK est la Entryclasse à l'intérieur de Mapla classe. Si vous souhaitez obtenir l'ensemble des paires clé-valeur stockées dans un HashMapobjet, utilisez la entrySet()méthode, qui renvoie un .Set<Map.Entry>

Notez qu'il s'agit d'un exemple de classe externe et de classe imbriquée.Map.Entry

Création d'un objet

Il est très facile de créer un objet d'une classe imbriquée statique. Voici à quoi ça ressemble:

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

C'est la même chose que pour les classes ordinaires, mais le nom se compose de deux parties.

Appel de méthodes statiques

Si une classe statique a des méthodes statiques, vous pouvez y accéder de la même manière que les méthodes statiques des classes ordinaires (mais le nom de la classe sera composé de deux parties).

OuterClass.NestedClass.staticMethod();

Accéder aux variables statiques

L'accès aux variables statiques publiques d'une classe imbriquée est également facile :

OuterParent.NestedClass.nameOfStaticVariable

3. Caractéristiques des classes statiques

Les classes imbriquées statiques ont le moins de raisons d'être appelées statiques. Ils se comportent comme des classes normales . Il n'y a aucune restriction quant à leur accès à partir de méthodes non statiques.

Si vous travaillez avec une classe imbriquée statique à l'intérieur de sa classe externe, vous ne remarquerez aucune différence par rapport à la classe la plus ordinaire (non imbriquée et non statique).

Exemple:

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

Si vous prenez une classe imbriquée statique et que vous la déplacez hors de sa classe externe, la seule chose qui changera est que la nouvelle classe ne pourra plus accéder aux private staticvariables et aux méthodes de son ancienne classe externe.

Exemple:

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

La mainméthode de la Pointclasse ordinaire ne peut pas accéder à la private static pointsvariable de la Solutionclasse !

C'est la principale différence entre une classe imbriquée statique et une classe ordinaire. Les méthodes d'une classe imbriquée statique peuvent accéder à toutes les variables et méthodes statiques de leur classe externe, même si elles sont déclarées private.

Et si vous y réfléchissez, pourquoi cela devrait-il être surprenant? Le privatemodificateur indique explicitement que les variables et les méthodes marquées par ce modificateur ne sont accessibles qu'à partir de leur classe. Une classe imbriquée statique est-elle à l'intérieur de sa classe externe ? Oui, donc pas de problème ! Accédez-y autant que vous le souhaitez.