Static nested class w Javie - kiedy warto jej użyć?

Tworzysz klasę wewnątrz innej klasy i zastanawiasz się, czy naprawdę potrzebujesz obiektu klasy zewnętrznej? Klasa statyczna w Javie rozwiązuje właśnie ten problem, ale łatwo pomylić ją ze zwykłą klasą wewnętrzną albo klasą zawierającą metody statyczne. Poniżej pokazuję, jak działa, kiedy jej używać, czym różni się od klasy niestatycznej i jakie błędy najczęściej pojawiają się w praktyce.

Czym naprawdę jest klasa statyczna w Javie

W Javie nie istnieje samodzielna „klasa statyczna” na poziomie pliku. Słowo static można zastosować do klasy zagnieżdżonej, czyli takiej, która znajduje się wewnątrz innej klasy. Najtrafniejsza nazwa to static nested class, po polsku statyczna klasa zagnieżdżona.

public class Sklep {
    private static String waluta = "PLN";

    public static class Produkt {
        private String nazwa;

        public Produkt(String nazwa) {
            this.nazwa = nazwa;
        }

        public void pokaz() {
            System.out.println(nazwa + " w walucie " + waluta);
        }
    }
}

Obiekt takiej klasy tworzymy bez wcześniejszego tworzenia obiektu Sklep:

Sklep.Produkt produkt = new Sklep.Produkt("Klawiatura");
produkt.pokaz();

To najważniejsza cecha tego rozwiązania. Klasa Produkt jest logicznie związana ze sklepem, ale nie przechowuje ukrytej referencji do konkretnego obiektu sklepu. Dzięki temu nie trzeba pisać konstrukcji w rodzaju sklep.new Produkt(), która jest wymagana przy zwykłej klasie wewnętrznej.

Jak utworzyć i używać klasy statycznej

Składnia jest prosta. Wewnątrz klasy zewnętrznej deklarujemy klasę z modyfikatorem static, a poza nią odwołujemy się do typu przez nazwę obu klas. W praktyce dobrze jest nadać klasie zagnieżdżonej odpowiedni poziom dostępu, najczęściej private albo public, zależnie od tego, czy ma być częścią publicznego API.

public class Konfiguracja {
    private static final int DOMYSLNY_PORT = 8080;

    public static class Serwer {
        private final String host;
        private final int port;

        public Serwer(String host, int port) {
            this.host = host;
            this.port = port;
        }

        public void uruchom() {
            System.out.println("Serwer działa na " + host + ":" + port);
        }
    }
}

public class Aplikacja {
    public static void main(String[] args) {
        Konfiguracja.Serwer serwer =
                new Konfiguracja.Serwer("localhost", 8080);

        serwer.uruchom();
    }
}

Statyczna klasa może mieć własne pola, konstruktory, metody, klasy zagnieżdżone i implementować interfejsy. Może też korzystać ze statycznych elementów klasy zewnętrznej, nawet gdy są oznaczone jako private. Nie ma jednak bezpośredniego dostępu do pól instancji, ponieważ nie istnieje konkretny obiekt klasy zewnętrznej, do którego mogłaby się odwołać.

public class Uzytkownik {
    private String login;
    private static String system = "Panel klienta";

    public static class Informacje {
        public void pokazSystem() {
            System.out.println(system); // poprawne
        }

        // login byłby tutaj niedostępny bez obiektu Uzytkownik
    }
}

Jeżeli klasa zagnieżdżona musi pracować z danymi konkretnego użytkownika, można przekazać obiekt w konstruktorze lub metodzie. To zwykle czytelniejsze niż rezygnowanie ze statyczności tylko po to, aby uzyskać dostęp do jednego pola.

Klasa statyczna a zwykła klasa wewnętrzna

Oba typy są klasami zagnieżdżonymi, ale różnią się sposobem powiązania z klasą zewnętrzną. Statyczna klasa zagnieżdżona nie potrzebuje instancji klasy otaczającej, natomiast zwykła klasa wewnętrzna jest z nią związana przez konkretny obiekt.

Przykład klasy wewnętrznej wygląda tak:

public class Koszyk {
    private int liczbaProduktow;

    public Koszyk(int liczbaProduktow) {
        this.liczbaProduktow = liczbaProduktow;
    }

    public class Podsumowanie {
        public void pokaz() {
            System.out.println("Produktów: " + liczbaProduktow);
        }
    }
}

Koszyk koszyk = new Koszyk(3);
Koszyk.Podsumowanie podsumowanie = koszyk.new Podsumowanie();
podsumowanie.pokaz();

W tym przypadku Podsumowanie korzysta z danych konkretnego koszyka. Gdyby było statyczne, nie wiedziałoby, z którym obiektem ma pracować. Z mojego doświadczenia wynika, że właśnie tutaj początkujący popełniają najwięcej błędów: widzą klasę wewnątrz klasy i zakładają, że oba warianty działają identycznie.

Gdzie statyczna klasa zagnieżdżona ma praktyczny sens

Najlepiej używać jej wtedy, gdy typ ma sens wyłącznie w określonym obszarze kodu, ale nie potrzebuje stanu konkretnej instancji klasy zewnętrznej. Takie umiejscowienie ogranicza chaos w projekcie i pokazuje innym programistom, z czym dana klasa jest związana.

Klasy pomocnicze ukryte przed resztą aplikacji

Jeżeli metoda publiczna wymaga małego typu pomocniczego, można umieścić go jako private static class. Dzięki temu typ nie zaśmieca pakietu i pozostaje szczegółem implementacyjnym.

public class Raport {
    public void generuj() {
        Wiersz wiersz = new Wiersz("Sprzedaż", 1250);
        System.out.println(wiersz.nazwa + ": " + wiersz.wartosc);
    }

    private static class Wiersz {
        private final String nazwa;
        private final int wartosc;

        Wiersz(String nazwa, int wartosc) {
            this.nazwa = nazwa;
            this.wartosc = wartosc;
        }
    }
}

To dobre rozwiązanie dla prostych struktur danych używanych tylko w jednej klasie. Jeśli jednak typ zaczyna być wykorzystywany w kilku miejscach, lepiej przenieść go do osobnego pliku. Zagnieżdżenie powinno porządkować kod, a nie ukrywać ważny model domenowy.

Wzorzec Builder

Klasa Builder często jest statyczna, ponieważ służy do konfigurowania obiektu, ale nie potrzebuje osobnego obiektu klasy zewnętrznej. To jeden z najbardziej rozpoznawalnych przykładów użycia.

public class Polaczenie {
    private final String host;
    private final int port;

    private Polaczenie(Builder builder) {
        this.host = builder.host;
        this.port = builder.port;
    }

    public static class Builder {
        private String host = "localhost";
        private int port = 8080;

        public Builder host(String host) {
            this.host = host;
            return this;
        }

        public Builder port(int port) {
            this.port = port;
            return this;
        }

        public Polaczenie build() {
            return new Polaczenie(this);
        }
    }
}

Polaczenie polaczenie = new Polaczenie.Builder()
        .host("serwer.local")
        .port(9090)
        .build();

Builder oddziela etap budowania konfiguracji od gotowego obiektu. W dużych klasach poprawia czytelność konstruktorów, chociaż przy dwóch prostych parametrach może być przesadą. Sam stosuję go głównie wtedy, gdy obiekt ma wiele opcjonalnych ustawień albo walidację wykonywaną dopiero w metodzie build().

Węzły struktur danych

Drzewo, lista lub graf często potrzebują wewnętrznego typu Node. Jeśli węzeł nie musi znać konkretnej instancji struktury, statyczne zagnieżdżenie jest rozsądne i ogranicza niepotrzebne powiązania.

public class Drzewo {
    private static class Node {
        int wartosc;
        Node lewy;
        Node prawy;

        Node(int wartosc) {
            this.wartosc = wartosc;
        }
    }

    private Node korzen;
}

W tym przykładzie Node jest szczegółem implementacyjnym drzewa. Użytkownik klasy nie musi wiedzieć, jak przechowywane są elementy, a brak referencji do obiektu Drzewo upraszcza strukturę i może ograniczyć narzut pamięci.

Najczęstsze błędy i ograniczenia

Próba oznaczenia klasy najwyższego poziomu jako static

Taki zapis jest niepoprawny:

static class Narzedzia {
}

Klasa najwyższego poziomu nie może być oznaczona jako static. Modyfikator ma sens dla typu zagnieżdżonego, który jest członkiem innej klasy. Jeżeli potrzebujesz zwykłej klasy narzędziowej, utwórz ją bez static, a jej metody oznacz osobno jako statyczne.

Odwołanie do pola instancji

Ten kod nie zadziała, bo nazwa należy do obiektu Sklep, a nie do samej klasy:

public class Sklep {
    private String nazwa;

    public static class Raport {
        public void pokaz() {
            System.out.println(nazwa); // błąd kompilacji
        }
    }
}

Rozwiązaniem jest przekazanie instancji do konstruktora, przekazanie samej wartości albo usunięcie statyczności, jeśli zależność od obiektu jest rzeczywiście potrzebna. Nie warto obchodzić problemu przez sztuczne pola globalne, bo szybko prowadzi to do trudnego w testowaniu kodu.

Pomylenie klasy statycznej z klasą zawierającą metody static

Klasa statyczna to nie to samo co klasa, której metody są statyczne. W pierwszym przypadku mówimy o zagnieżdżonym typie, a w drugim o sposobie wywoływania konkretnych metod.

public class Matematyka {
    public static int dodaj(int a, int b) {
        return a + b;
    }
}

Matematyka jest zwykłą klasą najwyższego poziomu. Statyczna jest tylko metoda dodaj. To rozróżnienie ma znaczenie przy projektowaniu API i podczas czytania komunikatów kompilatora.

Przeczytaj również: Java Iterable - Jak działa? Różnice, przykłady i błędy

Nadmierne zagnieżdżanie

Klasa zagnieżdżona nie zawsze poprawia architekturę. Jeżeli ma własną odpowiedzialność, wiele metod, osobne testy i jest używana w kilku modułach, zwykle zasługuje na osobny plik. Zagnieżdżenie zostawiam dla typów małych, lokalnych i mocno związanych z klasą nadrzędną.

Od Java 16 ograniczenia dotyczące deklarowania elementów statycznych w klasach wewnętrznych zostały złagodzone. Nie zmienia to jednak podstawowej zasady: możliwość zadeklarowania statycznej metody w klasie wewnętrznej nie sprawia, że sama klasa staje się statyczną klasą zagnieżdżoną.

Prosta reguła, która pomaga podjąć decyzję

Jeżeli zagnieżdżona klasa potrzebuje danych konkretnego obiektu klasy zewnętrznej, wybierz klasę wewnętrzną. Jeżeli jest tylko logicznie związanym typem pomocniczym i może działać niezależnie, wybierz static nested class.

W praktyce najpierw sprawdzam zależność od stanu. Brak ukrytej referencji, prostsze tworzenie obiektów i lepsze zamknięcie szczegółów implementacyjnych przemawiają za klasą statyczną, ale tylko wtedy, gdy jej zagnieżdżenie rzeczywiście pomaga czytelności kodu.