Statische lessen

1. Innerlijke klassen

U heeft onlangs vernomen dat er statische variabelen en statische methoden zijn. Het blijkt dat er ook statische klassen zijn. Maar we zullen dit onderwerp van een afstand benaderen.

In Java is het volledig toegestaan ​​om klassen binnen klassen te declareren. En zelfs klassen binnen klassen die binnen klassen binnen klassen zijn. Het ziet er allemaal heel simpel uit:

class OuterClass
{
   variables of the class
   methods of the class

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

We declareren gewoon de ene klasse in de andere. Zo simpel is het.

Voorbeeld:

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

Geneste klassen kunnen statisch of niet-statisch zijn. Statische geneste klassen worden eenvoudigweg statische geneste klassen genoemd . Niet-statische geneste klassen worden innerlijke klassen ( inner classs ) genoemd .

2. Statische lessen

Statische geneste klassen kunnen buiten hun buitenste klasse worden gebruikt. Als een dergelijke klasse de modifier voor openbare toegang heeft, kan deze overal in het programma worden gebruikt. Dergelijke klassen zijn bijna niet te onderscheiden van een gewone klasse. Maar er zijn een paar verschillen.

Naam van de klasse

Als u wilt verwijzen naar een statische geneste klasse van ergens anders dan de buitenste klasse, moet u de klassenaam specificeren, die bestaat uit de naam van de buitenste klasse en de naam van de geneste klasse. Dit is het algemene uiterlijk van deze naam:

OuterClass.InnerClass

Voorbeelden:

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

Als een geneste klasse zijn eigen geneste klasse heeft, worden hun namen eenvoudigweg samengevoegd met een punt.

Een typisch voorbeeld van een geneste klasse in de JDK is de Entryklasse binnen de Mapklasse. Als u de set sleutel-waardeparen in een object wilt opslaan HashMap, gebruikt u de entrySet()methode die een retourneert .Set<Map.Entry>

Merk op dat dit een voorbeeld is van een buitenste klasse en een geneste klasse.Map.Entry

Een voorwerp maken

Het is heel eenvoudig om een ​​object van een statische geneste klasse te maken. Zo ziet het eruit:

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

Het is allemaal hetzelfde als bij gewone klassen, maar de naam bestaat uit twee delen.

Statische methoden aanroepen

Als een statische klasse statische methoden heeft, kunt u deze op dezelfde manier benaderen als de statische methoden van gewone klassen (maar de klassenaam bestaat uit twee delen).

OuterClass.NestedClass.staticMethod();

Toegang tot statische variabelen

Toegang krijgen tot de openbare statische variabelen van een geneste klasse is ook eenvoudig:

OuterParent.NestedClass.nameOfStaticVariable

3. Kenmerken van statische klassen

Statische geneste klassen hebben de minste reden om statisch genoemd te worden. Ze gedragen zich net als gewone klassen . Er zijn geen beperkingen voor toegang via niet-statische methoden.

Als u werkt met een statische geneste klasse binnen de buitenste klasse, merkt u geen verschil met de meest gewone (niet geneste en niet statische) klasse.

Voorbeeld:

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

Als je een statische geneste klasse neemt en deze uit de buitenste klasse haalt, is het enige dat verandert dat de nieuwe klasse niet langer toegang heeft tot de private staticvariabelen en methoden van de vorige buitenste klasse.

Voorbeeld:

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

De mainmethode in de gewone Pointklasse heeft geen toegang tot de private static pointsvariabele van de Solutionklasse!

Dit is het belangrijkste verschil tussen een statische geneste klasse en een gewone klasse. Methoden van een statische geneste klasse hebben toegang tot alle statische variabelen en methoden van hun buitenste klasse, zelfs als ze gedeclareerd zijn private.

En als je erover nadenkt, waarom zou dat verrassend zijn? De privatemodifier zegt expliciet dat de variabelen en methoden gemarkeerd door deze modifier alleen toegankelijk zijn vanuit hun klasse. Is een statische geneste klasse binnen de buitenste klasse? Ja, dus geen probleem! Krijg er zoveel toegang toe als je wilt.