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

CKTIS / Java

Modèle objet de Java

Modèle objet de Java: Le modèle objet Java combine héritage simple de classes, interfaces multiples et composition ; une classe imbriquée statique (static nested class) n’a pas d’instance englobante, une classe interne (inner class) en possède une.

Version : Java SE 21 (JLS and Java SE API); examples verified on the repository Java runtime

Syntaxe

object model

Le modèle objet Java combine héritage simple de classes, interfaces multiples et composition ; une classe imbriquée statique (static nested class) n’a pas d’instance englobante, une classe interne (inner class) en possède une.

Préfère la composition pour un comportement remplaçable, une interface pour le contrat et une hiérarchie sealed pour des variantes fermées ; les copies défensives protègent les frontières.

Une classe interne peut retenir l’objet externe ; les classes locales et anonymes ne capturent que les variables locales final ou effectively final. L’immuabilité superficielle partage des éléments, tandis que l’immuabilité profonde exige de copier ou figer tout le graphe mutable.

Crée une instance interne avec outer.new Inner() ; une classe anonyme n’a pas de constructeur nommé et equals correct exige hashCode cohérent pour maps et sets.

Les lignes static, outer, local et anonymous distinguent quatre formes de classe ; shallow=[A, B], deep=[A] et outer-sizes=1/1 démontrent la copie défensive et la différence superficielle-profonde.

Exemples

import java.util.ArrayList;
import java.util.List;

public class Main {
    private final String name;

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

    static final class Nested {
        String value() { return "static"; }
    }

    final class Inner {
        String owner() { return name; }
    }

    static final class Box {
        private final List<List<String>> shallow;
        private final List<List<String>> deep;

        Box(List<List<String>> source) {
            shallow = List.copyOf(source);
            deep = source.stream().map(List::copyOf).toList();
        }
    }

    public static void main(String[] args) {
        var outer = new Main("outer");
        var inner = outer.new Inner();
        class Local { String value() { return "local"; } }
        Runnable anonymous = new Runnable() {
            @Override public void run() { System.out.println("anonymous"); }
        };

        System.out.println(new Nested().value());
        System.out.println(inner.owner());
        System.out.println(new Local().value());
        anonymous.run();

        var mutable = new ArrayList<>(List.of("A"));
        var source = new ArrayList<List<String>>();
        source.add(mutable);
        var box = new Box(source);
        mutable.add("B");
        source.add(List.of("C"));
        System.out.println("shallow=" + box.shallow.get(0));
        System.out.println("deep=" + box.deep.get(0));
        System.out.println("outer-sizes=" + box.shallow.size() + "/" + box.deep.size());
    }
}

Résultat

static
outer
local
anonymous
shallow=[A, B]
deep=[A]
outer-sizes=1/1

Les lignes static, outer, local et anonymous distinguent quatre formes de classe ; shallow=[A, B], deep=[A] et outer-sizes=1/1 démontrent la copie défensive et la différence superficielle-profonde.

Sources