Clasele statice

1. Clasele interioare

Ați aflat recent că există variabile statice și metode statice. Se pare că există și clase statice. Dar vom aborda acest subiect de la distanță.

În Java, aveți permisiunea de a declara clase în cadrul claselor. Și chiar și clase în cadrul claselor care sunt în cadrul claselor în cadrul claselor. Totul pare foarte simplu:

class OuterClass
{
   variables of the class
   methods of the class

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

Doar declarăm o clasă în alta. Simplu ca buna ziua.

Exemplu:

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

Clasele imbricate pot fi statice sau non-statice. Clasele imbricate statice sunt numite pur și simplu clase imbricate statice . Clasele imbricate non-statice sunt numite clase interioare ( clase interioare ).

2. Clase statice

Clasele imbricate statice pot fi utilizate în afara clasei lor exterioare. Dacă o astfel de clasă are modificatorul de acces public, atunci poate fi folosită oriunde în program. Astfel de clase sunt aproape imposibil de distins de orice clasă obișnuită. Dar există câteva diferențe.

Numele clasei

Dacă doriți să vă referiți la o clasă imbricată statică din altă parte decât clasa sa exterioară, trebuie să specificați numele clasei, care constă din numele clasei exterioare și numele clasei imbricate. Iată aspectul general al acestui nume:

OuterClass.InnerClass

Exemple:

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

Dacă o clasă imbricată are propria sa clasă imbricată, numele lor sunt pur și simplu unite folosind un punct.

Un exemplu tipic de clasă imbricată în JDK este Entryclasa din interiorul Mapclasei. Dacă doriți să obțineți setul de perechi cheie-valoare stocate într-un HashMapobiect, atunci utilizați entrySet()metoda, care returnează un .Set<Map.Entry>

Rețineți că este un exemplu de clasă exterioară și clasă imbricată.Map.Entry

Crearea unui obiect

Este foarte ușor să creezi un obiect dintr-o clasă imbricată statică. Așa arată:

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

Este la fel ca la clasele obișnuite, dar numele este format din două părți.

Apelarea metodelor statice

Dacă o clasă statică are metode statice, le puteți accesa în același mod ca și metodele statice ale claselor obișnuite (dar numele clasei va fi format din două părți).

OuterClass.NestedClass.staticMethod();

Accesarea variabilelor statice

Accesarea variabilelor statice publice ale unei clase imbricate este de asemenea ușoară:

OuterParent.NestedClass.nameOfStaticVariable

3. Caracteristici ale claselor statice

Clasele imbricate statice au cel mai mic motiv pentru a fi numite statice. Se comportă la fel ca cursurile obișnuite . Nu există restricții privind accesarea acestora din metode non-statice.

Dacă lucrați cu o clasă imbricată statică în interiorul clasei sale exterioare, nu veți observa nicio diferență față de cea mai obișnuită clasă (nu imbricată și nu statică).

Exemplu:

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

Dacă luați o clasă imbricată statică și o mutați din clasa sa exterioară, singurul lucru care se va schimba este că noua clasă nu va mai putea accesa variabilele private staticși metodele clasei sale exterioare.

Exemplu:

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

Metoda din clasa mainobișnuită nu poate accesa variabila clasei !Pointprivate static pointsSolution

Aceasta este diferența principală dintre o clasă imbricată statică și o clasă obișnuită. Metodele unei clase imbricate statice pot accesa toate variabilele și metodele statice ale clasei lor exterioare, chiar dacă sunt declarate private.

Și dacă te gândești bine, de ce ar trebui să fie surprinzător? Modificatorul privatespune în mod explicit că variabilele și metodele marcate de acest modificator pot fi accesate numai din clasa lor. Este o clasă imbricată statică în interiorul clasei sale exterioare? Da, deci nicio problemă! Accesați-le cât de mult doriți.