Klasy wewnętrzne Java

W Javie niektóre klasy mogą zawierać w sobie inne klasy. Klasy takie nazywane są klasami zagnieżdżonymi. Klasy zdefiniowane w ramach innych klas ogólnie dzielą się na dwie kategorie — statyczne i niestatyczne. Zagnieżdżone klasy niestatyczne nazywane są wewnętrznymi. Klasy zagnieżdżone, które są zadeklarowane jako statyczne, nazywane są statycznymi klasami zagnieżdżonymi. Tak naprawdę nie ma tu nic skomplikowanego, chociaż terminologia wydaje się nieco niejasna i czasami może zmylić nawet profesjonalnego programistę.

Klasy zagnieżdżone i wewnętrzne

Zatem wszystkie klasy znajdujące się wewnątrz innych klas nazywane są klasami zagnieżdżonymi.

class OuterClass {
    ...
    class NestedClass {
        ...
    }
}

Klasy zagnieżdżone, które nie są statyczne, nazywane są klasami wewnętrznymi , a te, które są statyczne, nazywane są statycznymi klasami zagnieżdżonymi . Klasy wewnętrzne Java — 1

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

Zatem wszystkie klasy wewnętrzne są zagnieżdżone, ale nie wszystkie zagnieżdżone są wewnętrzne. To są główne definicje. Klasy wewnętrzne są rodzajem mechanizmu bezpieczeństwa w Javie. Wiemy, że zwykłej klasy nie można powiązać z prywatnym modyfikatorem dostępu. Jeśli jednak nasza klasa jest członkiem innej klasy, wówczas klasę wewnętrzną można ustawić jako prywatną. Ta funkcja jest również używana do uzyskiwania dostępu do członków klasy prywatnej.

Przykład klasy wewnętrznej

Spróbujmy więc stworzyć jakąś klasę, a w niej inną klasę. Wyobraź sobie jakąś modułową konsolę do gier. Istnieje sama „pudełko”, do której można podłączyć określone moduły. Na przykład kontroler do gier, kierownica, kask VR, które z reguły nie działają bez samej konsoli. Tutaj mamy klasę GameConsole. Ma 2 pola i 1 metodę — start() . Różnica pomiędzy GameCosole a klasą, do której jesteśmy przyzwyczajeni, polega na tym, że posiada ona wewnętrzną klasę GameController .

public class GameConsole {
    private String model;
    private int weight;

    public void run() {
        System.out.println("Game console is on");
    }


    public class GameController {

        private String color;

        public void start() {
            System.out.println("start button is pressed");
        }

        public void x() {
            System.out.println("x button is pressed");
        }

        public void y() {
            System.out.println("y button is pressed");
        }
        public void a() {
            System.out.println("a button is pressed");
        }

        public void b() {
            System.out.println("b button is pressed");
        }
        public void mover() {
            System.out.println("mover button is pressed");
        }

    }

}

W tym momencie możesz się zastanawiać: dlaczego nie uczynić tych klas „oddzielnymi”? Nie jest konieczne ich zagnieżdżanie. Rzeczywiście, jest to możliwe. Chodzi raczej o prawidłowe zaprojektowanie klas pod kątem ich wykorzystania. Klasy wewnętrzne tworzone są w celu wyróżnienia w programie encji, która jest nierozerwalnie powiązana z inną encją. Elementami składowymi konsoli są kontroler czy np. kask VR. Tak, można je kupić oddzielnie od konsoli, ale bez niej nie można z nich korzystać. Gdybyśmy uczynili wszystkie te klasy oddzielnymi klasami publicznymi, nasz program mógłby mieć na przykład następujący kod:

public class Main {

   public static void main(String[] args) {
       GameController controller = new GameController();
       controller.x();
   }
}

Nie jest jasne, co stanie się w tym przypadku, ponieważ sam kontroler nie działa bez konsoli. Stworzyliśmy obiekt konsoli do gier. Stworzyliśmy jego podobiekt – kontroler gier. I teraz możemy grać, wystarczy nacisnąć odpowiednie klawisze. Metody, których potrzebujemy, są wywoływane na odpowiednich obiektach. Wszystko jest proste i wygodne. W tym przykładzie wyodrębnienie kontrolera gier poprawia hermetyzację (ukrywamy szczegóły części konsoli w odpowiedniej klasie) i pozwala na bardziej szczegółową abstrakcję. Jeśli jednak stworzymy np. program symulujący sklep, w którym można osobno kupić kask lub kontroler VR, to ten przykład zakończy się niepowodzeniem. Tam lepiej jest stworzyć kontroler gier osobno. Weźmy inny przykład. Wspomnieliśmy powyżej, że możemy ustawić klasę wewnętrzną jako prywatną i nadal wywoływać ją z klasy zewnętrznej. Poniżej znajduje się przykład takich zajęć.

class OuterClass {

   // inner class
   private class InnerClass {
       public void print() {
           System.out.println("We are in the inner class...");
       }
   }

   // method of outer class. We are create an inner class from the method of outer one
   void display() {
       InnerClass inner = new InnerClass();
       inner.print();
   }
}

Tutaj OuterClass jest klasą zewnętrzną, InnerClass jest klasą wewnętrzną, display() jest metodą, wewnątrz której tworzymy obiekt klasy wewnętrznej. Napiszmy teraz klasę demonstracyjną z metodą główną, w której będziemy wywoływać metodę display() .

public class OuterDemoMain {

       public static void main(String args[]) {
           // create an object of the outer class
           OuterDemo outer = new OuterDemo();

           outer.display();
       }
}

Jeśli uruchomisz ten program, otrzymasz następujący wynik:

Jesteśmy w wewnętrznej klasie...

Klasyfikacja klas wewnętrznych

Same klasy wewnętrzne lub zagnieżdżone klasy niestatyczne dzielą się na trzy grupy.

Klasa wewnętrzna taka jaka jest. Tylko jedna niestatyczna klasa w drugiej, jak pokazaliśmy powyżej na przykładzie GameConsole i GameController .
Metoda lokalna Klasa wewnętrzna to klasa znajdująca się wewnątrz metody.
Anonimowa klasa wewnętrzna.

Metoda lokalna Klasa wewnętrzna

W Javie możesz napisać klasę wewnątrz metody i jest to typ lokalny. Podobnie jak zmienne lokalne, zakres klasy wewnętrznej jest ograniczony w ramach metody. Lokalną klasę wewnętrzną metody można utworzyć tylko w ramach metody, w której zdefiniowano klasę wewnętrzną. Pokażmy, jak używać wewnętrznej klasy metody lokalnej.

public class OuterDemo2 {

   //instance method of the outer class OuterDemo2
   void myMethod() {
       String str = "and it's a value from OuterDemo2 class' myMethod ";

       // method-local inner class
       class methodInnerDemo {
           public void print() {
               System.out.println("Here we've got a method inner class... " );
               System.out.println(str);

           }
       }

       // Access to the inner class
       methodInnerDemo inn = new methodInnerDemo();
       inn.print();
   }
}

Teraz napiszemy klasę demonstracyjną z metodą główną, w której wywołamy metodę external() .

public class OuterDemoMain {


   public static void main(String args[]) {
       OuterDemo2 outer = new OuterDemo2();
       outer.myMethod();
   }
}

Dane wyjściowe to:

Tutaj mamy wewnętrzną klasę metody... i jest to wartość z myMethod klasy OuterDemo2

Anonimowa klasa wewnętrzna

Klasa wewnętrzna zadeklarowana bez nazwy klasy nazywana jest anonimową klasą wewnętrzną. Kiedy deklarujemy anonimową klasę wewnętrzną, natychmiast tworzymy jej instancję. Zwykle takich klas używa się zawsze, gdy zachodzi potrzeba przesłonięcia metody klasy lub interfejsu.

abstract class OuterDemo3 {
   public abstract void method();

}
   class outerClass {

       public static void main(String args[]) {
           OuterDemo3 inner = new OuterDemo3() {
               public void method() {
                   System.out.println("Here we've got an example of an  anonymous inner class");
               }
           };
           inner.method();
       }
   }

Dane wyjściowe są tutaj:

Tutaj mamy przykład anonimowej klasy wewnętrznej...

Anonimowa klasa wewnętrzna jako argument

Możesz także przekazać anonimową klasę wewnętrzną jako argument metody. Oto przykład.

interface OuterDemo4 {
       String hello();
   }

   class NewClass {
       // accepts the object of interface
       public void displayMessage(OuterDemo4 myMessage) {
           System.out.println(myMessage.hello());
           System.out.println("example of anonymous inner class as an argument");
       }

       public static void main(String args[]) {
           NewClass newClass = new NewClass();

           //here we pass an anonymous inner class as an argument
           newClass.displayMessage(new OuterDemo4() {
               public String hello() {
                   return "Hello!";
               }
           });
       }
}

Dane wyjściowe są tutaj:

Cześć! przykład anonimowej klasy wewnętrznej jako argumentu

Aby utrwalić zdobytą wiedzę, sugerujemy obejrzenie lekcji wideo z naszego kursu Java