Classe (informatique)

Pour les articles homonymes, voir Classe.

En programmation orientée objet, la déclaration d'une classe regroupe des membres, méthodes et propriétés (attributs) communs à un ensemble d'objets.

La classe déclare, d'une part, des attributs représentant l'état des objets et, d'autre part, des méthodes représentant leur comportement.

Une classe représente donc une catégorie d'objets. Elle apparaît aussi comme un moule ou une usine à partir de laquelle il est possible de créer des objets ; c'est en quelque sorte une « boîte à outils » qui permet de fabriquer un objet. On parle alors d'un objet en tant qu'instance d'une classe (création d'un objet ayant les propriétés de la classe).

Il est possible de restreindre l'ensemble d'objets représenté par une classe A grâce à un mécanisme d'héritage. Dans ce cas, on crée une nouvelle classe B liée à la classe A et qui ajoute de nouvelles propriétés. Dans ce cas, différents termes sont utilisés :

## Exemple de classe dans différents langages

[modifier | modifier le code]

Dans les exemples ci-dessous on définit dans différents langages une classe `Point` avec deux attributs `x` et `y`. Cette classe contient :

* un constructeur,
* deux méthodes retournant la valeur des attributs (`getX()` et `getY()`),
* une méthode déterminant si le point représente l'origine (`isOrigin()`)
* une méthode effectuant une translation.

Le constructeur est une règle de procédures d’initialisation qui sera appelée lors de la création d'une nouvelle instance d'une classe. Il définit un premier état valide pour l'état interne de l’objet. Cette règle peut se traduire sommairement par la notion de « déclaration de structures, de variables ». Il peut y avoir plusieurs constructeurs déclarés. En l’absence de constructeur, le compilateur en génèrera un par défaut.

La méthode est une règle de procédures appliquée aux attributs de la classe. Cette règle peut se traduire sommairement par la notion de « fonction » ou « routine ». Il peut y avoir plusieurs méthodes dans une classe.  Les méthodes sont les éléments clés de la classe.

### C++

[modifier | modifier le code]

class Point

public:
Point(int x, int y) : m_x(x), m_y(y) {}
int getX() const { return m_x; }
int getY() const { return m_y; }
bool isOrigin() const { return m_x == 0 && m_y == 0; }

Point translate(const Point& point) const {
return Point(m_x + point.getX(), m_y + point.getY());

private:
int m_x;
int m_y;

### C#

[modifier | modifier le code]

class Point

public Point(int x, int y)

X = x;
Y = y;

public int Y { get; private set; }

public int X { get; private set; }

public bool IsOrigin()

return X == 0 && Y == 0;

public Point Translate(Point p)

return new Point(X + p.X, Y + p.Y);

### Java

[modifier | modifier le code]

public class Point {
private int x;
private int y;

public Point(int x, int y) {
this.x = x;
this.y = y;

public int getX() { return x; }
public int getY() { return y; }

public boolean isOrigin() {
return (x == 0) && (y == 0);

public Point translate(Point pt) {
return new Point(x + pt.getX(), y + pt.getY());

### Javascript

[modifier | modifier le code]

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

### Pascal Objet

[modifier | modifier le code]

unit Point;

interface

type
TPoint = class
protected
fX, fY: integer;
function GetY : integer;
public
property X : integer read fX;   //Avec accesseur implicite
property Y : integer read GetY; //Sans accesseur implicite
constructor Create(X, Y: integer); overload;
constructor Create; overload;
function IsOrigin: Boolean;
function Translate(Pt: TPoint): TPoint;
end;

implementation

function TPoint.GetY: integer;
begin
Result := fY;
end;

constructor TPoint.Create(X, Y: integer);
begin
fX := X;
fY := Y;
end;

constructor TPoint.Create;
begin
Create(0,0);
end;

function TPoint.IsOrigin: Boolean;
begin
Result := (fX = 0) and (fY = 0);
end;

function TPoint.Translate(Pt: TPoint): TPoint;
begin
Result := TPoint.Create(fX + Pt.X, fY + Pt.Y);
end;

end.

### PHP

[modifier | modifier le code]

class Point {
private $x;
private $y;

public function __construct($x, $y) {
$this->x = (int) $x;
$this->y = (int) $y;

public function getX() { return $this->x; }
public function getY() { return $this->y; }

public function isOrigin() { return ($this->x == 0) && ($this->y == 0); }

public function translate(Point $point) {
return new Point($this->x + $point->getX(), $this->y + $point->getY());

### Ruby

[modifier | modifier le code]

class Point
attr_reader :x, :y

def initialize(x, y)
@x = x.to_i
@y = y.to_i
end

def origin?
@x.zero? and @y.zero?
end

def translate p
Point.new(@x + p.x, @y + p.y)
end
end

### Python

[modifier | modifier le code]

class Point(object):
def __init__(self, x, y):
super(Point, self).__init__()
self._x = x
self._y = y

@property
def x(self):
return self._x

@property
def y(self):
return self._y

def is_origin(self):
return (self._x == 0) and (self._y == 0)

def __add__(self, point):
return Point(self._x + point.x, self._y + point.y)

### VB.Net

[modifier | modifier le code]

Public class Point
Protected intX As Integer, intY As Integer

Public Sub New(ByVal pX As Integer, ByVal pY As Integer)
Me.intX = pX
Me.intY = pY
End Sub

Public ReadOnly Property X() As Integer
Get
Return Me.intX
End Get
End Property

Public ReadOnly Property Y() As Integer
Get
Return Me.intY
End Get
End Property

Public Function IsOrigine() As Boolean
Return ((Me.intX = 0) And (Me.intY = 0))
End Function

Public Function Translate(ByVal pP As Point) As Point
Return New Point(Me.intX + pP.x, Me.intY + pP.y)
End Function

### Ada, depuis Ada95

[modifier | modifier le code]

package Point_Pack is
-- une classe en Ada est un type dit "étiqueté"
-- ici on décide en plus de cacher le contenu du type (partie privée)
type Point is tagged private;

-- les méthodes sont déclarées en dehors du type
function Get_X (P : Point) return Integer;
function Get_Y (P : Point) return Integer;
function Is_Origin (P : Point) return Boolean;
function Translate (P, Vector : Point) return Point;

-- pas de constructeur "intégré"
function New_Point (X, Y : Integer) return Point;

private
-- définitions inaccessibles à l'utilisateur du type
type Point is tagged record
X, Y : Integer;
end record;
end Point_Pack;

-- la suite contient l'implémentation de la classe: en Ada il est important de séparer
-- le code (le corps) et les déclarations "visibles" (la spécification) : en général dans 2 fichiers différents
package body Point_Pack is
-- les méthodes nomment explicitement l'objet en argument
function Get_X (P : Point) return Integer is
begin
return P.X;
end Get_X;

function Get_Y (P : Point) return Integer is
begin
return P.Y;
end Get_Y;

function Is_Origin (P : Point) return Boolean is
begin
return P.X = 0 and then P.Y = 0;
end Is_Origin;

function Translate (P, Vector : Point) return Point is
begin
return Point'( X => P.X + Vector.X, Y => P.Y + Vector.Y );
end Translate;

function New_Point (X, Y : Integer) return Point is
begin
return Point'(X => X, Y => Y);
end New_Point;

end Point_Pack;

### Swift 3 et 4

[modifier | modifier le code]

class Point {

private let x: Int
private let y: Int

// Pour instancier un nouveau Point, on fera :
// var point = Point(8, 42)
public init(_ x: Int,_ y: Int) {
self.x = x
self.y = y

// x fait automatiquement référence à self.x
// La visibilité public rend la méthode accessible même si la classe est importée dans un autre projet
public func getX() -> Int {
return x

// Pas de visibilité rend la méthode accessible uniquement dans le projet
func getY() -> Int {
return y

// Cette méthode ne peut être utilisé que par un élément déclaré dans le fichier
fileprivate func isOrigin() -> Bool {
return (x == 0) && (y == 0)

// Cette méthode n'est accessible que par une instance de la classe Point
// Pour utiliser cette méthode, on fera :
// translate(point: instanceDePoint)
private func translate(point: Point) -> Point {

return Point(x + getX(), y + getY());

## Cas particuliers de classe

[modifier | modifier le code]

### Classe immuable

[modifier | modifier le code]

Article détaillé : Objet immuable.

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.

### Classe abstraite

[modifier | modifier le code]

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.

### Interface

[modifier | modifier le code]

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

### Métaclasse

[modifier | modifier le code]

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

## Manipulation des données membres

[modifier | modifier le code]

### Accès aux membres d'une classe

[modifier | modifier le code]

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

### Contrôle de l'accès aux membres d'une classe et visibilité

[modifier | modifier le code]

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 :

Portées (visibilités) des membres d'une classe Portée  | Mot clé  | Visible (accessible) par  | Note

|
|
|

(visibilité) | en C++ | un membre de la classe | une classe dérivée | un client de l'objet
public |

public

| oui  | oui  | oui  | Les membres publics sont aussi accessibles que l'objet instancié de cette classe (les membres déclarés dans cette portée sont visibles et utilisables par le client de l'objet).
protégé |

protected

| oui  | oui  | non  | Les membres protégés ne sont accessibles que par les membres de l'objet instancié de cette classe et par les classes qui en sont dérivées.
privé |

private

| oui  | non  | non  | Les membres privés ne sont accessibles que par les membres de l'objet instancié de cette classe (ils ne sont pas accessibles par une classe fille ou le client de l'objet).

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.

## Surcharge d'opérateur

[modifier | modifier le code]

Article détaillé : Surcharge des opérateurs.

Lorsqu'on est amené à manipuler des données de même type (c'est par exemple le cas de points dans un repère), on peut vouloir appliquer à ces objets (au sens de la POO) des opérations. Ainsi, la fusion de deux zones (polygones) donne bien une nouvelle zone, tout comme l'addition de deux points donne un nouveau point.

* Pour une addition de points, une première méthode consisterait à créer une méthode membre de la classe Point qu'on nommerait `translate(Point)` et qui renverrait un nouveau Point ayant subi l'addition. On a :

...
p=Point(6,2)
q=Point(6,3)
m=Point(0,0)
m=p.translate(q) // p+q
...

* En fait une notation plus naturelle et beaucoup plus simpliste serait de représenter l'addition tout simplement par `m = p+q`. Pour cela on utilise un mécanisme appelé surcharge d'opérateurs, qui redéfinit un opérateur donné pour une action donnée[3].

Continuons sur notre classe Point. L'exemple Python suivant est très parlant :

class Point:
(...)
def __add__(self,point):                             # Surcharge de '+'
return Point(self.x + point.x, self.y + point.y)

p=Point(0,0)
q=Point(2,3)
r=p+q

Ainsi `r.getX()` retournera 2.

## Notes et références

[modifier | modifier le code]

1. ↑ « Classes », sur Mozilla Developer Network (consulté le 13 septembre 2016)
2. ↑ On aurait très bien pu dire qu'un dessin vectoriel est un ensemble de polygones, de lignes et de points. Mais on s'aperçoit que, si on veut ajouter une géométrie plus complexe, il faut modifier la structure même de la classe mère, ce qui est ridicule.
3. ↑ On peut bien évidemment surcharger l'opérateur '+' pour qu'il réalise autre chose que l'addition de Points. Cependant une multiplication de surcharges mal choisies contribuerait à alourdir le code et à le rendre illisible.

## Voir aussi

[modifier | modifier le code]

Sur les autres projets Wikimedia :

* classe, sur le Wiktionnaire

* Classe abstraite
* Métaclasse
* Unified Modeling Language
* Encapsulation des données
* Programmation par contrat
* Programmation orientée prototype : programmation objet sans classe.
* ClassFile Inspector : plugin pour Eclipse, éditeur de bytecode Java.

v · m

Types de données

Non interprétée |

* Bit
* Byte
* Trit
* Tryte
* Mot

Numérique |

* Bignum
* Complexe (en)
* Décimal (en)
* Virgule fixe
* Virgule flottante
* Entier
* Non signé (en)
* Intervalle
* Rationnel (en)

Texte brut |

* Caractère
* Chaîne de caractères

Pointeur |

* Adressage mémoire
* Physique
* Virtuelle
* Référence

Composite (en) |

* Type algébrique de données
* Généralisé
* Tableau
* Tableau associatif
* Classe
* Dépendant
* Égalité (en)
* Inductive (en)
* Liste
* Objet
* Métaobjet
* Option (en)
* Produit
* Enregistrement
* Ensemble (set)
* Vecteur
* Union (en)
* Disjointe

Autres |

* Booléen
* Type vide
* Collection
* Conteneur
* Type énuméré
* Exception
* Fonction
* Opaque (en)
* Type récursif
* Sémaphore
* Flux
* Top (en)
* Type class (en)
* Type unité
* Void

Articles liés |

* Type abstrait
* Structure de données
* Généricité
* Kind (en)
* Métaclasse
* Parametric polymorphism (en)
* Primitive data type (en)
* Interface
* Subtyping (en)
* Type constructor (en)
* Conversion de type
* Type system (en)

v · m

Éléments de programmation informatique

Bibliothèque logicielle |

* Bibliothèque standard
* Espace de noms
* Framework
* Gabarit
* Interface
* Interface de programmation (API)

Vocabulaire |  |

* Algorithme
* Expression
* Indentation
* Instruction
* Ligne de code
* Opérateur
* Pseudo-code
* Ramasse-miettes

Fonctions |

* Convention de nommage
* Dispatch multiple
* Factorisation
* Fonction imbriquée
* Fonction de rappel
* Fonction d'ordre supérieur
* Fonction récursive
* Généricité
* Opérande
* Paramètre
* Polymorphisme
* Procédure
* Signature de type
* Surcharge

Objet |

* Classe
* Constructeur
* Destructeur
* Encapsulation
* Héritage
* Héritage multiple
* Instance
* Méthode

Événementiel | Inversion de contrôle
Code source |  | Structures de données |

* Arbre
* Attribut
* Caractère
* Enregistrement
* Ensemble
* File
* Liste
* Liste chaînée
* Pile
* Propriété
* Sémaphore
* Tableau
* Tas
* Type abstrait
* Vecteur

|

Déclarations |

* Affectation
* Pointeur
* Portée
* Référence
* Tableau associatif
* Type énuméré
* Type récursif
* Typage statique
* Variable
* Variable globale
* Variable locale

Structures de contrôle |

* Case
* Do
* Else
* Eval
* If
* For
* Goto
* Loop
* Switch
* While

Fonctions usuelles |

* Concaténation
* Incrémentation
* malloc
* printf

Outil de développement |

* Environnement de développement
* Générateur de documentation
* Gestion de versions
* Modèle
* Patch
* Spécification

Folklore |

* Hello world
* Principe KISS
* Langage de programmation exotique

Catégories :

* Programmation informatique
* Développement logiciel

* Portail de la programmation informatique

*[v]: Voir ce modèle.
*[m]: Modifier ce modèle. Merci de prévisualiser avant de sauvegarder.