Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Anonymní třídy v Javě

Anonymní třída umožňuje v jediném výrazu definovat implementaci rozhraní nebo podtřídu a zároveň vytvořit její instanci.

Verze: Java SE 21

Syntaxe

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.

V Javě SE 21 výraz new Interface() { ... } deklaruje anonymní třídu a vytváří její instanci. Interface zastupuje název existujícího rozhraní a ... deklarace v těle třídy. Objekt je instancí třídy implementující rozhraní, ne instancí samotného rozhraní. Každé vyhodnocení vytvoří nový objekt; každý samostatný výskyt tohoto tvaru deklaruje jinou třídu.

Tvar new BaseType(args) { ... } vytváří instanci podtřídy, pokud lze z BaseType dědit a zavolat vhodný konstruktor. Argumenty se předají konstruktoru nadtřídy. Konstruktor anonymní třídy nelze deklarovat explicitně, ale tělo třídy může obsahovat pole, metody a inicializační bloky instance.

Třída musí implementovat všechny požadované abstraktní metody. Implementace metod Action.perform(), Runnable.run() a Executor.execute(Runnable) musí být public. Pomocí @Override může překladač odhalit chybu v signatuře, například neúmyslné přetížení metody místo jejího překrytí.

V instanční metodě anonymní třídy označuje this anonymní objekt. Lambda nezavádí vlastní this a jako cílový typ vyžaduje funkční rozhraní. Obě formy mohou zachytit pouze lokální proměnné, které jsou final nebo efektivně finální, jako label, které se už nepřiřazuje nová hodnota.

new Executor() { public void execute(Runnable r) ... } je náčrt anonymní implementace Executor, ne způsob vytvoření fondu vláken. Metoda execute tu přímo volá r.run(), takže se úloha provede synchronně ve volajícím vlákně. Jiné implementace Executor mohou použít jiné vlákno nebo fond vláken.

Příklady

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();
    }
}

Výsledek

Open
Task 1
Task 2
Task 3
Task 4
Close

Dvě různé anonymní třídy implementují `Action` a další čtyři implementují `Runnable`. `Open` se vypíše před řádky `Task 1` až `Task 4` a `Close` po všech čtyřech úlohách, protože každé volání `execute` počká na dokončení přímého volání `run()`.

Související lekce

  • Java · Lekce 25 · Pokročilá · Verze: 2
  • Java · Lekce 8 · Středně pokročilá · Verze: 2
  • Java · Lekce 51 · Středně pokročilá · Verze: 2

Zdroje