Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Classi e interfacce annidate in Java

Distingui le classi annidate statiche dalle classi interne, esponi i passaggi di un builder tramite interfacce pubbliche e parametrizza una cache LRU annidata.

Versione: Java SE 21

Sintassi

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

Una classe annidata statica non ha un’istanza implicita della classe che la racchiude. Dall’esterno la si indica con Outer.Nested e, se il costruttore è accessibile, la si istanzia con new Outer.Nested(). Per accedere ai membri di istanza di un altro oggetto della classe esterna occorre un riferimento esplicito a quell’oggetto. Se la classe annidata estende la classe esterna, i suoi metodi di istanza possono accedere ai membri di istanza ereditati tramite il proprio this implicito. Una classe membro non statica (classe interna), invece, ha un’istanza della classe esterna e si può creare con outer.new Inner().

In static final class, static indica che non esiste un’istanza esterna associata, mentre final impedisce di creare sottoclassi. Nessuno dei due modificatori rende immutabili gli oggetti. In private static final class Builder, private nasconde inoltre il tipo di implementazione al codice client esterno alla classe che lo racchiude.

Le interfacce annidate sono implicitamente static, ma un’interfaccia membro dichiarata in una classe non è automaticamente public. Nell’esempio, le interfacce pubbliche Main.TitleStep e Main.BuildStep definiscono le operazioni disponibili. Il tipo restituito da builder() non espone build(); quello restituito da title(...) sì.

static class LRUCache<K,V> dichiara i propri parametri di tipo: K per le chiavi e V per i valori. Non può usare i parametri di tipo della classe che la racchiude. L’esempio usa una LinkedHashMap ordinata per accesso: quando la dimensione supera il limite, pollFirstEntry() rimuove la voce a cui si è acceduto meno di recente. Il metodo fa parte dell’API di Java SE 21; la cache dell’esempio non è thread-safe.

Esempi

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

Risultato

Report
1
null

Il programma non crea alcun oggetto `Main`. La lettura di `a` restituisce `1` e aggiorna l’ordine di accesso, quindi l’inserimento di `c` rimuove `b`. La successiva lettura di `b` restituisce `null`.

Lezioni correlate

  • Java · Lezione 37 · Intermedio · Versione: 2
  • Java · Lezione 38 · Intermedio · Versione: 2
  • Java · Lezione 40 · Intermedio · Versione: 2

Fonti