3.3 Corps d’une classe

Une classe est définie par divers éléments.

3.3.1 Attributs

Les attributs sont des variables à l’intérieur d’une classe, avec une visibilité privée (ou protégée en cas d’héritage (5).
Les attributs d’instance sont des variables personnalisables pour chaque instance : private type attributInstance;
Les attributs de classe sont des variables identiques pour toutes les instances, définies avec static : private static type attributClasse;

Un attribut de classe peut notamment être utilisé pour compter les instances.

Une constante est un attribut non-modifiable de classe, défini avec final et forcément à l’échelle de la classe avec static : private static final type constanteClasse;

Un attribut est appelé avec monInstance.unAttribut.

3.3.2 Constructeurs

Un constructeur est une méthode particulière : elle porte obligatoirement le nom de la classe et permet de créer des instances de cette classe (çàd alloue la mémoire nécessaire et initialise une instance).
Sa visibilité est généralement publique afin d’être accessible à l’extérieur de la classe.

Toute classe possède un constructeur publique par défaut, qui ne prend aucun paramètre. L’instance créée est vide, ses attributs ont leur valeur par défaut (souvent null ou zéro).
Lorsqu’un constructeur est défini dans la classe, il remplace celui par défaut.

Un constructeur est paramétrable : public MaClasse(type attribut1, type attribut2) {body}
On sélectionne parmi les attributs, ceux que l’on veut utiliser pour initialiser une instance. Les attributs non-initialisés auront leur valeur par défaut.

Dans le body, le constructeur initialise les attributs de l’instance à créer avec les paramètres grâce à this.attribut = parametre.
Il peut faire appel à des méthodes grâce à this.methode().

Par convention, on les nomme de la même façon pour avoir this.prenom = prenom.

La surcharge (2.3) de constructeurs est courante, afin d’avoir différentes manières de créer une instance.
Dans la signature du constructeur, on répète tous les paramètres concernés.
Dans le body, on utilise this(liste des parametres geres dans l'autre constructeur) en première instruction. Puis on complète avec les paramètres ajoutés (this.attribut = parametre).

Par convention, on ordonne les constructeurs du moins surchargé au plus surchargé (çàd par ordre croissant de paramètres).

3.3.3 Méthodes définies dans une classe

Une méthode d’instance est définie au sein de la classe, avec une visibilité publique afin d’être accessible à l’extérieur : private {type|void} methInstance(parametres potentiels) {body}
Dans le body, elle utilise this.attribut ou this.methodeDansMaClasse() pour accèder à un élément d’instance.
Elle peut faire appel à des méthodes extérieures à la classe, qu’il faut importer.

Ecrire explicitement this n’est bien souvent pas nécessaire mais ajoute de la lisibilité au code.

Une méthode de classe est définie au sein de la classe grâce à static, avec une visibilité publique afin d’être accessible à l’extérieur : private static {type|void} methClasse(parametres potentiels) {body}
Elle ne dépend pas d’une instance particulière et accède donc uniquement aux attributs de classe (pas de this). Elle peut faire appel à des méthodes extérieures à la classe, qu’il faut importer.

3.3.4 Assesseurs et mutateurs

D’après le principe d’encapsulation (@ref-visibilite-encapsulation)), les attributs sont protégés à l’intérieur de leur classe.
Les assesseurs (setters) et mutateurs (getters) sont des méthodes publiques standardisées qui permettent d’accéder à certains attributs depuis l’extérieur, avec des contrôles.

Un getter donne un accès en lecture sur un attribut : il se nomme toujours getAttribut, il ne prend pas de paramètre, il renvoie une variable du type de l’attribut appelé et ne contient que ce retour dans le body :

  public type getAtttribut() {
    return attributDuBonType;
  }

Un setter donne un accès en écriture sur un attribut : il se nomme toujours setAttribut, il prend un seul paramètre qui est la nouvelle valeur à attribuer, il ne renvoie rien et ne contient que la ligne d’affectation dans le body :

  public void setAttribut(type monAttribut) {
    this.monAttribut = monAttribut;
  }

Si l’on applique à la lettre le principe d’encapsulation, il est conseillé d’appeler les setters dans le constructeur -puisque c’est une méthode publique- et de laisser le setter utiliser le this.

Pour les attributs et les constantes de classe, qui sont static, les setters et getters doivent également être static, ils utilisent alors le nom de la classe au lieu du this.