Classe (informatique)

À partir de l’édition de 2015 (ECMAScript 6), une syntaxe de définition de classes a été ajoutée, simplifiant l’utilisation de son mécanisme d’héritage prototypal pour le développement orienté objet[1] :

class Point {
    
    constructor(x, y) {
        this._x = x;
        this._y = y;
    }
    
    getX() {
        return this._x;
    }
    
    getY() {
        return this._y;
    }
    
    isOrigin() { 
        return this._x === 0 && this._y === 0; 
    }
    
    translate(pt) {
        return new Point(this._x + pt._x, this._y + pt._y);
    }
    
}

Une classe est dite immuable s'il n'est pas possible de modifier un objet de cette classe après sa création. Par exemple, la classe Point, décrite ci-dessus dans différents langages, est immuable car elle n'expose aucune méthode permettant de modifier la valeur de ses variables membres. La méthode translate retourne un nouvel objet au lieu de modifier l'objet lui-même. La classe java.lang.String de l'environnement Java est un autre exemple de classe immuable, tout comme la classe System.String du Framework Microsoft .NET.

Dans certains langages, une classe peut être partiellement définie. En particulier, certaines méthodes de cette classe n'ont pas de corps ou d'implémentation. Ces méthodes sont dites « abstraites » (ou virtuelles en C++).

Les classes possédant au moins une méthode abstraite sont aussi dites classes abstraites (ou virtuelles) et ne peuvent pas être instanciées directement — sauf en créant une sous-classe non abstraite.

Exemple

On souhaite modéliser les relations objets d'un dessin vectoriel. On peut dire qu'un objet dessin est un ensemble de géométries (la classe abstraite) et chaque géométrie peut être un point, un polygone ou une ligne brisée (ces trois classes héritent de géométrie). La classe abstraite n'est donc pas indispensable en soi, mais elle est indispensable[2] pour un modèle propre, générique et simplifié.

Le mixin est un cas particulier de classe abstraite. Il permet d'ajouter un service aux sous-classes.

Une classe ne possédant que des méthodes abstraites est appelée interface ou classe purement virtuelle (en C++) ou protocole (en Objective C).

La classe d'une classe est une métaclasse. Les métaclasses permettent de réaliser de la réflexion structurelle.

Une classe, comme définie précédemment, est un ensemble de membres (méthodes et attributs) qu'on est forcément amené à manipuler. Si p est une instance de Point(a,b) où a et b sont de type int, on accède aux membres de p comme ceci :

• p.x = a et p.y = b (accès aux attributs)
• p.getX() et p.getY() (accès aux méthodes)

La question qui vient tout de suite à l'esprit est la suivante : pourquoi définir une méthode getX(), alors qu'on peut accéder directement aux champs x et y de la classe Point ?

En fait, lorsqu'on est amené à manipuler de nombreuses classes ainsi que de nombreuses relations entre ces classes (cf. héritage), le schéma, les données et les opérations peuvent devenir très complexes (surtout pour un individu n'ayant pas conçu le code). On a donc recours à un mécanisme qu'on appelle encapsulation des données, lequel se charge de masquer à certaines parties du programme les champs de la classe dans un souci d'intégrité. L'utilisateur est donc amené à ne manipuler que des méthodes qui ont été approuvées et qui en théorie remplissent bien leur rôle.

Selon le principe d'encapsulation, les méthodes ont un accès public - cela signifie que tout élément d'un programme peut utiliser une méthode. Quant aux attributs composant l'état, ils ont un accès privé (private) - seul l'objet lui-même (et donc les méthodes qu'il contient) a un accès direct à ses attributs. Dans ce cas, le seul moyen d'accéder à ces attributs est d'utiliser les méthodes de l'objet. Les attributs ne peuvent pas être utilisés directement par un autre élément du programme ni même un autre objet, même si cet objet est de la même classe. Autre point : tous les attributs d'un objet qui sont hérités sont directement accessibles par les autres membres de cet objet.

En ce qui concerne les dernières remarques, il y a souvent confusion sur la sémantique de l'accès privé. Le principe d'encapsulation implique une protection des attributs que nous appellerons verticale (seuls l'objet lui-même et les objets d'une sous-classe y ont accès). Nous retrouvons cette sémantique dans des langages comme Smalltalk, Oz ou OCaml. Cependant certains langages, comme C++, Pascal ou Java, plaident pour une protection des attributs que nous appellerons horizontale (les objets d'une même classe y ont accès, mais pas les objets des sous-classes).

Certains langages permettent, lors de la déclaration de la classe, de modifier la portée de ses membres et, par conséquent, des membres des objets instanciés à partir de cette classe; la modification de la portée réduit la visibilité et, par conséquent, l'accessibilité aux membres.

Par exemple, les langages C++ et Pascal Objet proposent les modifications de portée suivantes :

public

protected

private

La sémantique de ces modifications de portée et leur nombre varient selon le langage de programmation.

Par exemple, Java propose une définition un peu différente pour les membres protégés; elle s'étend à l'ensemble des objets de la même classe, des classes filles et des classes du même paquetage.

Par exemple, Python propose la possibilité de modifier la visibilité des membres d'une classe en préfixant le nom du membre par le caractère souligné ('_'):

• getX() est une méthode publique.
• _getX() est une méthode protégée, c'est-à-dire accessible seulement par les éléments du même module.
• __getX() est une méthode privée.