Statiske klasser

1. Indre klasser

Du har nylig lært at det finnes statiske variabler og statiske metoder. Det viser seg at det også finnes statiske klasser. Men vi skal nærme oss dette emnet på avstand.

I Java har du fullt lov til å deklarere klasser i klasser. Og til og med klasser i klasser som er innenfor klasser i klasser. Det hele ser veldig enkelt ut:

class OuterClass
{
   variables of the class
   methods of the class

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

Vi erklærer bare en klasse i en annen. Så enkelt som det.

Eksempel:

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

Nestede klasser kan være statiske eller ikke-statiske. Statiske nestede klasser kalles ganske enkelt statiske nestede klasser . Ikke-statiske nestede klasser kalles indre klasser ( indre klasser ).

2. Statiske klasser

Statiske nestede klasser kan brukes utenfor deres ytre klasse. Hvis en slik klasse har modifikatoren for offentlig tilgang, kan den brukes hvor som helst i programmet. Slike klasser kan nesten ikke skilles fra noen vanlig klasse. Men det er et par forskjeller.

Klassenavn

Hvis du vil referere til en statisk nestet klasse fra et annet sted enn dens ytre klasse, må du spesifisere klassenavnet, som består av navnet på den ytre klassen og navnet på den nestede klassen. Her er det generelle utseendet til dette navnet:

OuterClass.InnerClass

Eksempler:

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

Hvis en nestet klasse har sin egen nestede klasse, kobles navnene deres ganske enkelt sammen med en prikk.

Et typisk eksempel på en nestet klasse i JDK er Entryklassen inne i Mapklassen. Hvis du ønsker å få settet med nøkkelverdi-par lagret i et HashMapobjekt, bruk entrySet()metoden, som returnerer en .Set<Map.Entry>

Merk at det er et eksempel på en ytre klasse og en nestet klasse.Map.Entry

Opprette et objekt

Det er veldig enkelt å lage et objekt av en statisk nestet klasse. Slik ser det ut:

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

Det er det samme som med vanlige klasser, men navnet består av to deler.

Kaller statiske metoder

Hvis en statisk klasse har statiske metoder, kan du få tilgang til dem på samme måte som de statiske metodene til vanlige klasser (men klassenavnet vil bestå av to deler).

OuterClass.NestedClass.staticMethod();

Tilgang til statiske variabler

Å få tilgang til de offentlige statiske variablene til en nestet klasse er også enkelt:

OuterParent.NestedClass.nameOfStaticVariable

3. Funksjoner av statiske klasser

Statiske nestede klasser har minst grunn til å bli kalt statiske. De oppfører seg akkurat som vanlige klasser . Det er ingen begrensninger for tilgang til dem fra ikke-statiske metoder.

Hvis du arbeider med en statisk nestet klasse i dens ytre klasse, vil du ikke merke noen forskjell fra den mest vanlige (ikke nestet og ikke statisk) klassen.

Eksempel:

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

Hvis du tar en statisk nestet klasse og flytter den ut av den ytre klassen, er det eneste som vil endre seg at den nye klassen ikke lenger vil kunne få tilgang til private staticvariablene og metodene til den tidligere ytre klassen.

Eksempel:

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

Metoden maini den ordinære Pointklassen kan ikke få tilgang til private static pointsvariabelen til Solutionklassen!

Dette er hovedforskjellen mellom en statisk nestet klasse og en vanlig klasse. Metoder for en statisk nestet klasse kan få tilgang til alle statiske variabler og metoder for deres ytre klasse, selv om de er deklarert private.

Og hvis du tenker på det, hvorfor skulle det være overraskende? Modifikatoren privatesier eksplisitt at variablene og metodene som er merket med denne modifikatoren kun kan nås fra klassen deres. Er en statisk nestet klasse innenfor dens ytre klasse? Ja, så ikke noe problem! Få tilgang til dem så mye du vil.