Ce chapitre a pour but d'introduire la notion de classe : de quoi une classe est-elle faite et quel rôle joue-t-elle, durant le développement du programme, sa compilation, sa structuration finale, et surtout son découpage.
Dans les langages OO, la classe est le modèle à respecter, comme une maison le fait du plan de l'architecte,et la chemise du patron du couturier. La classe se décrit au moyen de trois informations :
- Le nom de la classe
- Les attributs de la classe
- Les méthodes de la classe
int maMethode(){
attribut1 = attribut1 + 1 ;
....
return attribut1;
}
La rencontre du mot return met fin à l'exécution de la méthode en replaçant celle-ci dans le code qui l'appelle par la valeur de ce retour. La différence entre une méthode qui retourne une valeur et une qui ne retourne rien (void précède alors le nom de méthode) se marque uniquement dans le contexte d'exécution de la méthode.
En langage procédural ont fait la distinction entre une fonction (déclarée avec un retour) et une procédure (déclarée sans retour et qui se borne à modifier des données du code ).
Une méthode, comme toute opération informatique (fonction ou procédure), peut recevoir un ensemble d'argument entre les parenthèses,dans l'exemple ci-après l'argument entier « a ».
void maMethode( int a ){
attribut1 = attribut1 + a ;
....
}
Identification et surcharge des méthodes par leur signature : La signature de la méthode est ce qui permet de la retrouver dans la mémoire des méthodes. Elle est constituée du nom, de la liste, ainsi que du type des arguments.Toutes modification de cette liste entraîne la création d'une nouvelle méthode,surcharge de la précédente. La nature du return ne fait pas partie de cette signature dans la mesure où deux méthodes ayant le même nom et la même liste d'arguments ne peuvent différer par leur return comme ci-dessous.
class MaClasse1 {
void maMethode( ){
attribut1 = attribut1 + 1 ;
....
}
void maMethode( int a ){
attribut1 = attribut1 + a ;
....
}
attribut1 = a + b ;
....
}
int maMethode( int a, int b ){ /* Il est interdit de définir cette méthode, présentant la même signature, mais un type de retour différent de la précédente */
}
}
La classe est un module fonctionnel , l'existence de la classe nous épargnera de préciser, pour chaque objet, le nombre et le type de ses attributs,ainsi que la signature et le corps des méthodes qui manipulent ces derniers,économie d'écriture non négligeable et dont l'effet va croissant avec le nombre d'objets issus d'une même classe.En général, tout programme OO manipulera un grand nombre d'objets d'un même classe, ces objets seront stockés dans des ensembles informatiques particuliers, que l'on dénomme des collections.Il s'agira des listes pour les ensembles extensibles, ou des tableaux pour les non extensibles.
Il est considéré comme une très bonne pratique en programmation, de ne jamais créer une variable quellle qu'elle soit sans l'initialiser au préalable et certainement avant toute utilisation.Pour ce qui est des objets, c'est bien parce qu'il s'agit de l'unique information à compléter qu'une méthode particulière portant le même nom que la classe s'y emploiera.On appelle cette méthode singulière le constructeur.
Le constructeur : C'est une méthode particulière, ayant le même nom que la classe,définie sans type de retour.sont rôle est d'initialiser les attributs d'un objet dès sa création.Contrairement aux autres méthodes qui s'exécutent alors qu'un objet est déjà créé et sur celui-ci, il n'est appelé que lors de la construction de l'objet, et une version par défaut est toujours fournie par les langages de programmation. La recommandation, classique en programmation, est d'éviter de se reposer sur le « défaut », et de là toujours prévoir un constructeur pour chacune des classes créées, même s'il se limite à reproduire le comportement par défaut.Le constructeur est souvent une des méthodes les plus surchargées, selon les valeurs d'attributs qui sont connues à la création de l'objet et qui sont passées comme autant d'argument.
Ainsi un des constructeurs de la classe MaClasse pourrait se définir comme suit :
MaClasse( int attribut1Init , double attribut3Init ){ // pas de valeur de retour pour le constructeur
attribut1 = attribut1Init ;
attribut3 = attribut3Init ;
attribut2 = 1 ;
}
Cependant dès qu'un constructeur est défini dans la classe,et pour autant qu'il reçoivent un ou plusieurs arguments, il ne sera plus possible de créer un objet en n'y indiquant aucun argument (sauf si le constructeur est explicitement surchargé par un autre qui ne reçoit aucun argument). Comme il est de bonne pratique en informatique de toujours avoir la maîtrise de l'initialisation des objets qu'on utilise, prenez l'habitude, pour éviter toute surprise, de toujours définir un constructeur.
Voyons deux façons différentes de créer un objet et de faire appel à une méthode de cette classe:
Exemple 1 :
MaClasse monObjet = new Maclasse( 3 , 5 ) ;/* création de l'objet et assignation de l'adresse de l'objet comme valeur du référent */
monObjet.methodex(3) ;
Exemple 2 :
MaClasse monObjet ; // création du seule référent initialisé à null.
monObjet.methodex(3) ;
A la fin de la première instruction de l'exemple 2, seul le référent est créé, et typé. Il n'est pas incorrect aux yeux du compilateur d'envoyer un message à même ce référent par l'intermédiaire de la deuxième instruction monObjet.methodex(3) bien que l'objet ne soit pas créé. Bien évidement, cela plantera à l'exécution et produira une exception de type NullPointer,une des erreurs les plus fréquentes en Java et C# (et que le compilateur attentif soit-il ne peut anticiper).
Cela démontre que le compilateur ne se préoccupe jamais de la partie new des instructions de créations d'objet et limite son attention à la déclaration statique.Le reste, la création à proprement parler, ne se déroule que pendant l'exécution.
La figure ci-dessous illustre les trois étapes de la construction d'objet déclenchées par l'instruction :
MaClasse monObjet = new Maclasse( 3 , 5 ) ;
Mémoire dynamique, mémoire statique : A l'époque des tous premiers langages de programmation à l'issue de la compilation, il y avait moyen de prévoir de quelle quantité de mémoire vive le programme aurait besoin pour son exécution, la gestion s'effectuait selon le principe dit de « mémoire pile » toujours d'actualité dans la plupart des langages d'aujourd'hui. La gestion pile revient à empiler et dépiler les données à mémoriser pour y placer en respectant un mécanisme de type dernier rentrant premier sortant, en fonction du début et de la fin des blocs d'instructions dans lesquels ces données opèrent. Ce mode de gestion mémoire est également décrit comme « statique ».
Le mot réservé new ,autorise un programme au cours de son exécution, non seulement à allouer de l'espace mémoire pour y placer de nouvelles variables (des objets) , mais également à les disposer n'importe où dans cette mémoire et sans contraindre leur répartition et disparition de leur seule présence dans les blocs d'instructions. Ce mode alternatif de gestion de mémoire est généralement taxé de « dynamique ».
La classe comme garante de son usage. Contrairement aux langages « interprétés » comme Pythons et PHP 5, dans les langages compilés comme C# et Java le compilateur a pour fonction critique de générer du code « exécutable », et que son utilisateur exige le moins inattendu possible, le compilateur prendra garde de vérifier que rien de ce qui est écrit par le programmeur ne puisse être source d'imprévu et d'erreur.Et c'est la que la classe joue de nouveau un rôle considérable, en permettant au compilateur de se transformer en cerbère, et de s'assurer que ce qui est demandé aux objets (essentiellement l'exécution de messages) est de l'ordre du possible. La classe est assurée par avance que tout de ce que feront ses objets est conforme à ce qui est spécifié dans le contrat. Et ce contrat est passé avec le compilateur. On ne peut envoyer sur l'objet un message qui ne soit pas une des méthodes prévues par sa classe. On dit des langages qui permettent cette vérification qu'ils sont fortement typés.
Le langage est fortement typé quand le compilateur vérifie que l'on ne fait avec les objets et les variables du programme que ce qui est autorisé par leur type.Cette vérification a pour effet d'accroître la fiabilité de l'exécution du programme, l'étape de compilation y est essentielle.
Mémoire de la classe, dans une application logicielle particulière quand tous les objets ont une valeur d'attribut commune, il n'est plus nécessaire d'installer cet attribut dans l'espace mémoire alloué à chaque objet, vu que la valeur est commune à tous les objets.Il serait plus naturel, à l'instar des méthodes, de l'installer dans les espaces mémoire dédiés aux classes. On qualifie ce type d'attribut particulier, dont les valeurs sont partagées par tous les objets et deviennent de ce fait plutôt attribut de classe que d'objet, d'attribut statique.On retrouve ces attributs dans la zone de mémoire des méthodes.
Méthode de la classe et des instances, certaines méthodes peuvent également être déclarées statiques,elles se rapportent à la classe plutôt qu'à un objet. Les praticiens de Java ou de C# connaissent tous une célèbre méthode statique,totalement inévitable, la méthode main(). En Java et C# le « main » est une méthode statique, car il n'est, en effet, pas nécessaire de lancer cette méthode à partir d'un objet.
Statique: Les attributs d'une classe dont les valeurs communes à tous les objets, et qui deviennent ainsi directement associés à la classe, ainsi que les méthodes pouvant s'exécuter directement à partir de la classe, seront déclarées comme statique. Ils pourront s'utiliser en l'absence de tout objet. Une méthode statique ne peut utiliser que des attributs statiques, et ne peut appeler en son sein que des méthodes également déclarées comme statiques.
Liaison naturelle et dynamique des classes. La classe, par le fait qu'elle s'assimile à un petit programme à part entière, constitue un module idéal pour le découpage du logiciel en ses différents fichiers. La liaison sémantique entre classes, rendue possible si la première intègre en son code un appel à la seconde, devrait suffire à relier de façon dynamique, pendant la compilation et l'exécution du code, les fichiers dans lesquels ces classes sont écrites.