Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Classes internes et syntaxe `outer.new Inner(...)`

Une classe membre interne est liée à une instance précise de la classe englobante et peut lire les champs privés de cet objet.

Version : Java SE 21

Syntaxe

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

En Java, une classe interne est une classe imbriquée qui n'est ni explicitement ni implicitement static. Les classes locales non statiques et les classes anonymes en font aussi partie. Si une telle classe locale ou anonyme est déclarée dans un contexte statique, ses objets n'ont pas d'instance englobante immédiate. En revanche, un objet d'une classe membre interne comme Team.Member est lié à un objet englobant précis dès sa création.

Dans outer.new Inner(...), outer fournit l'objet englobant et les arguments entre parenthèses sont transmis au constructeur de Inner. Outer.Inner désigne le type, pas l'objet englobant. Dans une méthode d'instance de Outer, new Inner(...) peut utiliser this comme objet englobant implicite. En contexte statique, omettre le qualificateur provoque une erreur de compilation ; si le qualificateur vaut null, une NullPointerException est levée à l'exécution. Le type et le constructeur doivent rester accessibles.

Dans une méthode d'instance de Member, this désigne l'objet Member, tandis que Team.this désigne l'objet Team qui l'englobe. Team.this.name lit le champ privé de l'équipe, même si Member possède son propre champ name. Une classe imbriquée statique n'a pas d'objet englobant implicite : elle a besoin d'une référence explicite pour lire les champs d'instance de cet objet. En Java SE 21, une classe interne peut déclarer des membres static et des initialiseurs statiques sans devenir statique.

TaskList instancie la classe privée final nommée FilteringIterator et renvoie l'objet sous le type Iterator<Integer>. Chaque itérateur a son propre indice et lit le champ source de la liste englobante. Il ignore les valeurs non positives ; une fois l'itérateur épuisé, next() lève une NoSuchElementException. Conserver l'itérateur peut prolonger la durée de vie de l'objet TaskList qui l'englobe.

Exemples

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++];
        }
    }
}

Résultat

Red: Ada
Blue: Ada
4
7

Les deux objets `Member` portent le même nom, mais affichent des noms d'équipe différents. L'itérateur affiche ensuite uniquement `4` et `7`, dans leur ordre dans `source`.

Leçons associées

  • Java · Leçon 7 · Intermédiaire · Version : 2
  • Java · Leçon 24 · Intermédiaire · Version : 2

Sources