Objet immuable

Avant l'apparition de la programmation orientée objet, les variables d'exécution dont le contenu n'était pas destiné à changer en cours d'exécution (par exemple, le facteur de conversion permettant de transformer des livres en kilogrammes, ou encore la valeur de pi avec plusieurs décimales) étaient connues sous le nom de constantes, pour les différencier de celles qui pouvaient être modifiées.

Dans la plupart des langages orientés objet, les objets sont manipulés par des références. C'est le cas, par exemple, de Java, des objets de type class de C# et de Swift (contrairement aux objets de type struct), de Python, de JavaScript et de Ruby. Dans ce cas, le fait que l'état d'un objet partagé par référence puisse ou non être modifié est important.

Lorsqu'un objet est réputé immuable, on peut en obtenir une copie en dupliquant simplement sa référence, au lieu de copier l'objet entier. Comme une référence (qui n'occupe typiquement en mémoire que la taille d'un pointeur) est habituellement bien moins volumineuse que l'objet lui-même, cette technique permet à la fois d'économiser de la mémoire et d'améliorer la vitesse d'exécution.

La technique de copie des références est bien plus complexe à utiliser pour les objets variables, parce que si un élément quelconque utilisant la référence à un objet variable modifie ce dernier, la modification deviendra visible pour tous les autres éléments utilisateurs de la référence. Au cas où ce ne serait pas l'effet souhaité, il peut s'avérer difficile de faire répondre correctement les autres utilisateurs. Dans une telle situation, la copie préventive de l'objet dans son ensemble constitue une solution fréquemment utilisée, mais coûteuse. Le patron de conception observateur représente une solution alternative pour la gestion des modifications des objets variables.

Les objets immuables peuvent être utilisés dans des applications multi-threads. Plusieurs threads peuvent utiliser des données implémentées en tant qu'objets immuables, sans se préoccuper d'une éventuelle modification par un thread concurrent. C'est pourquoi les objets immuables sont considérés comme plus sûrs dans un contexte multi-threads que les objets variables.

La technique qui consiste à toujours utiliser des références au lieu de copies d'objets identiques immuables, en ne stockant qu'une seule fois en mémoire leur valeur, porte en anglais le nom d'« interning ». Dans ce cadre, deux objets sont considérés comme égaux si et seulement si leurs références, typiquement représentées par des entiers, sont égales. Certains langages gèrent cette technique automatiquement : par exemple, Python gère automatiquement de cette manière les chaînes courtes. Si l'algorithme qui implémente l'interning garantit de l'effectuer chaque fois que c'est possible, alors la comparaison d'égalité entre deux objets se réduit à la comparaison de leurs pointeurs, ce qui représente un gain en rapidité substantiel dans la plupart des applications. L'interning ne présente généralement d'intérêt que pour les objets immuables.

Il peut arriver que seuls certains champs d'un objet soient immuables : l'objet lui-même est immuable seulement si tous ses champs sont immuables. Ceci peut permettre par exemple de contraindre certaines données d'un objet à rester invariables tout au long de la vie de l'objet. Dans certains langages, ceci se réalise au moyen d'un mot-clé (comme const en C++, ou final en Java). Dans d'autres langages, c'est l'inverse : en OCaml, les champs d'un objet sont immuables par défaut, et doivent être marqués explicitement comme variables le cas échéant.

L'immuabilité n'implique pas que l'objet, tel qu'il est stocké en mémoire, ne puisse être réécrit. Il s'agit plutôt d'une directive de compilation indiquant ce qu'un programmeur a le droit de faire via l'interface normale de l'objet, et non ce qu'il est possible de faire dans l'absolu (par exemple en contournant le système de typage ou en violant les règles de gestion des const en C ou en C++).

class Position2D
{
    private readonly double _x;
    private readonly double _y;
    public double X { get { return _x; }}
    public double Y { get { return _y; }}
    public Position2D(double x, double y)
    {
        _x = x;
        _y = y;
    }
}

    String s = "ABC";
    s.toLowerCase();

    s = s.toLowerCase();

    class Panier {
       private final List articles;

       public Panier(List articles) { this.articles = articles; }

       public List getArticles() { return articles; }
       public int total() { /* retourne le prix total */ }
    }

    class PanierImmuable {
       private final List articles;

       public PanierImmuable(List articles) {
         this.articles = Collections.unmodifiableList(new ArrayList(articles));
       }

       public List getArticles() {
           return articles;
       }
       public int total() { /* retourne le prix total */ }
    }

:symbole

• Classe (informatique)
• Clojure
• Haskell
• Erlang
• Tcl

• Portail de l’informatique