class OuterClass {
...
static class StaticNestedClass {
...
}
class InnerClass {
...
}
}- Niestatyczne klasy zagnieżdżone - niestatyczne klasy zagnieżdżone. Nazywa się je także klasami wewnętrznymi w inny sposób.
- Statyczne klasy zagnieżdżone - statyczne klasy zagnieżdżone.
- klasa lokalna
- klasa anonimowa
Na dzisiejszym wykładzie porozmawiamy o klasach Inner - klasach wewnętrznych (są to także niestatyczne klasy zagnieżdżone, niestatyczne klasy zagnieżdżone). Są one specjalnie wyróżnione na ogólnym schemacie, żebyście się nie zgubili :) Zacznijmy od oczywistego pytania: dlaczego te klasy nazywają się „wewnętrznymi”? Odpowiedź jest dość prosta: ponieważ są tworzone wewnątrz innych klas. Oto przykład:
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("Iść!");
}
public class HandleBar {
public void right() {
System.out.println("Kierownica w prawo!");
}
public void left() {
System.out.println("Kierownica w lewo!");
}
}
public class Seat {
public void up() {
System.out.println("Siedzenie jest w górze!");
}
public void down() {
System.out.println("Siedzenie jest opuszczone!");
}
}
}Bicycle- rower. Ma 2 pola i 1 metodę - start(). 
Różni się od zwykłej klasy tym, że ma dwie klasy, których kod jest zapisany w środku Bicycle- są to klasy HandleBar(kierownica) i Seat(fotel). Są to pełnoprawne klasy: jak widać, każda z nich ma swoje własne metody. W tym momencie możesz mieć pytanie: dlaczego umieściliśmy jedną klasę w drugiej? Po co umieszczać je wewnętrznie? OK, powiedzmy, że potrzebujemy w programie oddzielnych klas dla kierownicy i siedzenia. Ale nie musisz ich zagnieżdżać! Możesz robić regularne zajęcia. Na przykład tak:
public class HandleBar {
public void right() {
System.out.println("Kierownica w prawo!");
}
public void left() {
System.out.println("kierownica lewa");
}
}
public class Seat {
public void up() {
System.out.println("Siedzenie jest w górze!");
}
public void down() {
System.out.println("Siedzenie jest opuszczone!");
}
}public class Main {
public static void main(String[] args) {
HandleBar handleBar = new HandleBar();
handleBar.right();
}
}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();
}
}
Сиденье поднято выше!
Поехали!
Руль влево!
Руль вправо!
W tej sytuacji nasze poprzednie rozwiązanie zakończy się niepowodzeniem. W sklepie z częściami każda pojedyncza część roweru ma znaczenie nawet poza samą istotą roweru. Na przykład będziemy potrzebować metod takich jak „sprzedaj pedały kupującemu”, „kup nowe siedzenie” itp. Błędem byłoby wykorzystywanie tutaj klas wewnętrznych – każda pojedyncza część roweru w naszym nowym programie ma swoje znaczenie: jest oddzielona od istoty roweru i nie jest z nią w żaden sposób powiązana. Na to powinieneś zwrócić uwagę, jeśli zastanawiasz się, czy potrzebujesz użyć klas wewnętrznych, czy też podzielić wszystkie byty na osobne klasy. Programowanie obiektowe jest świetne, ponieważ ułatwia modelowanie obiektów ze świata rzeczywistego. Tego możesz użyć jako wskazówki przy podejmowaniu decyzji o użyciu klas wewnętrznych. W prawdziwym sklepie części są oddzielone od rowerów - to normalne. Oznacza to, że będzie to poprawne podczas projektowania programu. OK, wyjaśniliśmy „filozofię” :) Teraz zapoznajmy się z ważnymi „technicznymi” cechami klas wewnętrznych. Oto, co zdecydowanie musisz zapamiętać i zrozumieć:
-
Obiekt klasy wewnętrznej nie może istnieć bez obiektu klasy „zewnętrznej”.
To logiczne: dlatego zrobiliśmy z tego zajęcia
SeatwewnętrzneHandleBar, aby kierownice i fotele bez właściciela nie pojawiały się tu i ówdzie w naszym programie.Ten kod się nie skompiluje:
public static void main(String[] args) { HandleBar handleBar = new HandleBar(); }Wynika z tego następująca ważna cecha:
-
Obiekt klasy wewnętrznej ma dostęp do zmiennych klasy „zewnętrznej”.
Przykładowo dodajmy do naszej klasy
Bicyclezmiennąint seatPostDiameter– średnicę sztycy.Następnie w klasie wewnętrznej
Seatmożemy stworzyć metodęgetSeatParam(), która poinformuje nas o parametrze seat: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("Iść!"); } public class Seat { public void up() { System.out.println("Siedzenie jest w górze!"); } public void down() { System.out.println("Siedzenie jest opuszczone!"); } public void getSeatParam() { System.out.println("Parametr siodła: średnica sztycy = " + Bicycle.this.seatPostDiameter); } } }A teraz możemy uzyskać te informacje w naszym programie:
public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle("Peugeot", 120, 40); Bicycle.Seat seat = bicycle.new Seat(); seat.getSeatParam(); } }Wyjście konsoli:
Параметр сиденья: диаметр подседельного штыря = 40Zwróć uwagę:nowa zmienna jest deklarowana z najsurowszym modyfikatorem -
private. A mimo to klasa wewnętrzna ma dostęp! -
Obiektu klasy wewnętrznej nie można utworzyć w metodzie statycznej klasy „zewnętrznej”.
Wyjaśnia to cechy konstrukcyjne klas wewnętrznych. Klasa wewnętrzna może mieć konstruktory z parametrami lub tylko konstruktor domyślny. Ale niezależnie od tego, kiedy tworzymy obiekt klasy wewnętrznej, po cichu przekazywana jest do niego referencja do obiektu klasy „zewnętrznej”. W końcu obecność takiego obiektu jest warunkiem wstępnym. W przeciwnym razie nie będziemy mogli stworzyć obiektów klasy wewnętrznej.
Ale jeśli metoda klasy zewnętrznej jest statyczna, wówczas obiekt klasy zewnętrznej może w ogóle nie istnieć! Oznacza to, że logika klasy wewnętrznej zostanie złamana. W takiej sytuacji kompilator zgłosi błąd:
public static Seat createSeat() { //Bicycle.this cannot be referenced from a static context return new Seat(); } -
Klasa wewnętrzna nie może zawierać zmiennych i metod statycznych.
Logika tutaj jest taka sama: metody i zmienne statyczne mogą istnieć i być wywoływane nawet jeśli nie ma obiektu.
Ale bez obiektu klasy „zewnętrznej” nie będziemy mieli dostępu do klasy wewnętrznej.
Oczywista sprzeczność! Dlatego obecność zmiennych i metod statycznych w klasach wewnętrznych jest zabroniona.
Kompilator zgłosi błąd podczas próby ich utworzenia:
public class Bicycle { private int weight; public class Seat { //inner class cannot have static declarations public static void getSeatParam() { System.out.println("Parametr siodła: średnica sztycy = " + Bicycle.this.seatPostDiameter); } } } -
Podczas tworzenia obiektu klasy wewnętrznej ważną rolę odgrywa jego modyfikator dostępu.
Klasę wewnętrzną można oznaczyć za pomocą standardowych modyfikatorów dostępu -
public, i .privateprotectedpackage privateDlaczego to jest ważne?
Ma to wpływ na to, gdzie w naszym programie możemy utworzyć instancję klasy wewnętrznej.
Jeśli nasza klasa
Seatjest zadeklarowana jakopublic, możemy utworzyć jej obiekty w dowolnej innej klasie. Jedynym wymaganiem jest to, że musi także istnieć obiekt klasy „zewnętrznej”.Nawiasem mówiąc, już to zrobiliśmy tutaj:
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(); } }Z łatwością uzyskaliśmy dostęp do klasy wewnętrznej
HandleBarzMain.Jeśli zadeklarujemy klasę wewnętrzną jako
private, będziemy mieli dostęp tylko do tworzenia obiektów w obrębie klasy „zewnętrznej”.SeatNie będziemy już mogli stworzyć obiektu z zewnątrz:private class Seat { //metody } public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle("Peugeot", 120, 40); //Bicycle.Seat has a private access in 'Bicycle' Bicycle.Seat seat = bicycle.new Seat(); } }Pewnie już rozumiesz logikę :)
-
Modyfikatory dostępu dla klas wewnętrznych działają tak samo jak w przypadku zwykłych zmiennych.
Modyfikator
protectedzapewnia dostęp do zmiennej klasy w jej klasach potomnych oraz w klasach znajdujących się w tym samym pakiecie.To samo
protecteddotyczy klas wewnętrznych. Obiektyprotectedklas wewnętrznych można tworzyć:- wewnątrz klasy „zewnętrznej”;
- w swoich klasach potomnych;
- w tych klasach, które są w tym samym pakiecie.
Jeśli klasa wewnętrzna nie ma modyfikatora dostępu (
package private), można utworzyć obiekty klasy wewnętrznej- wewnątrz klasy „zewnętrznej”;
- w klasach znajdujących się w tym samym pakiecie.
Modyfikatory znasz od dawna, więc tutaj nie będzie żadnych problemów.
GO TO FULL VERSION