Beágyazott belső osztályok

Szia! Ma egy fontos témával foglalkozunk: hogyan működnek a beágyazott osztályok a Java-ban. A Java lehetővé teszi osztályok létrehozását egy másik osztályon belül:

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

Ezeket a belső osztályokat beágyazottnak nevezzük. 2 típusra oszthatók:

1. Nem statikus beágyazott osztályok. Ezeket belső osztályoknak is nevezik.
2. Statikus beágyazott osztályok.

A belső osztályoknak viszont két különálló alkategóriája van. Amellett, hogy egy belső osztály egyszerűen belső osztály, lehet:

• egy helyi osztály
• egy névtelen osztály

Zavaros? :) Rendben van. Itt van egy diagram az egyértelműség kedvéért. Térjen vissza az óra alatt, ha hirtelen összezavarodik! A mai leckében a belső osztályokról (más néven nem statikus beágyazott osztályokról) fogunk beszélni. Az általános diagramon külön kiemelve vannak, hogy ne tévedj el :) Kezdjük a nyilvánvaló kérdéssel: miért nevezik őket "belső" osztályoknak? A válasz nagyon egyszerű: mert más osztályokon belül jönnek létre. Íme egy példa:

public class Bicycle {

   private String model;
   private int weight;

   public Bicycle(String model, int weight) {
       this.model = model;
       this.weight = weight;
   }
  
   public void start() {
       System.out.println("Let's go!");
   }

   public class Handlebar {

       public void right() {
           System.out.println("Steer right!");
       }

       public void left() {

           System.out.println("Steer left!");
       }
   }

   public class Seat {
      
       public void up() {

           System.out.println("Seat up!");
       }
      
       public void down() {

           System.out.println("Seat down!");
       }
   }
}

Itt van az Bicycleosztály. 2 mezője és 1 metódusa van: start(). Abban különbözik a közönséges osztálytól, hogy két osztályt tartalmaz: Handlebarés Seat. A kódjuk az osztályon belül van írva Bicycle. Ezek teljes értékű osztályok: mint látható, mindegyiknek megvan a maga módszere. Ezen a ponton felmerülhet a kérdés: mi a fenéért helyeznénk el egyik osztályt a másikba? Miért kell őket belső osztályokká tenni? Nos, tegyük fel, hogy külön osztályokra van szükségünk a programunkban a kormány és az ülés fogalmához. Természetesen nem szükséges, hogy beágyazzuk őket! Készíthetünk rendes órákat. Például így:

public class Handlebar {
   public void right() {
       System.out.println("Steer right!");
   }

   public void left() {

       System.out.println("Steer left");
   }
}

public class Seat {

   public void up() {

       System.out.println("Seat up!");
   }

   public void down() {

       System.out.println("Seat down!");
   }
}

Nagyon jó kérdés! Természetesen nem korlátoz minket a technológia. Ez természetesen egy lehetőség. Itt inkább az órák helyes kialakítása az adott program és annak célja szempontjából a fontos. A belső osztályok egy olyan entitás elkülönítésére szolgálnak, amely elválaszthatatlanul kapcsolódik egy másik entitáshoz. A kormány, az ülések és a pedálok a kerékpár részei. A biciklitől elválasztva nincs sok értelmük. Ha ezeket a fogalmakat külön nyilvános osztályokká tesszük, akkor a programunkban a következő kódot kaptuk volna:

public class Main {

   public static void main(String[] args) {
       Handlebar handlebar = new Handlebar();
       handlebar.right();
   }
}

Hmm... Ennek a kódnak a jelentését még nehéz megmagyarázni. Van egy bizonytalan kormányunk (miért van rá szükség? Fogalmam sincs, hogy őszinte legyek). És ez a fogantyú jobbra fordul... magától, bicikli nélkül... valamiért. A kormány és a kerékpár fogalmának elválasztásával némi logikát veszítettünk programunkból. Egy belső osztály használatával a kód nagyon eltérően néz ki:

public class Main {

   public static void main(String[] args) {

       Bicycle peugeot = new Bicycle("Peugeot", 120);
       Bicycle.Handlebar handlebar = peugeot.new Handlebar();
       Bicycle.Seat seat = peugeot.new Seat();

       seat.up();
       peugeot.start();
       handlebar.left();
       handlebar.right();
   }
}

Konzol kimenet:

Seat up! 
Let's go! 
Steer left! 
Steer right!

Most, amit látunk, hirtelen értelmet nyer! :) Bicikli objektumot alkottunk. Létrehoztunk két kerékpáros "altárgyat" - egy kormányt és egy ülést. Felemeltük az ülést a kényelem kedvéért, és indultunk is: pedálozunk és kormányozunk, ahogy kellett! :) A szükséges metódusokat a megfelelő objektumokon hívjuk meg. Mindez egyszerű és kényelmes. Ebben a példában a kormány és az ülés szétválasztása javítja a tokozást (az adott osztályon belül elrejti a kerékpáralkatrészek adatait), és lehetővé teszi egy részletesebb absztrakció létrehozását. Most nézzünk egy másik helyzetet. Tegyük fel, hogy szeretnénk létrehozni egy programot, amely szimulál egy kerékpárboltot és a kerékpárok alkatrészeit. Ebben a helyzetben a korábbi megoldásunk nem működik. Egy kerékpárboltban minden egyes kerékpáralkatrésznek van értelme még akkor is, ha elválasztják a kerékpártól. Például szükségünk lesz olyan módszerekre, mint a „pedálok eladása az ügyfélnek”, „új ülés vásárlása”, stb. Hiba lenne itt belső osztályokat használni – új programunkban minden egyes kerékpár alkatrésznek van jelentése, amely megállja a helyét. sajátja: elválasztható a kerékpár fogalmától. Pontosan erre kell figyelnie, ha arra gondol, hogy belső osztályokat kell-e használnia, vagy az összes entitást külön osztályként kell-e szerveznie. Az objektum-orientált programozás abban jó, hogy egyszerűvé teszi a valós entitások modellezését. Ez lehet a vezérelv a belső osztályok használatának eldöntésekor. Egy igazi boltban, a pótalkatrészek külön vannak a kerékpároktól – ez rendben van. Ez azt jelenti, hogy programtervezéskor is rendben van. Oké, kitaláltuk a "filozófiát" :) Most ismerkedjünk meg a belső órák fontos "technikai" jellemzőivel. Íme, amit feltétlenül emlékezned kell és meg kell értened:

1. Egy belső osztály objektuma nem létezhet egy külső osztály objektuma nélkül.

   Ez logikus: ezért készítettük el programunkban a Seatés a belső osztályokat – hogy ne kerüljön elárvult kormány és ülés.Handlebar

   Ez a kód nem fordítja le:

   
   public static void main(String[] args) {
   
      Handlebar handlebar = new Handlebar();
   }
   

   Ebből egy másik fontos jellemző következik:

2. Egy belső osztály objektuma hozzáfér a külső osztály változóihoz.

   Például adjunk hozzá egy int seatPostDiameterváltozót (amely a nyeregcső átmérőjét jelenti) az osztályunkhoz Bicycle.

   Ezután a Seatbelső osztályban létrehozhatunk egy displaySeatProperties()metódust, amely megjeleníti az ülés tulajdonságait:

   
   public class Bicycle {
   
      private String model;
      private int weight;
   
      private int seatPostDiameter;
   
      public Bicycle(String model, int weight, int seatPostDiameter) {
          this.model = model;
          this.weight = weight;
          this.seatPostDiameter = seatPostDiameter;
   
      }
   
      public void start() {
          System.out.println("Let's go!");
      }
   
      public class Seat {
   
          public void up() {
   
              System.out.println("Seat up!");
          }
   
          public void down() {
   
              System.out.println("Seat down!");
          }
   
          public void displaySeatProperties() {
   
              System.out.println("Seat properties: seatpost diameter = " + Bicycle.this.seatPostDiameter);
          }
      }
   }
   

   És most ezt az információt megjeleníthetjük a programunkban:

   
   public class Main {
   
      public static void main(String[] args) {
   
          Bicycle bicycle = new Bicycle("Peugeot", 120, 40);
          Bicycle.Seat seat = bicycle.new Seat();
   
          seat.displaySeatProperties();
      }
   }
   

   Konzol kimenet:

   
   Seat properties: seatpost diameter = 40
   

   Jegyzet:az új változót a legszigorúbb hozzáférésmódosítóval ( private) deklaráljuk. És még mindig a belső osztálynak van hozzáférése!

3. Egy belső osztály objektuma nem hozható létre egy külső osztály statikus metódusában.

   Ezt a belső osztályok megszervezésének sajátosságai magyarázzák. Egy belső osztály rendelkezhet paraméterekkel rendelkező konstruktorokkal, vagy csak az alapértelmezett konstruktorral. De ettől függetlenül, amikor létrehozunk egy belső osztály objektumát, a külső osztály objektumára való hivatkozás láthatatlanul átkerül a belső osztály létrehozott objektumához. Hiszen egy ilyen tárgyreferencia megléte abszolút követelmény. Ellenkező esetben nem tudjuk létrehozni a belső osztály objektumait.

   De ha a külső osztály metódusa statikus, akkor lehet, hogy nem lesz a külső osztály objektuma! És ez sértené a belső osztály működésének logikáját. Ebben a helyzetben a fordító hibát generál:

   
   public static Seat createSeat() {
     
      // Bicycle.this cannot be referenced from a static context
      return new Seat();
   }
   

4. Egy belső osztály nem tartalmazhat statikus változókat és metódusokat.

   A logika ugyanaz: statikus metódusok és változók létezhetnek, és objektum hiányában is hívhatók vagy hivatkozhatnak rájuk.

   De a külső osztály objektuma nélkül nem lesz hozzáférésünk a belső osztályhoz.

   Egyértelmű ellentmondás! Ez az oka annak, hogy a statikus változók és metódusok nem megengedettek a belső osztályokban.

   A fordító hibát generál, ha megpróbálja létrehozni őket:

   
   public class Bicycle {
   
      private int weight;
   
   
      public class Seat {
         
          // An inner class cannot have static declarations
          public static void displaySeatProperties() {
   
              System.out.println("Seat properties: seatpost diameter = " + Bicycle.this.seatPostDiameter);
          }
      }
   }
   

5. Egy belső osztály objektumának létrehozásakor fontos a hozzáférés módosítója.

   Egy belső osztályt a standard hozzáférés módosítókkal lehet megjelölni: public, private, protected, és package private.

   Miért számít ez?

   Ez befolyásolja, hogy a programunkban hol hozhatunk létre példányokat a belső osztályból.

   Ha az Seatosztályunk a következővel van deklarálva , akkor bármely más osztályban publiclétrehozhatunk objektumokat. SeatAz egyetlen követelmény az, hogy a külső osztály objektumának is léteznie kell.

   Egyébként ezt már megtettük itt:

   
   public class Main {
   
      public static void main(String[] args) {
   
          Bicycle peugeot = new Bicycle("Peugeot", 120);
          Bicycle.Handlebar handlebar = peugeot.new Handlebar();
          Bicycle.Seat seat = peugeot.new Seat();
   
          seat.up();
          peugeot.start();
          handlebar.left();
          handlebar.right();
      }
   }
   

   Az osztályból könnyen bejutottunk a Handlebarbelső osztályba Main.

   Ha a belső osztályt -nak deklaráljuk private, akkor csak a külső osztályon belül tudunk objektumokat létrehozni.

   Seat"Kívülről" már nem tudunk objektumot létrehozni :

   
   private class Seat {
   
      // Methods
   }
   
   public class Main {
   
      public static void main(String[] args) {
   
          Bicycle bicycle = new Bicycle("Peugeot", 120, 40);
   
          // Bicycle.Seat has private access in Bicycle
          Bicycle.Seat seat = bicycle.new Seat();
      }
   }
   

   Valószínűleg már érted a logikát :)

6. A belső osztályokhoz tartozó hozzáférés-módosítók ugyanúgy működnek, mint a közönséges változók esetében.

   A protectedmódosító hozzáférést biztosít egy példányváltozóhoz azokban az alosztályokban és osztályokban, amelyek ugyanabban a csomagban vannak.

   protectedbelső osztályokra is működik. Létrehozhatunk protectedobjektumokat a belső osztályból:

   • a külső osztályban;
   • alosztályaiban;
   • osztályokban, amelyek ugyanabban a csomagban vannak.

   Ha a belső osztály nem rendelkezik hozzáférésmódosítóval ( package private), akkor a belső osztály objektumai létrehozhatók:

   • a külső osztályban;
   • osztályokban, amelyek ugyanabban a csomagban vannak.

   Régóta ismeri a módosítókat, így nincs probléma.

Egyelőre ennyi :) De ne lazsálj! A belső osztályok meglehetősen kiterjedt téma, amelyet a következő leckében folytatunk. Most felfrissítheti az emlékezetét tanfolyamunk belső osztályairól szóló órájáról . És legközelebb beszéljünk a statikus beágyazott osztályokról.