Statyczne klasy zagnieżdżone
Definiuj statyczne klasy zagnieżdżone jako powiązane typy pomocnicze, które nie przechowują odwołania do instancji klasy obejmującej.
Statyczne klasy zagnieżdżone to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.
Statyczne klasy zagnieżdżone
Statyczna klasa zagnieżdżona jest definiowana wewnątrz innej klasy za pomocą słowa kluczowego static. Nie ma odwołania do instancji klasy zewnętrznej — jest z nią jedynie logicznie powiązana.
Deklarowanie statycznej klasy zagnieżdżonej
Aby uzyskać dostęp do klasy zagnieżdżonej z zewnątrz, użyj nazwy klasy zewnętrznej.
class LinkedList<T> {
private Node<T> head;
// Static nested class — no outer instance reference
private static class Node<T> {
T data;
Node<T> next;
Node(T data) { this.data = data; }
}
public void addFirst(T item) {
Node<T> node = new Node<>(item);
node.next = head;
head = node;
}
}Dostęp z zewnątrz
Odwołuj się do publicznej statycznej klasy zagnieżdżonej jako OuterClass.InnerClass.
class Builder {
public static class Config {
public final String host;
public final int port;
Config(String host, int port) {
this.host = host; this.port = port;
}
}
}
Builder.Config config = new Builder.Config("localhost", 8080);
System.out.println(config.host + ":" + config.port); // localhost:8080Statyczna klasa zagnieżdżona a klasa wewnętrzna
Kluczowa różnica: statyczne klasy zagnieżdżone NIE mają niejawnego odwołania do instancji klasy zewnętrznej. Klasy wewnętrzne (niestatyczne) MAJĄ takie odwołanie.
class Outer {
private int x = 10;
// Static nested: no access to x
static class StaticNested {
void doSomething() {
// System.out.println(x); // compile error — no outer reference!
System.out.println("Static nested");
}
}
// Inner class: has access to x
class Inner {
void doSomething() {
System.out.println(x); // 10 — can access outer fields
}
}
}Wzorzec Builder ze statyczną klasą zagnieżdżoną
Klasyczny wzorzec Builder używa statycznej klasy zagnieżdżonej, dzięki czemu wywołujący nie potrzebuje instancji klasy zewnętrznej, aby utworzyć builder.
class Pizza {
private final String size, crust;
private final List<String> toppings;
private Pizza(Builder b) {
this.size = b.size; this.crust = b.crust; this.toppings = List.copyOf(b.toppings);
}
public static class Builder {
private String size = "medium", crust = "thin";
private List<String> toppings = new ArrayList<>();
public Builder size(String s) { this.size = s; return this; }
public Builder crust(String c) { this.crust = c; return this; }
public Builder topping(String t) { this.toppings.add(t); return this; }
public Pizza build() { return new Pizza(this); }
}
}Wpisy w mapach
Map.Entry to dobrze znany statyczny zagnieżdżony interfejs używany do iterowania po parach klucz-wartość.
import java.util.*;
Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87, "Carol", 92);
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
System.out.printf("%-10s: %d%n", entry.getKey(), entry.getValue());
}
// Modern: using var
for (var entry : scores.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}Testowanie ze statyczną klasą zagnieżdżoną
W testach jednostkowych statyczna klasa zagnieżdżona może przechowywać dane testowe lub implementacje mock ograniczone do klasy testowej.
class UserServiceTest {
// Static nested fake/stub — no outer instance needed
static class FakeUserRepository implements UserRepository {
private final Map<Long, User> store = new HashMap<>();
public void save(User u) { store.put(u.id(), u); }
public Optional<User> findById(long id) {
return Optional.ofNullable(store.get(id));
}
}
// @Test methods use FakeUserRepository
void testFindUser() {
FakeUserRepository repo = new FakeUserRepository();
// ...
}
}Statyczne klasy zagnieżdżone w logice domenowej
Grupuj powiązane typy za pomocą statycznych klas zagnieżdżonych, aby lepiej organizować modele domeny.
class Order {
private final long id;
private final List<LineItem> items;
// Static nested — logically belongs to Order, no outer reference needed
public static class LineItem {
public final String sku;
public final int quantity;
public final double unitPrice;
public LineItem(String sku, int qty, double price) {
this.sku = sku; this.quantity = qty; this.unitPrice = price;
}
public double total() { return quantity * unitPrice; }
}
// ...
}Porównanie: statyczna klasa zagnieżdżona a klasa najwyższego poziomu
Preferuj statyczną klasę zagnieżdżoną, gdy dana klasa jest używana wyłącznie w kontekście klasy zewnętrznej. Użyj klasy najwyższego poziomu, gdy ma szersze zastosowanie.
Statyczne klasy zagnieżdżone z typami generycznymi
Statyczne klasy zagnieżdżone uczestniczą w mechanizmie typów generycznych tak samo jak klasy najwyższego poziomu.
class Pair<A, B> {
// Static nested with its own type params
public static class Mutable<X, Y> {
public X first;
public Y second;
public Mutable(X first, Y second) {
this.first = first; this.second = second;
}
}
public static <X, Y> Mutable<X, Y> mutableOf(X x, Y y) {
return new Mutable<>(x, y);
}
}
Pair.Mutable<String, Integer> p = Pair.mutableOf("Alice", 30);
System.out.println(p.first + " is " + p.second); // Alice is 30Efektywność pamięciowa
Statyczne klasy zagnieżdżone nie przechowują odwołania do instancji klasy zewnętrznej. Zapobiega to przypadkowemu utrzymywaniu obiektu zewnętrznego w pamięci, co może powodować wycieki pamięci w strukturach o długim czasie życia.
Szybki test
Co odróżnia statyczną klasę zagnieżdżoną od klasy wewnętrznej (niestatycznej)?
Podsumowanie: statyczne klasy zagnieżdżone
Najważniejsze informacje:
- Statyczne klasy zagnieżdżone są powiązane z klasą zewnętrzną, ale nie mają odwołania do jej instancji
- Dostęp z zewnątrz: OuterClass.NestedClass
- Brak niejawnego odwołania oznacza brak przypadkowego utrzymywania instancji klasy zewnętrznej w pamięci
- Wzorzec Builder często korzysta ze statycznej zagnieżdżonej klasy Builder
- Map.Entry to dobrze znany statyczny zagnieżdżony interfejs
- Preferuj statyczną klasę zagnieżdżoną, gdy klasa wewnętrzna nie potrzebuje dostępu do instancji klasy zewnętrznej
Często zadawane pytania
Czy lekcja „Statyczne klasy zagnieżdżone” jest bezpłatna?
Tak — pełny tekst „Statyczne klasy zagnieżdżone” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Statyczne klasy zagnieżdżone”?
Definiuj statyczne klasy zagnieżdżone jako powiązane typy pomocnicze, które nie przechowują odwołania do instancji klasy obejmującej. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Java Academy?
Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Statyczne klasy zagnieżdżone”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?
Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Statyczne klasy zagnieżdżone
- Klasy wewnętrzne i dostęp do klasy zewnętrznej
- Klasy lokalne i anonimowe
- Wybór właściwej strategii zagnieżdżania