Beágyazott osztályok Java-ban

1. Bemutatkozás

Ez a bemutató gyors és pontos bevezetést jelent a beágyazott osztályokhoz a Java nyelven.

Egyszerűen fogalmazva: a Java lehetővé teszi számunkra, hogy osztályokat definiáljunk más osztályokon belül. A beágyazott osztályok lehetővé teszik, hogy logikailag csoportosítsuk a csak egy helyen használt osztályokat, olvashatóbb és karbantarthatóbb kódokat írjunk és növeljük a beágyazást.

Mielőtt belekezdenénk, nézzük meg a nyelven elérhető többféle beágyazott osztályt:

  • Statikus beágyazott osztályok
  • Nem statikus beágyazott osztályok
  • Helyi osztályok
  • Névtelen osztályok

A következő szakaszokban ezeket részletesen megvitatjuk.

2. Statikus beágyazott osztályok

A statikus beágyazott osztályokról itt van néhány emlékezetes dolog:

  • Csakúgy, mint a statikus tagoknál, ezek is a záróosztályukhoz tartoznak, és nem az osztály egyik példányához
  • Nyilatkozatukban minden típusú hozzáférés-módosító szerepelhet
  • Csak a csatoló osztály statikus tagjaihoz férnek hozzá
  • Meghatározhatnak statikus és nem statikus tagokat is

Nézzük meg, hogyan deklarálhatjuk a statikus beágyazott osztályt:

public class Enclosing {private static int x = 1; public static class StaticNested {private void run () {// módszer implementáció}} @Test public void test () {Enclosing.StaticNested beágyazott = new Enclosing.StaticNested (); beágyazott.run (); }}

3. Nem statikus beágyazott osztályok

Ezután íme néhány gyors emlékezet a nem statikus beágyazott osztályokról:

  • Belső osztályoknak is nevezik őket
  • Nyilatkozatukban minden típusú hozzáférés-módosító szerepelhet
  • Csakúgy, mint a példányváltozók és a módszerek, a belső osztályok is társulnak a becsatoló osztály egy példányához
  • Hozzáférhetnek a bezáró osztály minden tagjához, függetlenül attól, hogy statikusak vagy nem statikusak
  • Csak nem statikus tagokat határozhatnak meg

Így nyilváníthatunk belső osztályt:

nyilvános osztály Külső {nyilvános osztály belső {// ...}}

Ha beágyazott osztályt deklarálunk egy módosítóval statikus, akkor ez egy statikus tag. Egyébként ez egy belső osztály. Annak ellenére, hogy szintaktikailag a különbség csak egyetlen kulcsszó (azaz statikus), szemantikailag óriási különbség van az ilyen típusú beágyazott osztályok között. A belső osztály példányai a záró osztályokhoz vannak kötve, és ezért hozzáférhetnek tagjaikhoz. Tisztában kell lennünk ezzel a kérdéssel, amikor kiválasztjuk, hogy a beágyazott osztály belső osztály legyen-e.

A belső osztály példaképéhez először be kell mutatnunk a záró osztályát.

Lássuk, hogyan tehetjük ezt meg:

Külső külső = új Külső (); Külső belső belső = külső.új belső ();

A következő alfejezetekben néhány speciális típusú belső osztályt mutatunk be.

3.1. Helyi osztályok

A helyi osztályok a belső osztályok speciális típusai - amelyekben az osztályt egy módszer belsejében határozzuk meg vagy hatókör blokk.

Nézzünk meg néhány megjegyzendő megjegyzést az ilyen típusú órákról:

  • Nyilatkozatukban nem lehetnek hozzáférés-módosítók
  • Statikus és nem statikus tagokhoz is hozzáférhetnek a mellékelt kontextusban
  • Csak példánytagokat határozhatnak meg

Itt egy rövid példa:

public class NewEnclosing {void run () {class Local {void run () {// módszer implementáció}} Local local = new Local (); local.run (); } @Test public void test () {NewEnclosing newEnclosing = new NewEnclosing (); newEnclosing.run (); }}

3.2. Névtelen osztályok

Az anonim osztályok felhasználhatók egy felület vagy egy absztrakt osztály megvalósításának meghatározására anélkül, hogy újrafelhasználható megvalósítást kellene létrehozni.

Soroljunk fel néhány pontot, amelyet érdemes megjegyezni az anonim órákról:

  • Nyilatkozatukban nem lehetnek hozzáférés-módosítók
  • Statikus és nem statikus tagokhoz is hozzáférhetnek a mellékelt kontextusban
  • Csak példánytagokat határozhatnak meg
  • Ők az egyetlen olyan beágyazott osztályok, amelyek nem definiálhatják a konstruktorokat, illetve nem terjeszthetik / implementálhatják más osztályokat vagy interfészeket

Anonim osztály definiálásához először adjunk meg egy egyszerű absztrakt osztályt:

absztrakt osztály SimpleAbstractClass {absztrakt void run (); }

Most nézzük meg, hogyan definiálhatunk egy névtelen osztályt:

public class AnonymousInnerUnitTest {@Test public void whenRunAnonymousClass_thenCorrect () {SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass () {void run () {// metódus implementáció}}; simpleAbstractClass.run (); }}

További részletekért hasznosnak találhatjuk a Java névtelen óráiról szóló oktatóanyagunkat.

4. Árnyékolás

A belső osztály tagjainak nyilatkozata árnyékolja a befogadó osztály tagjait ha azonos a nevük.

Ebben az esetben a ez kulcsszó a beágyazott osztály példányaira utal, a külső osztály tagjaira pedig a külső osztály nevével lehet hivatkozni.

Lássunk egy gyors példát:

nyilvános osztály NewOuter {int a = 1; statikus int b = 2; nyilvános osztály InnerClass {int a = 3; statikus végső int b = 4; public void run () {System.out.println ("a =" + a); System.out.println ("b =" + b); System.out.println ("NewOuterTest.this.a =" + NewOuter.this.a); System.out.println ("NewOuterTest.b =" + NewOuter.b); System.out.println ("NewOuterTest.this.b =" + NewOuter.this.b); }} @Test public void teszt () {NewOuter external = new NewOuter (); NewOuter.InnerClass belső = külső.új InnerClass (); belső.fut (); }}

5. Sorosítás

Hogy elkerülje a java.io.NotSerializableException miközben megpróbálunk beágyazott osztályt sorosítani, meg kell tennünk:

  • Nyilvánítsa a beágyazott osztályt statikus
  • Hajtsa végre mind a beágyazott osztályt, mind a becsatoló osztályt Sorosítható

6. Következtetés

Ebben a cikkben megnéztük, hogy melyek a beágyazott osztályok és azok típusai. Megvizsgáltuk azt is, hogy a terepi láthatóság és a hozzáférés módosítói hogyan különböznek ezeken a különböző típusokon.

Mint mindig, ennek az oktatóanyagnak a teljes megvalósítása megtalálható a GitHubon.