ENPC - Objets et Patterns

ENPC - Objets et Patterns - Séance 2

La programmation orientée objet

La programmation objet, c'est à dire celle qu'on est sensé mettre en oeuvre lorsqu'on écrit des programmes avec un langage à objet (ou langage orienté objet) tel que Java, fait intervenir différents concepts tels que celui de classe, d'objet, de responsabilité, d'encapsulation, etc.
Le premier concept auquel on est confronté lorsqu'on écrit un programme est celui de classe: le mot-clé class MaClasse { ... } permet de définir (entre les accolades) les membres de la classe MaClasse.

Une classe représente et définit plusieurs choses en même temps:
1. Un modèle pour la création de toutes ses instances (tout objet est l'instance d'une classe). En ce sens, une classe est une sorte de moule dans lequel on coule un objet lors de sa création (cette création est effectuée par l'opérateur new suivi d'un constructeur qui a le même nom que la classe.
  Exemple: Personne jean = new Personne("Jean");
  Ici, jean est le nom d'une variable qui contient la référence à l'objet créé et "Jean" est une chaîne de caractère (String) utilisée comme argument du constructeur de la classe Personne.
2. Une unité de compilation. Cela signifie que la compilation d'un ensemble de fichiers produit un bytecode de classe (un fichier Toto.class) par classe définie dans le code source (par mot-clé ...class Toto { ... }.
3. Un type qui sera le type assigné à tout objet de cette classe. La notion de type est importante car elle permet au compilateur de signaler des incohérences dans un programme. Par exemple, si une méthode est définie dans la classe Personne avec un paramètre de type Personne (disons discuterAvec(Personne p) {...}), alors le compilateur détecte une erreur si cette méthode est appelée avec un argument d'un autre type. Exemple:
```
   Brouette b = new Brouette();
   Personne bob = new Personne("Robert");
   jean.discuterAvec(b);        // Erreur de compilation
   jean.discuterAvec(bob);      // Correct 
```
  Dans la dernière instruction, la méthode discuterAvec est appelée sur l'objet jean (qu'on appelle la cible de la méthode) avec comme argument l'objet bob.
4. D'une manière générale, une classe décrit ce que tous ses objets ont en commun. C'est à dire le type, bien sûr, mais plus précisément leurs membres, c'est à dire d'une part ce qui permet de décrire l'état de chacun des objets de cette classe (les variables d'instance, ou champs, ou encore attributs) et d'autre part les fonctionnalités dont chacun d'entre eux dispose (c'est à dire les méthodes).
Un comportement habituel en programmation orientée objet est décrit ci-dessous:
1. Définir (décrire) une classe, c'est à dire:
  - son nom (qui sera à la fois le nom de la classe et celui du type correspondant)
  - les variables d'instance dont disposeront chacune de ses instances: chaque objet de cette classe disposera de ses propres occurrences de ces variables d'instance qui décriront son état (vraissemblablement différent de l'état des autres objets de la même classe).
  - les méthodes (fonctionnalités) qui seront offertes à toute instance de cette classe.
2. Créer des objets (instances) de cette classe, qui vont pouvoir "vivre" avec chacun leur propre état (représenté par les valeurs de leurs variables d'instance) et qui pourront communiquer entre eux ou avec des objets d'autres classes via leurs méthodes respectives.
Un programme exécutable (ou plus exactement dont le bytecode produit par la phase de compilation est exécutable par une JVM) est une classe qui dispose d'une méthode dite principale ayant la forme suivante:
public static void main(String[] args) { ... }

La programmation "tout court" !

Avant de s'intéresser aux spécificités de la programmation orientée objet, nous allons nous familiariser avec la programmation "tout court", c'est à dire aux instructions simples, à leurs enchaînements, aux structures de contrôle, etc. Pour mettre en oeuvre ces concepts simples, nous n'avons pas besoin d'objets (instances) ayant des états et des fonctionnalités. Dans ce cas, il nous faut des méthodes pouvant être exécutées indépendament de l'existence d'une instance. De telles méthodes sont dites statiques ou encore méthodes de classe.

Une méthode statique a pour propriété de pouvoir être exécutée avec pour cible la classe elle-même (tandis qu'une méthode non statique doit impérativement être appelée sur une instance de la classe. La définition d'une méthode statique se fait avec le mot clé static. Exemple:
static void maMethode(Type1 param1, Type2 param2) {...}

En dehors des modificateurs de visibilité (public, protected, private), qui peuvent s'appliquer selon le cas aux classes, aux méthodes ou aux variables d'instance et sur lesquels nous reviendrons plus tard, la définition d'une méthode est de la forme suivante:

typeRetour nomMethode(Type1 param1, ..., TypeN paramN) { ... }

Dans le cas des méthodes statiques, nous ferons simplement précéder le type de retour (le type de la valeur renvoyée par l'exécution de la méthode) par le mot-clé static.

Les types en Java

Toutes les variables que l'on peut manipuler en Java sont typées et on distingue deux grandes catégories de types:

les types dits primitifs. Ces types sont les plus simples que l'on puisse trouver, et disposent d'une représentation "machine" établie. Ainsi, ce sont les types:
- boolean dont la valeur est true ou false.
- byte qui représente un octet, c'est à dire un entier signé sur 8 bits.
- char qui représente les caractères sur 16 bits, dans le format Unicode.
- short qui représente un entier signé sur 16 bits.
- int qui représente un entier signé sur 32 bits.
- long qui représente un entier long signé sur 64 bits.
- float qui représente un nombre flottant signé sur 32 bits au format IEEE 754.
- double qui représente un nombre flottant signé sur 64 bits au format IEEE 754.
La caractéristique commune à tous les types primitifs est que la déclaration d'une variable alloue implicitement l'espace mémoire nécessaire à son stockage. Ainsi, la simple déclaration int i; réserve 32 bits d'espace mémoire pour stocker la ou les valeurs que l'on voudra affecter à l'entier i.
les types référence. Une référence peut être vue comme l'adresse d'un espace mémoire. Tous les types qui ne sont pas primitifs sont des types référence, mais leur déclaration n'implique pas que l'espace mémoire auquel il correspondent à été alloué. Cet espace, dont la taille dépend de la classe de l'objet à créer, doit être alloué explicitement, grâce à l'opérateur new, lors de la construction d'un objet dont la référence (l'adresse en mémoire) pourra alors être stockée dans une variable de type référence. Exemple:
```
 Personne p;
 // N'alloue pas l'espace mémoire requis
 // pour stocker un objet de la classe Personne  

 p = new Personne("Toto");
 // L'opérateur new alloue l'espace mémoire requis par le 
 // constructeur de la classe Personne et renvoie (assigne
 // dans la variable p) la référence à cet espace mémoire.
 
```
On distingue quelques fois les références à des objets (comme ci-dessus) et les références à des tableaux. Ces deux types de référence sont bien de même nature, même si les constructeurs de tableaux sont un peu particuliers.

Les tableaux

Les tableaux, en Java, sont des instances de classes invisibles (elles n'apparaissent pas dans les API). Ils permettent de stocker un nombre établi d'éléments, tous du même type. Une variable de type tableau se déclare avec la syntaxe suivante:
TypeElement[] nomVariable;
Un objet tableau de ce type, de taille N, s'alloue comme ceci:
nomVariable = new TypeElement[N];
Il existe d'autres syntaxes, mais celle ci est la plus répandue.

Lorsqu'un tableau est alloué, tous ses éléments sont initialisés à la valeur par défaut du type des éléments. Cette valeur est 0 pour tous les types numériques, false pour le type boolean et null pour tous les types référence. Ce null correspond à "la référence vers rien" et c'est une erreur que d'essayer d'y accéder. Ces initialisations par défaut sont également effectuées pour les variables d'instance (champs) d'un objet lors de sa création.

Exercices

Afficher les carrés des n premiers entiers dans la méthode principale. Créer ensuite une méthode de signature public static void premiersCarres(int n) qui s'en charge, et l'appeler dans la méthode principale.
Définir (déclarer et initialiser) un tableau tab de 10 entiers. Écrire une méthode d'affichage des éléments d'un tableau d'entier. L'initialiser chaque élément au carrré de son indice (t[5] = 25)
Écrire une méthode de tri d'un tableau d'entier.
Écrire un programme qui accepte une liste d'entiers sur la ligne de commande, les place dans un tableau d'entiers créé pour l'occasion et les affiche dans l'ordre après avoir trié ce tableau. Exemple:
```
  % java TriEntiers 34 65 12 7 27 12
  7 12 12 27 34 65 
```
Écrire une méthode de tri d'un tableau de String.