ENPC - Programmation - Séance 2

Les types en Java

Toutes les variables que l'on peut manipuler en Java sont typées, ce qui signifie que le programmeur doit leur affecter un type qui est pris en compte par le compilateur pour vérifier la cohérence de l'utilisation de ces variables. 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 prédéfinie au sein de la machine virtuelle. 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 ils correspondent a é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:

   String s;
   // N'alloue pas l'espace mémoire requis
   // pour stocker un objet de la classe String
  
   s = new String("toto");
   // L'opérateur new alloue l'espace mémoire requis par le 
   // constructeur de la classe String et renvoie (assigne
   // dans la variable s) la référence à cet espace mémoire.
   

  On distingue quelquefois les références à des objets (comme ci-dessus) et les références à des tableaux. Ces deux types de références 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 (leur documentation n'apparaît 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;

nomVariable = new TypeElement[N];

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.

Étant donnée une instance de tableau tab, la taille de ce tableau peut être obtenue par l'expression tab.length.

Exercice 1

Écrire un programme qui accepte, sur la ligne de commande, un nombre arbitraire de valeurs entières et qui affiche la moyenne de ces valeurs.

Exercice 2

Écrire une méthode d'affichage des éléments d'un tableau d'entiers de taille quelconque. Écrire une méthode d'initialisation d'un tableau qui affecte à chaque indice le carré de cet indice (tab[5] = 25). Écrire un programme qui prend en argument sur la ligne de commande un entier n, définit un tableau tab de n entiers, l'initialise et l'affiche à l'aide des fonctions précédentes.

Exercice 3

Écrire une fonction tri() qui trie un tableau d'entiers dans l'ordre croissant.

É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 à l'aide de tri(). Exemple:

% java Tri 34 65 12 7 27 12
7 12 12 27 34 65

Exercice 4

Même question pour un tableau de double, avec une fonction de même nom tri().

Les exceptions

Le mécanisme des exceptions permet de séparer le flot de contrôle classique (appel/retour de fonction) du flot de contrôle lié à un comportement exceptionnel, tel qu'une erreur dépendant du contexte d'exécution.

Par exemple, revenons quelques instants au programme seance1.BaseDeux qui attend, sur la ligne de commande, qu'un entier soit fourni. Lorsqu'un tel entier est fourni, tout se passe bien:

% java seance1.BaseDeux 9
1001

% java seance1.BaseDeux
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
        at seance1.BaseDeux.main(BaseDeux.java:15)

int argument = Integer.parseInt(args[0]);

% java seance1.BaseDeux toto
Exception in thread "main" java.lang.NumberFormatException: For input \
                                                       string: "toto"
        at java.lang.NumberFormatException.forInputString(Number \
	                                        FormatException.java:48)
        at java.lang.Integer.parseInt(Integer.java:426)
        at java.lang.Integer.parseInt(Integer.java:476)
        at seance1.BaseDeux.main(BaseDeux.java:15)

Les exceptions représentent donc des problèmes qui arrivent au cours de l'exécution d'un programme. Leur cycle de vie est le suivant.

• Elles sont tout d'abord créées, comme le sont tous les objets (nous y reviendrons).
• Ensuite, ces exceptions sont levées, ce qui interrompt le flot de contrôle normal du programme. La levée d'une exception e est réalisée par l'instruction throw e.
• Finalement, une exception qui a été levée peut soit être capturée, soit remonter dans la pile des appels de fonctions.
  Si l'instruction qui a levé l'exception ou une fonction qui la propage est située à l'intérieur d'un bloc try, alors un ou plusieurs blocs catch peuvent tenter de capturer l'exception, suivant son type, et spécifier du code à exécuter dans ce cas.
  Si aucune capture n'est spécifiée, l'exception « remonte » à la fonction appelante, et ainsi de suite jusqu'à être capturée ou bien jusqu'à atteindre la fonction main().

Il est possible d'ajouter un bloc finally après un bloc try/catch. Ce bloc sera exécuté dans tous les cas.

Lorsqu'une exception peut être propagée par une fonction, cette fonction peut déclarer ce risque de propagation par le mot-clef throws. Par exemple, en l'absence des blocs de capture, nous aurions pu déclarer dans BaseDeux.java:

  public static void main(String[] args) throws
  ArrayIndexOutOfBoundsException, NumberFormatException {
    // ...
  }

Exercice 5

Modifier le programme seance1.BaseDeux pour qu'il ait le comportement suivant:

% java seance1.BaseDeux 9
1001
% java seance1.BaseDeux
Il faut donner un entier décimal en argument
% java seance1.BaseDeux toto
L'argument fourni doit être entier

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, dans

class 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 ou le receveur 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 classe Point

Nous considérons ici la classe Point des objets qui sont des points dans un plan à deux dimensions. Les instances de cette classe disposent donc, pour décrire leur état, de deux champs, x et y, de type double.

Pour créer un point, on dispose d'un constructeur qui accepte les deux coordonnées du point que l'on veut créer.

Un constructeur est une méthode un peu particulière puisqu'il doit avoir exactement le nom de la classe (avec sa majuscule) et qu'il n'a pas de type de retour (en effet, lorsqu'un tel constructeur est associé à l'opérateur new, il retourne la référence de l'objet (l'instance) qui vient d'être alloué et celle-ci est donc typée Point dans notre exemple.

Par ailleurs, on souhaite pouvoir effectuer deux opérations sur n'importe quel point:

• le déplacer, par la méthode public void translate(double dx, double dy) et
• en obtenir une représentation sous la forme d'une chaîne de caractères, par la méthode public String toString().

Autour des constructeurs

1. Modifier les paramètres formels du constructeur pour leur donner les noms x et y au lieu de leX et leY. Quel est le problème?
   Dans une classe, le mot clé this représente la référence à l'instance courante de cette classe. L'utilisation de ce mot-clé est donc interdite dans toute portion de code statique.
2. Mettre le constructeur et le code du main en commentaire. Dans le main, créer un seul point par Point p = new Point(); et l'afficher. Que s'est il passé? Enlever les commentaires du constructeur et tester à nouveau. Quel est le problème?
   Lorsqu'aucun constructeur n'est explicitement défini, le compilateur crée un constructeur implicite également appelé constructeur par défaut. Si un constructeur explicite est défini, ce constructeur par défaut n'est plus accessible.
3. Faire en sorte que les deux constructeurs Point(double x, double y) et Point() cohabitent dans la classe Point.
   On dit que ces deux constructeurs sont surchargés: ils ont le même nom mais sont différentiables par la liste de leurs paramètres.

Autour de toString()

1. Mettre en commentaire la définition de la méthode toString() de la classe Point, recompiler et exécuter. Comment expliquer ce comportement?
   La méthode toString() définie dans la classe Point est une redéfinition de la méthode toString() de la classe Object. En l'absence de la première, c'est la méthode de Object, héritée dans Point, qui est utilisée. Par défaut, elle affiche le nom de la classe de l'objet représenté par la référence et une valeur hexadécimale qui est un code représentant cet objet (hashcode).
2. Après avoir décommenté la méthode toString() dans le programme, remplacer dans le main l'instruction System.out.println(p.toString()); par System.out.println(p);. Que se passe-t-il?
   Lorsque son argument n'est pas un type primitif, mais une référence à un objet d'une classe, la méthode println appelle automatiquement la méthode toString() sur cette référence avant d'effectuer l'affichage de la chaîne de caractère résultant de cet appel.

Autour de l'égalité

1. Qu'affiche le programme suivant et comment expliquer ce résultat?

     Point p1 = new Point();
     Point p2 = new Point();
     System.out.println(p1 == p2);

   L'opérateur == agit en général sur les types primitifs. Lorsqu'il est utilisé sur des références à des objets, il teste l'égalité des références aux objets. En d'autre termes, il teste les valeurs qui ont été retournées par des appels à l'opérateur new. En ce sens, les deux points p1 et p2 qui ont été créés correspondent à deux références différentes, même si elles réfèrent des objets identiques (leur état est identique).
2. Définir une méthode public boolean same(Point p) qui retourne true si le paramètre p à même x et même y que le point auquel on applique la méthode et false sinon. Ainsi, si on appelle p1.same(p2) dans l'exemple ci-dessus, le résulat doit être true.

Surcharge de méthode

Surchargez, dans la classe Point, la méthode public void translate(double dx, double dy) avec une méthode public void translate(double d) qui déplace à la fois x et y de la valeur d. Testez cette méthode.
Tout comme les constructeurs, les méthodes peuvent être surchargées: cela signifie que plusieurs méthodes ayant le même nom cohabitent dans la même classe. Elle doivent se distinguer par des listes de paramètres différents.
Attention: dans une classe, deux méthodes ne peuvent pas avoir le même nom et les même paramètres, même si elles ont des types de retour différents.

Nicolas.Bedon[at]univ-mlv.fr - Etienne.Duris[at]univ-mlv.fr - © ENPC - Novembre 2002 - http://www-igm.univ-mlv.fr/~duris/ENPC