Statiska klasser

1. Inre klasser

Du lärde dig nyligen att det finns statiska variabler och statiska metoder. Det visar sig att det också finns statiska klasser. Men vi kommer att närma oss detta ämne på avstånd.

I Java är du helt tillåten att deklarera klasser inom klasser. Och även klasser inom klasser som är inom klasser inom klasser. Det hela ser väldigt enkelt ut:

class OuterClass
{
   variables of the class
   methods of the class

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

Vi deklarerar bara en klass i en annan. Så enkelt som det.

Exempel:

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

Kapslade klasser kan vara statiska eller icke-statiska. Statiska kapslade klasser kallas helt enkelt statiska kapslade klasser . Icke-statiska kapslade klasser kallas inre klasser ( inre klasser ) .

2. Statiska klasser

Statiska kapslade klasser kan användas utanför deras yttre klass. Om en sådan klass har public access-modifieraren kan den användas var som helst i programmet. Sådana klasser går nästan inte att skilja från någon vanlig klass. Men det finns ett par skillnader.

Klassnamn

Om du vill referera till en statisk kapslad klass från någon annanstans än dess yttre klass, måste du ange klassnamnet, som består av namnet på den yttre klassen och namnet på den kapslade klassen. Här är det allmänna utseendet på detta namn:

OuterClass.InnerClass

Exempel:

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

Om en kapslad klass har sin egen kapslade klass sammanfogas deras namn helt enkelt med en punkt.

Ett typiskt exempel på en kapslad klass i JDK är Entryklassen inuti Mapklassen. Om du vill få uppsättningen nyckel-värdepar lagrade i ett HashMapobjekt, använd entrySet()metoden som returnerar en .Set<Map.Entry>

Observera att det är ett exempel på en yttre klass och en kapslad klass.Map.Entry

Skapa ett objekt

Det är väldigt enkelt att skapa ett objekt av en statisk kapslad klass. Så här ser det ut:

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

Det är samma sak som med vanliga klasser, men namnet består av två delar.

Anropar statiska metoder

Om en statisk klass har statiska metoder kan du komma åt dem på samma sätt som de statiska metoderna för vanliga klasser (men klassnamnet kommer att bestå av två delar).

OuterClass.NestedClass.staticMethod();

Tillgång till statiska variabler

Det är också lätt att komma åt de offentliga statiska variablerna för en kapslad klass:

OuterParent.NestedClass.nameOfStaticVariable

3. Funktioner av statiska klasser

Statiska kapslade klasser har minst anledning att kallas statiska. De beter sig precis som vanliga klasser . Det finns inga begränsningar för att komma åt dem från icke-statiska metoder.

Om du arbetar med en statisk kapslad klass i dess yttre klass kommer du inte att märka någon skillnad från den vanligaste (inte kapslade och inte statiska) klassen.

Exempel:

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

Om du tar någon statisk kapslad klass och flyttar den från sin yttre klass, är det enda som kommer att förändras att den nya klassen inte längre kommer att kunna komma åt private staticvariablerna och metoderna för sin tidigare yttre klass.

Exempel:

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 vanliga Pointklassen kan inte komma åt private static pointsklassens variabel Solution!

Detta är huvudskillnaden mellan en statisk kapslad klass och en vanlig klass. Metoder för en statisk kapslad klass kan komma åt alla statiska variabler och metoder för deras yttre klass, även om de är deklarerade private.

Och om du tänker efter, varför skulle det vara förvånande? Modifieraren privatesäger uttryckligen att variablerna och metoderna markerade av denna modifierare endast kan nås från deras klass. Finns en statisk kapslad klass i dess yttre klass? Ja, så inga problem! Få tillgång till dem så mycket du vill.