Notes de laboratoire

Contents
1 L’orient´e objet et l’h´eritage 3
1.1 Introduction....................................... 3
1.2 Convention de nommage des classes et variables . . . . . . . . . . . . . . . . . . . 3
1.3 Unepremi`ereclasse .................................. 4
1.4 Lespaquets....................................... 4
1.5 Interaction avec l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 Javaetpointeurs.................................... 5
1.7 Constructeurs : initialisation d’objets de classe . . . . . . . . . . . . . . . . . . . 6
1.8 Setters, getters et fonction toString() ........................ 8
1.9 Gestiondestableaux.................................. 10
1.10H´eritage......................................... 10
1.11 Port´ee des attributs et m´ethodes de classe . . . . . . . . . . . . . . . . . . . . . . 12
1.12 Mot-cl´e final ...................................... 12
2 Polymorphisme : superclasses abstraites et interfaces 13
2.1 Introduction au polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2 Supeclassesabstraites ................................. 13
2.3 Interface......................................... 15
2.4 Superclasses abstraites VS interfaces . . . . . . . . . . . . . . . . . . . . . . . . . 16
3 Traitement des exceptions 17
3.1 Introduction....................................... 17
3.2 Captureruneerreur .................................. 18
3.3 Les clause throws et throw .............................. 19
3.4 La fonction printStackTrace() ........................... 20
4 Fichiers et flots de donn´ees 21
4.1 Introduction....................................... 21
4.2 Fichiersetflux ..................................... 21
4.3 ´ Ecriture et lecture `a partir d’un fichier `a acc`es s´equentiel . . . . . . . . . . . . . . 22
- 1 -

- 2 -

Chapter 1
L’orient´e objet et l’h´eritage
1.1 Introduction
Avec le langage de programmation Java, l’orient´e objet est un concept primordial ´etant donn´e
que tout y est objet. En C/C++, l’emploi des objets n’est pas obligatoire. L’utilisateur d´eclare
une fonction main() qui est appel´ee au lancement du programme et qui contient l’ensemble des
instructions du programme. En Java, cette fonction main() est incluse en tant que fonction
static (op´eration de classe) au sein d’une classe. Il n’est donc pas n´ecessaire de cr´eer une
instance d’objet pour appeler cette fonction, mais il n’est pas possible de d´eclarer des fonctions
ou des variables en dehors des classes. Ce chapitre rappellera donc les notions relatives `a l’orient´e
objet.
1.2 Convention de nommage des classes et variables
Avant d’aller plus loin dans la pr´esentation des concepts relatifs `a l’orient´e objet, il faut pr´esenter
les conventions de nommage des classes et des variables au sein de Java. Afin d’am´eliorer la
lisibilit´e et la compr´ehensibilit´e du code, la convention de nommage CamelCase a ´et´e adopt´ee
pour nommer les classes et variables. Elle n’est pas obligatoire, mais fortement sugg´er´ee et
commun´ement adopt´ee par la communaut´e des d´eveloppeurs. Elle est d`es lors impos´ee au cours
des s´eances de laboratoire. Cette convention am`ene les r`egles suivantes :
Le nom d’une classe commence par une majuscule.
Le nom d’une variable ou d’une fonction commence par une minuscule.
Lorsque que le nom d’une classe, d’une variable ou d’une fonction est compos´e de plusieurs
mots, l’initial de chaque mot est mise en majuscule (`a l’exception du premier mot s’il s’agit
du nom d’une variable, afin de respecter la r`egle pr´ec´edente). L’emploi du caract`ere ” ”
pour s´eparer les mots et donc contre-indiqu´e.
Exemples :
public class EtudiantMaster
int anneeNaissance
float calculerMoyenne()
- 3 -

1.3 Une premi`ere classe
Le listing 1.1 pr´esente une premi`ere classe assez simple qui permet d’afficher le texte ”Hello
World” au terminal. En Java, chaque classe est imp´erativement programm´ee dans un fichier
distinct qui porte le nom de la classe et dont l’extension est ”.java”. Il y a ainsi un fichier nomm´e
HelloWorld.java qui contient le code de la classe HelloWord.
Listing 1.1: La classe HelloWorld
1public class HelloWo rl d {
2
3/* *
4* @param args the comm an d line ar gu me nts
5*/
6public static void main ( Str in g [] arg s ) {
7Sys tem . out . pri nt ln (" Hell o World " );
8}
9
10 }
La fonction main() est n´ecessairement d´eclar´ee comme ´etant publique (public) et statique
(static) afin de pouvoir ˆetre appel´ee sans devoir instancier la classe. Les m´ethodes et les
variables statiques sont appel´ees m´ethodes et variables de classe. Les variables de classes sont
partag´ees entre les instances de la classe. Si une instance modifie la valeur d’une variable de
classe, cette modification sera d’application pour toutes les instances de la classe consid´er´ee.
les m´ethodes de classe sp´ecifient que l’action r´ealis´ee n’est pas li´ee `a une instance particuli`ere
de cette classe. Il n’est donc pas n´ecessaire d’instancier la classe, de cr´eer un objet, pour
utiliser la m´ethode. Pour appeler une telle m´ethode, il suffit de faire directement r´ef´erence
au nom de la classe. Par exemple, pour appeler la fonction main() de la classe HelloWorld :
HelloWorld.main(null);
Comme la fonction main() de la classe HelloWorld ne renvoie rien, le mot-cl´e void est plac´e
avant le nom de la fonction.
Pour afficher du texte dans la console, HelloWorld utilise les outils fournit par la classe
System. La classe System met `a disposition des objets de flux qui fournissent des canaux
de communication entre un programme et un p´eriph´erique bien d´etermin´e. En l’occurrence,
System.out permet d’afficher des donn´ees dans la console. Il fournit plusieurs m´ethodes `a cet
escient. La m´ethode utilis´ee, println(), est un raccourci pour print line. Cette m´ethode affiche
dans la console la chaˆıne de caract`ere pass´ee en param`etre et ins`ere un retour `a la ligne. Il est
possible d’afficher une chaˆıne de caract`eres sans retour `a la ligne avec la m´ethode print().
1.4 Les paquets
En Java, les classes sont r´eunies dans des paquets qu’il faut importer pour pouvoir les employer,
`a l’instar des fichiers d’en-tˆete en C++ qui fournissent les d´efinitions de fonctions et de classes.
Dans l’exemple du listing 1.1, la classe System est issue du package java.lang. Celui-ci n’est
pas import´e par une instruction sp´ecifique au d´ebut du programme, car il est automatiquement
import´e dans tous les programmes Java. Le paquet java.lang est le seul paquet `a ˆetre import´e
automatiquement. Tout autre paquet doit ˆetre import´e avec le mot-cl´e import. Par exemple,
l’emploi de la classe JOptionPane, qui sera pr´esent´e plus loin, n´ecessite l’importation du paquet
javax.swing.
Il y a deux mani`eres d’acc´eder `a une classe plac´ee dans un paquet. Soit en important la
classe elle-mˆeme avec une ligne de code comme :
import javax.swing.JOptionPane;
- 4 -

soit en important l’enti`eret´e du paquet qui la contient `a l’aide du signe ’*’ :
import javax.swing.*;
1.5 Interaction avec l’utilisateur
Nous avons d´ej`a vu comment afficher une chaˆıne de caract`eres dans la console `a l’aide de la
classe System. Pour saisir des informations au clavier, c’est la classe JOptionPane qui est
employ´ee. Cette classe fait partie du package javax.swing et fournit un ensemble de m´ethodes
qui permettent `a l’utilisateur d’interagir via des boˆıtes de dialogue.
Pour saisir du texte via une boˆıte de dialogue, il faut utiliser la fonction showInputDialog.
Cette fonction renvoie un pointeur vers la chaˆıne de caract`eres saisie par l’utilisateur.
String nom = JOptionPane.showInputDialog("Veuillez entrer votre nom");
Pour afficher du texte au sein d’une boˆıte de dialogue, il suffit d’utiliser la fonction
showMessageDialog() :
JOptionPane.showMessageDialog(null, "Votre nom est " + nom);
Pour manipuler autre chose que des chaˆınes de caract`eres, il est n´ecessaire d’utiliser les
classes des types primitifs. Java fournit des classes pour chaque type primitif (int,float ...)
qui encapsulent une instance du type primitif consid´er´e et qui offrent un ensemble de m´ethodes
pour manipuler les donn´ees. Ainsi, si un utilisateur souhaite saisir un entier, il peut utiliser la
fonction Integer.parseInt() qui prend en argument une chaˆıne de caract`eres et qui renvoie
un entier :
int age = Integer.parseInt(JOptionPane.showInputDialog("Veuillez entrer votre
^age"));
Le mˆeme genre de m´ethode peut ˆetre trouv´e pour les autres types primitifs.
1.6 Java et pointeurs
Pour rappel, un pointeur est une variable qui contient l’adresse `a laquelle se trouve une donn´ee.
Dans Java, tous les objets sont acc´ed´es par l’interm´ediaire de pointeurs. ` A chaque fois qu’une
d´eclaration d’objet est faite, il s’agit en fait de la d´eclaration d’un pointeur.
Par exemple, les chaˆınes de caract`eres sont g´er´ees en Java par la classe String. Une chaˆıne
de caract`eres est donc d´eclar´ee comme toute variable primitive :
String monNom;
A ce stade cependant, il n’est pas encore possible de manipuler de chaˆınes de caract`eres. La
variable monNom est un pointeur et ne permet que de stocker l’adresse de la chaˆıne de caract`eres.
Il est donc n´ecessaire d’allouer de la place pour celle-ci et de stocker l’adresse de cette espace
m´emoire dans la variable monNom. Cette op´eration se fait `a l’aide de l’instruction new :
monNom = new String();
Les fonctions ne re¸coivent pas de copies locales des objets, mais directement les adresses des
objets pass´es en param`etres. Toute modification apport´ee sur un objet au sein d’une fonction
est donc aussi effective en dehors de cette fonction.
- 5 -