Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Classi interne e sintassi `outer.new Inner(...)`

Una classe membro interna è legata a una specifica istanza della classe esterna e può leggere i campi privati di quell'oggetto.

Versione: Java SE 21

Sintassi

class Outer {
    class Inner {
        Inner(int value) { /* initialize this Inner object */ }
    }

    Inner create(int value) {
        return new Inner(value); // enclosing instance: this Outer
    }
}

// In a method or initializer where the type and constructor are accessible:
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(42);

In Java una classe interna è una classe annidata che non è static né esplicitamente né implicitamente. Rientrano in questa categoria anche le classi locali non statiche e le classi anonime. Se una classe locale o anonima di questo tipo è dichiarata in un contesto statico, i suoi oggetti non hanno un'istanza esterna immediata. Un oggetto di una classe membro interna come Team.Member, invece, viene associato a uno specifico oggetto esterno al momento della creazione.

In outer.new Inner(...), outer fornisce l'oggetto esterno e gli argomenti tra parentesi sono passati al costruttore di Inner. Outer.Inner indica il tipo, non l'oggetto esterno. In un metodo di istanza di Outer, new Inner(...) può usare this come oggetto esterno implicito. In un contesto statico, omettere il qualificatore causa un errore di compilazione; se il qualificatore vale null, si verifica una NullPointerException in fase di esecuzione. Il tipo e il costruttore devono comunque essere accessibili.

In un metodo di istanza di Member, this indica l'oggetto Member, mentre Team.this indica il suo oggetto Team esterno. Team.this.name legge il campo privato del team anche se Member ha un proprio campo name. Una classe annidata statica non ha un oggetto esterno implicito: per leggerne i campi di istanza serve un riferimento esplicito. In Java SE 21 una classe interna può dichiarare membri static e inizializzatori statici senza diventare una classe annidata statica.

TaskList istanzia la classe privata final chiamata FilteringIterator e restituisce l'oggetto come Iterator<Integer>. Ogni iteratore ha il proprio indice e legge source della lista esterna. Salta i valori non positivi e, quando non ci sono più elementi, next() lancia NoSuchElementException. Conservare l'iteratore può mantenere in vita l'oggetto TaskList a cui è legato.

Esempi

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Main {
    public static void main(String[] args) {
        Team red = new Team("Red");
        Team blue = new Team("Blue");
        Team.Member first = red.new Member("Ada");
        Team.Member second = blue.new Member("Ada");
        System.out.println(first.label());
        System.out.println(second.label());

        TaskList tasks = new TaskList(0, 4, -1, 7);
        Iterator<Integer> positives = tasks.positiveIterator();
        while (positives.hasNext()) {
            System.out.println(positives.next());
        }
    }
}

final class Team {
    private final String name;

    Team(String name) {
        this.name = name;
    }

    class Member {
        private final String name;

        Member(String name) {
            this.name = name;
        }

        String label() {
            return Team.this.name + ": " + this.name;
        }
    }
}

final class TaskList {
    private final int[] source;

    TaskList(int... values) {
        source = values.clone();
    }

    Iterator<Integer> positiveIterator() {
        return new FilteringIterator();
    }

    private final class FilteringIterator implements Iterator<Integer> {
        private int index;

        @Override
        public boolean hasNext() {
            while (index < source.length && source[index] <= 0) {
                index++;
            }
            return index < source.length;
        }

        @Override
        public Integer next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return source[index++];
        }
    }
}

Risultato

Red: Ada
Blue: Ada
4
7

I due oggetti `Member` hanno lo stesso nome, ma stampano nomi di team diversi. L'iteratore stampa poi solo `4` e `7`, nell'ordine in cui compaiono in `source`.

Lezioni correlate

  • Java · Lezione 7 · Intermedio · Versione: 2
  • Java · Lezione 24 · Intermedio · Versione: 2

Fonti