Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

Anonymné triedy v Jave

Anonymná trieda umožňuje v jednom výraze definovať implementáciu rozhrania alebo podtriedu a zároveň vytvoriť jej inštanciu.

Verzia: Java SE 21

Syntax

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 Jave SE 21 výraz new Interface() { ... } deklaruje anonymnú triedu a vytvára jej inštanciu. Interface zastupuje názov existujúceho rozhrania a ... deklarácie v tele triedy. Objekt je inštanciou triedy implementujúcej rozhranie, nie samotného rozhrania. Každé vyhodnotenie vytvorí nový objekt; každý samostatný výskyt tohto tvaru deklaruje inú triedu.

Tvar new BaseType(args) { ... } vytvára inštanciu podtriedy, ak možno z BaseType dediť a zavolať vhodný konštruktor. Argumenty sa odovzdajú konštruktoru nadtriedy. Konštruktor anonymnej triedy nemožno explicitne deklarovať, no telo triedy môže obsahovať polia, metódy a inicializačné bloky inštancie.

Trieda musí implementovať všetky požadované abstraktné metódy. Implementácie metód Action.perform(), Runnable.run() a Executor.execute(Runnable) musia byť public. Pomocou @Override môže kompilátor odhaliť chybu v signatúre, napríklad nechcené preťaženie metódy namiesto jej prekrytia.

V inštančnej metóde anonymnej triedy označuje this anonymný objekt. Lambda nezavádza vlastné this a ako cieľový typ vyžaduje funkčné rozhranie. Obe formy môžu zachytiť iba lokálne premenné, ktoré sú final alebo efektívne finálne, ako label, ktorej sa už nepriradí nová hodnota.

new Executor() { public void execute(Runnable r) ... } je náčrt anonymnej implementácie Executor, nie spôsob vytvorenia fondu vlákien. Metóda execute tu priamo volá r.run(), takže úloha prebehne synchrónne vo volajúcom vlákne. Iné implementácie Executor môžu použiť iné vlákno alebo fond vlákien.

Prí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ýsledok

Open
Task 1
Task 2
Task 3
Task 4
Close

Dve rôzne anonymné triedy implementujú `Action` a ďalšie štyri implementujú `Runnable`. `Open` sa vypíše pred riadkami `Task 1` až `Task 4` a `Close` po všetkých štyroch úlohách, pretože každé volanie `execute` počká na dokončenie priameho volania `run()`.

Súvisiace lekcie

  • Java · Lekcia 25 · Pokročilá · Verzia: 2
  • Java · Lekcia 8 · Stredne pokročilá · Verzia: 2
  • Java · Lekcia 51 · Stredne pokročilá · Verzia: 2

Zdroje