KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Geneste klassen en interfaces in Java

Leer het verschil tussen statische geneste klassen en innerlijke klassen. Gebruik publieke interfaces voor de stappen van een builder en typeparameters voor een geneste LRU-cache.

Versie: Java SE 21

Syntax

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

Een statische geneste klasse heeft geen impliciete omsluitende instantie. Van buitenaf verwijs je ernaar als Outer.Nested. Als de constructor toegankelijk is, maak je een object met new Outer.Nested(). Voor toegang tot instantieleden van een afzonderlijk object van de omsluitende klasse heb je een expliciete verwijzing naar dat object nodig. Erft de geneste klasse van de omsluitende klasse, dan kunnen haar instantiemethoden via hun eigen impliciete this bij geërfde instantieleden. Een niet-statische lidklasse (innerlijke klasse) heeft wel een omsluitende instantie en kun je maken met outer.new Inner().

In static final class betekent static dat er geen omsluitende instantie is, terwijl final het afleiden van subklassen verhindert. Geen van beide modifiers maakt objecten onveranderlijk. In private static final class Builder verbergt private bovendien het implementatietype voor aanroepende code buiten de omsluitende klasse.

Geneste interfaces zijn impliciet static, maar een interface die als lid in een klasse is gedeclareerd is niet automatisch public. In het voorbeeld bepalen de publieke interfaces Main.TitleStep en Main.BuildStep welke bewerkingen beschikbaar zijn. Het retourtype van builder() biedt build() niet aan; het retourtype van title(...) wel.

static class LRUCache<K,V> declareert eigen typeparameters: K voor sleutels en V voor waarden. De klasse kan de typeparameters van de omsluitende klasse niet gebruiken. Het voorbeeld gebruikt een LinkedHashMap op volgorde van toegang. Als de grootte de limiet overschrijdt, verwijdert pollFirstEntry() het item dat het langst niet is benaderd. Die methode komt uit de Java SE 21-API; de voorbeeldcache is niet thread-safe.

Voorbeelden

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

Resultaat

Report
1
null

Het programma maakt geen `Main`-object. Het lezen van `a` geeft `1` terug en wijzigt de volgorde van toegang. Daardoor wordt `b` verwijderd als `c` wordt toegevoegd. De volgende leesbewerking voor `b` geeft `null` terug.

Gerelateerde lessen

  • Java · Les 37 · Gemiddeld · Versie: 2
  • Java · Les 38 · Gemiddeld · Versie: 2
  • Java · Les 40 · Gemiddeld · Versie: 2

Bronnen