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

CKTIS / Java

Vnořené třídy a rozhraní v Javě

Rozlište statické vnořené třídy od vnitřních tříd, zpřístupněte kroky builderu pomocí veřejných rozhraní a parametrizujte vnořenou mezipaměť LRU.

Verze: Java SE 21

Syntaxe

class Outer {
    public interface Step { Result build(); }
    private static final class Builder implements Step {
        public Result build() { return new Result(); }
    }
    public static final class Result {}
    static class LRUCache<K,V> {}
    class Inner {}
}
// Where accessible: new Outer.Result() vs. outer.new Inner()

Statická vnořená třída nemá implicitní obklopující instanci. Zvenčí se na ni odkazuje jako na Outer.Nested; pokud je konstruktor přístupný, lze objekt vytvořit pomocí new Outer.Nested(). Pro přístup k instančním členům jiného objektu obklopující třídy je třeba výslovná reference na tento objekt. Pokud vnořená třída dědí od obklopující třídy, její instanční metody mohou přistupovat ke zděděným instančním členům přes vlastní implicitní this. Nestatická členská třída (vnitřní třída) naopak má obklopující instanci a lze ji vytvořit zápisem outer.new Inner().

V zápisu static final class znamená static, že třída nemá obklopující instanci, a final zakazuje odvozování podtříd. Ani jeden modifikátor nezajišťuje neměnnost objektů. V deklaraci private static final class Builder navíc private skrývá implementační typ před klientským kódem mimo obklopující třídu.

Vnořená rozhraní jsou implicitně static, členské rozhraní deklarované ve třídě však není automaticky public. V příkladu určují veřejná rozhraní Main.TitleStep a Main.BuildStep dostupné operace. Návratový typ builder() nezpřístupňuje build(); typ vrácený metodou title(...) už ano.

static class LRUCache<K,V> deklaruje vlastní typové parametry: K pro klíče a V pro hodnoty. Nemůže použít typové parametry obklopující třídy. Příklad používá LinkedHashMap seřazenou podle přístupu. Po překročení limitu odstraní pollFirstEntry() položku, ke které se nejdéle nepřistupovalo. Tato metoda je součástí API Java SE 21; ukázková mezipaměť není bezpečná pro souběžný přístup z více vláken.

Příklady

import java.util.LinkedHashMap;

public class Main {
    public interface TitleStep {
        BuildStep title(String title);
    }

    public interface BuildStep {
        Report build();
    }

    public static TitleStep builder() {
        return new Builder();
    }

    private static final class Builder implements TitleStep, BuildStep {
        private String title;

        @Override
        public BuildStep title(String title) {
            this.title = title;
            return this;
        }

        @Override
        public Report build() {
            return new Report(title);
        }
    }

    public static final class Report {
        private final String title;

        private Report(String title) {
            this.title = title;
        }

        public String title() {
            return title;
        }
    }

    static class LRUCache<K,V> {
        private final int limit;
        private final LinkedHashMap<K,V> entries = new LinkedHashMap<>(16, 0.75f, true);

        LRUCache(int limit) {
            if (limit < 1) {
                throw new IllegalArgumentException("limit must be positive");
            }
            this.limit = limit;
        }

        V get(K key) {
            return entries.get(key);
        }

        void put(K key, V value) {
            entries.put(key, value);
            if (entries.size() > limit) {
                entries.pollFirstEntry();
            }
        }
    }

    public static void main(String[] args) {
        Report report = Main.builder().title("Report").build();
        System.out.println(report.title());

        Main.LRUCache<String, Integer> cache = new Main.LRUCache<>(2);
        cache.put("a", 1);
        cache.put("b", 2);
        System.out.println(cache.get("a"));
        cache.put("c", 3);
        System.out.println(cache.get("b"));
    }
}

Výsledek

Report
1
null

Program nevytváří objekt `Main`. Čtení `a` vrátí `1` a aktualizuje pořadí podle přístupu, takže vložení `c` odstraní `b`. Pozdější čtení `b` vrátí `null`.

Související lekce

  • Java · Lekce 37 · Středně pokročilá · Verze: 2
  • Java · Lekce 38 · Středně pokročilá · Verze: 2
  • Java · Lekce 40 · Středně pokročilá · Verze: 2

Zdroje