Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Klasy anonimowe w Javie

Klasa anonimowa pozwala w jednym wyrażeniu zdefiniować implementację interfejsu lub podklasę i od razu utworzyć jej obiekt.

Wersja: Java SE 21

Składnia

Anonymous implementation: new InterfaceType() { /* member declarations */ }
Anonymous subclass: new BaseType(constructorArguments) { /* member declarations */ }
In a variable declaration, end the declaration with a semicolon after the closing brace.

W Javie SE 21 wyrażenie new Interface() { ... } deklaruje klasę anonimową i tworzy jej obiekt. Interface oznacza nazwę istniejącego interfejsu, a ... zastępuje deklaracje w ciele klasy. Tworzony jest obiekt klasy implementującej interfejs, nie samego interfejsu. Każde obliczenie wyrażenia tworzy nowy obiekt, a każde osobne wystąpienie takiego wyrażenia deklaruje odrębną klasę.

W postaci new BaseType(args) { ... } powstaje podklasa, o ile można rozszerzyć BaseType i wywołać odpowiedni konstruktor. Argumenty trafiają do konstruktora nadklasy; własnego konstruktora klasy anonimowej nie można zadeklarować jawnie. Ciało może natomiast zawierać pola, metody i inicjalizatory instancji.

Klasa anonimowa musi zapewniać implementacje wszystkich wymaganych metod abstrakcyjnych. Implementacje Action.perform(), Runnable.run() i Executor.execute(Runnable) muszą być public. @Override pozwala kompilatorowi wykryć błąd w sygnaturze, na przykład przypadkowe przeciążenie zamiast przesłonięcia metody.

W metodzie instancji klasy anonimowej this oznacza jej obiekt. Lambda nie wprowadza własnego this i wymaga interfejsu funkcyjnego jako typu docelowego. Obie formy mogą odwoływać się do zmiennych lokalnych z otoczenia tylko wtedy, gdy są one final lub efektywnie finalne, jak label, któremu nie przypisuje się ponownie wartości.

new Executor() { public void execute(Runnable r) ... } to schemat anonimowej implementacji Executor, a nie składnia tworzenia puli wątków. Tutaj execute wywołuje bezpośrednio r.run(), więc zadanie wykonuje się synchronicznie w wątku wywołującym. Inne implementacje Executor mogą korzystać z innego wątku lub z puli.

Przykłady

import java.util.concurrent.Executor;

public class AnonymousClassDemo {
    interface Action {
        void perform();
    }

    public static void main(String[] args) {
        Action open = new Action() {
            @Override
            public void perform() { System.out.println("Open"); }
        };
        Action close = new Action() {
            @Override
            public void perform() { System.out.println("Close"); }
        };

        Executor direct = new Executor() {
            @Override
            public void execute(Runnable r) {
                r.run();
            }
        };

        String label = "Task ";
        Runnable[] tasks = {
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "1"); }
            },
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "2"); }
            },
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "3"); }
            },
            new Runnable() {
                @Override
                public void run() { System.out.println(label + "4"); }
            }
        };

        open.perform();
        for (Runnable task : tasks) {
            direct.execute(task);
        }
        close.perform();
    }
}

Wynik

Open
Task 1
Task 2
Task 3
Task 4
Close

Dwie osobne klasy anonimowe implementują `Action`, a cztery kolejne implementują `Runnable`. `Open` pojawia się przed `Task 1`–`Task 4`, a `Close` dopiero po wszystkich zadaniach, ponieważ każde `execute` czeka na zakończenie bezpośredniego wywołania `run()`.

Powiązane lekcje

  • Java · Lekcja 25 · Zaawansowany · Wersja: 2
  • Java · Lekcja 8 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 51 · Średniozaawansowany · Wersja: 2

Źródła