Programmer en Java - GYMNASE DE BURIER - OC Informatique 14 15
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Programmer en Java OC Informatique 14 – 15 GYMNASE DE BURIER
Table des matières
1 Greenfoot 3
1.1 Concepts de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Gros chat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Le monde du crabe 8
3 De l’environnement intégré à la ligne de commande 11
3.1 La structure de base d’un premier programme Java . . . . . . . . . . . . . . . . 11
3.2 La ligne de commande du Mac . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Compilation bidon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4 Structure d’un programme Java autonome 16
4.1 La méthode main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2 Un tout petit premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.3 Un exemple un peu plus complexe . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 Pour passer des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5 Généralités sur Java 21
6 Quelques exercices d’entraı̂nement 25
6.1 Faire calculer la machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.2 Instructions répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.3 Données numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.4 Données alphanumériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.5 Pour commencer avec les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . 28
7 La programmation objet en Java 29
7.1 Classes et Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.2 Une classe et ses méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.3 La notion de constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
7.4 L’accessibilité aux attributs d’une classe . . . . . . . . . . . . . . . . . . . . . . 35
7.4.1 La notion d’accesseur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
7.4.2 La notion de mutateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
7.4.3 Les attributs statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1
7.5 L’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
7.5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
7.5.2 Un exemple complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
8 Exercices sur les objets en java 43
8.1 Figures géométriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
8.2 La citerne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
8.3 Thermometre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8.4 Devinez un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8.5 Ville et Capitale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8.6 Jouer avec des dés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.7 Les Schtroumpfs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
8.8 Le Village Schtroumpf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.9 Exercices sur les tableaux et les boucles . . . . . . . . . . . . . . . . . . . . . . . 53
8.10 Listes dynamiques en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.11 La classe Personne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.12 Exercices divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.13 Les piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9 Le point de départ : JFrame 64
10 Deux niveaux d’interface 65
10.1 Composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
10.2 Contenants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
10.3 Description de la JFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
11 Les gestionnaires de mise en forme 67
12 Les événements 69
v. 2.0 – Août 2014
1 Greenfoot
1.1 Concepts de base
Exercice 1.1
On voit ci-dessous le menu contextuel associé à un wombat du scénario leaves-and-wombats.
a) Établir une liste de toutes les méthodes du Wombat.
b) Dans la liste de la question a), chercher toutes les méthodes sans valeur de retour.
c) Dans la liste de la question a), chercher toutes les méthodes qui renvoient une valeur. Donner
également le type de la valeur de retour.
d) Décrire précisément chaque mot figurant dans l’en-tête de la méthode setDirection.
e) Donner la liste de toutes les valeurs que peut renvoyer la méthode canMove.
f) Donner quelques exemples de valeurs que peut renvoyer la méthode getLeavesEaten.
g) Quelle est la méthode de la classe Wombat qui demande un paramètre ? Quel est le type de ce
paramètre ?
h) Que signifie le mot-clef void ?
Exercice 1.2
On donne le scénario cars, dans lequel on trouve la classe Car. Ouvrir ce scénario.
a) Est-ce qu’un objet de type Car existe à l’ouverture du scénario ?
b) Est-ce que la classe Car existe à l’ouverture du scénario ?
c) Combien d’objets de type Car peut-on créer dans ce scénario ?
d) Créer quelques voitures. Ces voitures sont-elles différentes ?
e) Cliquer le bouton Act. Comment interpréter le résultat qui s’affiche à la console ?
f) Remettre le scénario à zéro en cliquant le bouton Reset. Créer une voiture dans la première
colonne. À l’aide d’un appel à la bonne méthode, faire se déplacer la voiture de deux cases
vers la droite.
3
Exercice 1.3
Rédiger l’en-tête d’une méthode publique nommée send, disposant d’un paramètre de type String,
et qui ne renvoie pas de valeur.
Exercice 1.4
Rédiger l’en-tête d’une méthode publique nommée moyenne, disposant de deux paramètres, tous
deux de type int, et qui renvoie une valeur int.
Exercice 1.5
Voici le diagramme de classe des acteurs du scénario leaves-and-wombats
On donne également les en-têtes des classes figurant dans ce diagramme à l’exception de la classe
Actor.
public class Wombat extends Actor
public class Leaf extends Actor
Dessiner le diagramme de classe des acteurs du scénario asteroids à partir des en-têtes de classes
donnés ci-dessous :
public class Explosion extends Actor
public class Mover extends Actor
public class Bullet extends Mover
public class Rocket extends Mover
public class Asteroid extends Mover
1.2 Gros chat
Exercice 1.6
Observez les en-têtes de méthodes ci-dessous :
public void play()
public void addAmount(int amount)
public boolean hasWings()
public void compare(int x, int y, int z)
public boolean isGreater (int number)
4
Pour chaque en-tête, répondez aux questions suivantes :
a) Quel est le nom de la méthode ?
b) La méthode retourne-t-elle une valeur ?
Si c’est le cas, quelle est le type de la valeur de retour ?
c) Combien de paramètres a la méthode ?
Exercice 1.7
Écrivez l’en-tête d’une méthode dont le nom est “go”. La méthode n’a pas de paramètre et ne
retourne aucune valeur.
Exercice 1.8
Écrivez l’en-tête d’une méthode dont le nom est process. La méthode a un paramètre de type int
intitulé “number” et elle retourne une valeur de type int.
Exercice 1.9
Sur papier, écrivez un appel de méthode pour la méthode play de l’exercice 1. Donnez un autre
appel de méthode pour la méthode addAmount de l’exercice 1.
5
Exercice 1.10
On donne ci-dessous les méthodes de la classe Cat du scénario fatcat.
Écrire la méthode act de votre chat en respectant les deux points suivants simultanément :
a) si le chat s’ennuie, il danse et crie “Hooray” ;
b) s’il ne s’ennuie pas, il se déplace à gauche de cinq unités et, dans ce cas seulement, s’il est
fatigué, il dort durant trois unités de temps.
Tous les exercices qui suivent sont destinés à être faits dans le scénario Greenfoot : fatcat.
Ouvrez le scénario dans Greenfoot avant de poursuivre.
Pour télécharger ce nouveau scénario :
http://www.greenfoot.org/book/etudes/code/fatcat.zip
Exercice 1.11
Ouvrez le code la classe Cat dans l’éditeur. Assurez-vous que l’éditeur est en mode de documentation.
De combien de méthodes dispose la classe Cat ?
Exercice 1.12
Combien de méthodes de la classe Cat retournent une valeur ?
Exercice 1.13
Combien de paramètres contient la méthode sleep ?
6
Exercice 1.14
Essayez d’appeler certaines méthodes de votre chat de façon interactive, en utilisant le menu contex-
tuel du chat. Les méthodes intéressantes proviennent toutes de Inherited from Cat.
Exercice 1.15
Est-ce que le chat s’ennuie ? Comment pouvez-vous faire pour qu’il ne s’ennuie pas ?
Exercice 1.16
Ouvrez l’éditeur pour la classe MyCat. (C’est là que vous allez écrire le code pour tous les exercices
suivants.)
Faites manger le chat quand il agit. (C’est à dire : Dans la méthode act, écrire un appel à la méthode
eat.) Compiler. Testez en appuyant sur le bouton Act dans le panneau de contrôle de l’exécution.
Exercice 1.17
Faites danser le chat. (Ne pas le faire de façon interactive - écrivez du code dans la méthode act
pour ce faire. Lorsque vous avez terminé, cliquez sur le bouton Act dans le panneau de contrôle de
l’exécution.)
Exercice 1.18
Faites dormir le chat.
Exercice 1.19
Faites exécuter à votre chat une séquence d’actions de votre choix, choisies parmi celles qui sont
disponibles.
Exercice 1.20
Changer la méthode act de votre chat afin que, lorsque vous cliquez Act, si le chat est fatigué, il
dort un peu. Si il n’est pas fatigué, il ne fait rien.
Exercice 1.21
Changer la méthode act de votre chat pour qu’il danse s’il s’ennuie. (Mais seulement s’il s’ennuie.)
Exercice 1.22
Changer la méthode act de votre chat pour qu’il mange s’il a faim.
Exercice 1.23
Modifier la méthode act de votre chat de la façon suivante : Si le chat est fatigué, il dort un peu,
et puis il crie hooray. S’il n’est pas fatigué, il crie seulement hooray. (Pour les essais, faire en sorte
que le chat soit fatigué en appelant des méthodes de manière interactive. Comment pouvez-vous
faire pour que le chat soit fatigué ?)
Exercice 1.24
Modifier le code de la méthode act de façon à obtenir le comportement suivant : Si votre chat est
seul, faites-le dormir. S’il n’est pas seul, faites le crier : hooray.
Testez en plaçant un deuxième chat dans le monde avant de lancer Act.
7
2 Le monde du crabe
Exercice 2.1
Voici le code source de la classe CrabWorld du scénario little-crab-5
import greenfoot.*; // imports Actor, World, Greenfoot, GreenfootImage
import java.util.Random;
import java.awt.Color;
public class CrabWorld extends World
{
/**
* Create the crab world (the beach). Our world has a size
* of 560x560 cells, where every cell is just 1 pixel.
*/
public CrabWorld()
{
super(560, 560, 1);
populateWorld();
}
/**
* Create the objects for the start of the game.
*/
public void populateWorld()
{
addObject(new Crab(), 300, 300);
addObject(new Lobster(), 90, 70);
addObject(new Lobster(), 390, 200);
addObject(new Lobster(), 360, 500);
addObject(new Worm(), 20, 500);
addObject(new Worm(), 30, 200);
addObject(new Worm(), 60, 90);
addObject(new Worm(), 80, 310);
addObject(new Worm(), 150, 50);
addObject(new Worm(), 210, 410);
addObject(new Worm(), 220, 520);
addObject(new Worm(), 380, 330);
addObject(new Worm(), 410, 270);
addObject(new Worm(), 530, 30);
}
}
On constate que les objets sont placés “à la main” les uns à la suite des autres. À l’aide de l’instruction
while, modifier le code ci-dessus pour placer automatiquement un crabe, trois homards et dix vers
aléatoirement sur l’écran à l’ouverture du scénario.
8
On utilisera la méthode Greenfoot.getRandomNumber(int limit). Écrire le code source de la
nouvelle méthode populateWorld.
Exercice 2.2
On a ajouté au scénario little-crab-5 une sous-classe FatWorm de la classe Worm.
On donne ci-dessous le code source de la méthode lookForWorm de la classe Crab :
/**
* Check whether we have stumbled upon a worm.
* If we have, eat it. If not, do nothing. If we have
* eaten eight worms, we win.
*/
public void lookForWorm()
{
if ( canSee(Worm.class) )
{
eat(Worm.class);
Greenfoot.playSound(“slurp.wav”);
wormsEaten = wormsEaten + 1;
if (wormsEaten == 8)
{
Greenfoot.playSound(“fanfare.wav”);
Greenfoot.stop();
}
}
}
L’appel de méthode canSee(Worm.class) retourne true si le crabe voit un objet de la classe Worm
ou de sa sous-classe FatWorm.
9Modifier la méthode lookForWorm de façon à ce que l’attribut wormsEaten soit augmenté de 2
lorsque le crabe mange un objet de la classe FatWorm, toutes choses restant égales par ailleurs.
Réécrire complètement la méthode lookForWorm ci-dessous, après lui avoir fait les modifications
nécessaires. On veillera à changer le commentaire...
103 De l’environnement intégré à la ligne de commande
Le fascicule “Introduction à la programmation orientée objet avec Greenfoot”, tiré du livre “In-
troduction to programming with Greenfoot” de Michael Kölling donne un cours d’introduction
à la programmation dans le cadre d’un environnement de programmation intégré. L’environ-
nement intégré Greenfoot fournit une fenêtre graphique, un diagramme de classes, un tableau
commande du scénario (avec des boutons Run, Act, etc.) et un éditeur de texte pour afficher et
modifier le code source d’une classe.
Nous supposons ici que l’environnement Greenfoot vous est familier et que vous avez compris
les bases de la programmation en Java qui sont exposées dans le fascicule “Introduction à la
programmation orientée objet avec Greenfoot”. Nous allons maintenant nous intéresser à un
environnement beaucoup plus basique.
Il est tout à fait possible de compiler un programme Java avec des outils plus simples, en
particulier si l’on se contente d’une interface utilisateur très limitée. Nous présentons ci-dessous
ce qu’il faut savoir au minimum pour pouvoir exécuter de petits programmes écrits en Java sur
une machine récente.
En bref, il faut un éditeur de texte (Smultron pour Mac, ou Notepad++ pour Windows, par
exemple) et un compilateur. Tant sous Windows que sous OS X, un compilateur est d’accès
facile via une fenêtre de terminal. Une fois ces deux outils réunis, on peut compiler et exécuter
de petits programmes Java.
3.1 La structure de base d’un premier programme Java
Un programme Java comporte au moins un fichier qui doit contenir au minimum une classe
Java. La fenêtre ci-dessous, copie d’écran d’une fenêtre TextMate montre le programme ne
comportant que la classe Bidon, sans aucune instruction à l’intérieur du bloc formé des accolades
qui suivent.
Notons le commentaire, ignoré par le compilateur, mais essentiel pour le programmeur !
11Nous pouvons compiler sans erreur un fichier de ce genre, pour peu qu’il ait été enregistré sous
le nom de Bidon.java. Le nom de la classe commence conventionnellement par une majuscule.
Le nom du fichier doit être identique au nom de la classe. Le code source correspondant est le
suivant :
/**
* Bidon.java - une classe vide dans un fichier texte.
* On ne peut pas faire plus simple!
*
* @version 1.0 10 juin 2010
* @author Thivent Besson
*/
public class Bidon
{
}
Supposons maintenant que, tout comme le suggère la copie d’écran plus haut, le code source
ci-dessus a été enregistré sur le disque dur de notre ordinateur. On pourra alors, à l’aide d’un
compilateur, créer un fichier Bidon.class, contenant du bytecode Java que la machine virtuelle
Java peut exécuter. Pour cela, il faut accéder au compilateur. Le paragraphe suivant présente
une introduction minimale à la ligne de commande du Mac, qui expose comment compiler un
fichier Java.
Exercice 3.1
Dans votre éditeur de texte, saisir le code source de la classe Bidon.java. Sauvegarder ce fichier texte
dans un dossier exercice 1 1, qui devra être placé dans le répertoire contenant tous vos exercices.
3.2 La ligne de commande du Mac
Sous OS X, le compilateur est installé par défaut et on y accède au moyen de la ligne de
commande du terminal Unix. Il suffit, pour accéder au compilateur, d’ouvrir une fenêtre terminal
à l’aide de l’application portant le même nom. On obtient une fenêtre qui ressemble à celle-ci :
La ligne de commande est un outil de gestion extrêmement puissant. Nous nous bornerons à
utiliser ici le compilateur Java. Pour pouvoir l’employer, il faut tout d’abord être en mesure
d’accéder au fichier contenant le code source Java. Le fichier est enregistré dans un dossier que
nous avons choisi : ici, le dossier Documents de notre session, qui contient lui-même un dossier
12exercicesJava ; dans ce dernier, nous trouvons un dossier exercice 1 1, dans lequel finalement se
trouve notre fichier Bidon.java.
Il nous faut maintenant trouver le moyen d’accéder à ce fichier depuis la ligne de commande.
Il faut savoir ici que lors de l’ouverture d’une fenêtre terminal, le répertoire courant peut être
donné par la commande pwd, autrement dit : present working directory ; les commandes de la
ligne de terminal seront très souvent de tels sigles. Voyons l’effet de la commande pwd :
Le répertoire courant est thiventbesson, sous-répertoire de Users, qui est le dossier contenant les
fichiers personnels de la session courante.
Exercice 3.2
Ouvrir une fenêtre de l’application Terminal sur votre session. Déterminer le répertoire courant et
l’ouvrir dans l’interface graphique du système d’exploitation de votre machine.
13Pour obtenir la liste des fichiers contenus dans le répertoire courant, on utilise la commande ls
et on obtient :
On voit maintenant le dossier Documents dans la liste des sous-répertoires du répertoire courant.
Il faut trouver moyen de changer de répertoire pour se trouver à l’intérieur du dossier Documents.
Pour ce faire, on utilisera la commande cd, change directory. La commande
cd Documents
aura l’effet suivant :
En utilisant à bon escient la commande cd encore deux fois, on peut se placer dans le dossier dans
lequel se trouve notre programme Bidon.java. Une vérification au moyen de la commande ls
confirme que nous nous trouvons au bon endroit.
Exercice 3.3
Ouvrir une fenêtre de l’application Terminal sur votre session. Faire en sorte que le répertoire courant
soit celui dans lequel se trouve votre fichier Bidon.java.
143.3 Compilation bidon
La compilation du fichier Bidon.java est maintenant un jeu d’enfant. Il suffit en effet d’écrire
la commande suivante :
javac Bidon.java
L’effet en est le suivant :
Apparemment, il ne s’est rien passé. La commande ls nous montre le contraire. En effet, le
compilateur a produit un fichier Bidon.class qui se trouve dans le répertoire courant.
Pour exécuter un fichier après compilation, on utilise simplement la commande java suivi du
nom du fichier sans l’extension .class. Essayons d’exécuter notre “programme” Bidon, au
moyen de la commande java Bidon.
Exercice 3.4
Compiler le fichier Bidon.java et tenter d’exécuter le fichier résultat Bidon.class avec la machine
virtuelle Java.
Nous aurions pu nous attendre à ce que l’exécution se borne à ne rien faire. Mais nous obtenons
le message d’erreur suivant :
Exception in thread "main" java.lang.NoSuchMethodError: main
Il nous faut maintenant éliminer la cause de cette erreur. C’est le sujet du paragraphe suivant.
154 Structure d’un programme Java autonome
4.1 La méthode main
Force nous est de constater que la compilation d’une classe vide ne provoque pas d’erreur,
mais que la machine virtuelle chargée de l’exécution ne trouve pas la méthode main de notre
programme. Tout programme java doit en effet comporter une méthode main chargée du fil
d’exécution principal. La syntaxe de cette méthode est la suivante :
public static void main (String[] args)
{
// Code exécutable à cet endroit
}
Exercice 4.1
Editer le fichier Bidon.java et ajouter la méthode main au bloc vide suivant la déclaration de la
classe Bidon. Compiler ce nouveau fichier et vérifier qu’il est exécuté sans erreur par la machine
virtuelle Java même s’il ne se passe rien à l’exécution.
En résumé, un programme Java minimal est formé d’une classe contenant une méthode main
comme ci-dessous.
/**
* Bidon.java - une classe contenant une méthode main vide
* le plus simple que l’on puisse faire sans erreur à l’exécution!
*
* @version 1.0 10 juin 2010
* @author Thivent Besson
*/
public class Bidon
{
public static void main (String[] args)
{
}
}
La méthode main est une méthode statique qui n’est liée à aucune instance particulière de la
classe dans laquelle elle se trouve.
Le paramètre String[] args de la méthode main permet de récupérer des arguments transmis
au programme au moment de son lancement.
Pour que le programme Bidon.java fasse vraiment quelque chose, nous allons mettre du code
source dans la méthode main.
164.2 Un tout petit premier programme
On veut écrire ici un programme qui affiche les nombres de 1 à 10, directement dans la fenêtre
de terminal.
Il suffit d’utiliser une boucle for et d’appeler la méthode println() de l’objet System.out qui
est ici la fenêtre de terminal dans laquelle nous travaillons depuis le début. Pour que la méthode
println() affiche le nombre voulu, on lui passe en paramètre le compteur i de la boucle for.
Exercice 4.2
Dans un dossier exercice 2 2, créer un fichier CompteJusquaDix.java dans lequel écrire le pro-
gramme décrit ci-dessus. Compiler et lancer le résultat dans une fenêtre terminal.
On donne ci-dessous la solution de l’exercice 2.2 :
/**
* CompteJusquaDix.java - une classe pour afficher
* les dix premiers nombres entiers
*
* @version 1.0 10 juin 2010
* @author Thivent Besson
*/
public class CompteJusquaDix
{
public static void main (String[] args)
{
for (int i = 1; i4.3 Un exemple un peu plus complexe
On donne maintenant un exemple de code un peu plus élaboré, utilisant des variables déclarées
dans la fonction main.
/**
* AfficheLogarithmes.java - une classe permettant d’afficher les
* logarithmes des puissances successives d’un nombre et de constater
* que ce sont des multiples du logarithme du nombre de départ.
*
* @version 1.0 10 juin 2010
* @author Thivent Besson
*/
public class AfficheLogarithmes
{
public static void main (String[] args)
{
int n;
double base;
double nombre;
double resultat;
n = 5;
base = 2.0;
nombre = 2.4;
System.out.println();
for (int i = 1; iExercice 4.5
En vous inspirant de l’exemple ci-dessus, par exemple, inventer un petit programme qui utilise des
variables déclarées dans la fonction main. Tester le programme en question.
4.4 Pour passer des paramètres
On aimerait bien, à ce stade, pouvoir passer en paramètre des nombres ou des chaı̂nes de
caractères à notre programme. Il suffit, pour ce faire, d’utiliser le tableau args défini dans l’en
tête de notre méthode main. Comme indiqué dans la liste des paramètres de cette méthode,
le tableau args est un tableau de chaı̂nes de caractère. Aucun problème donc pour passer
des chaı̂nes de caractères à notre programme. Mais nous aimerions récupérer des arguments
numériques. Pour ce faire, Java nous a prévu les méthodes de classe Integer.parseInt() et
Double.parseDouble(). Voici notre programme modifié :
/**
* AfficheLogAvecParam.java - une classe permettant d’afficher les
* logarithmes des puissances successives d’un nombre et de constater
* que ce sont des multiples du logarithme du nombre de départ.
*
* On doit passer trois paramètres à la méthode main
* depuis la ligne de commande: le nombre d’étapes,
* la base du log et le nombre.
*
* @version 1.0 10 juin 2010
* @author Thivent Besson
*/
public class AfficheLogAvecParam
{
public static void main (String[] args)
{
int n;
double base;
double nombre;
double resultat;
n = Integer.parseInt(args[0]);
base = Double.parseDouble(args[1]);
nombre = Double.parseDouble(args[2]);
System.out.println();
System.out.println("Les logarithmes de " + args[3]);
System.out.println();
for (int i = 1; iresultat = Math.log(Math.pow(nombre, i))/Math.log(base);
System.out.println("Le log en base "
+ base + " de " + nombre
+ " élevé à la puissance " + i
+ " vaut " + resultat);
}
resultat = Math.log(nombre)/Math.log(base);
System.out.println();
System.out.println("Ce sont les multiples de " + resultat);
System.out.println();
}
}
Pour passer les paramètres au programme on compile comme d’habitude et on appelle le pro-
gramme depuis la ligne de commande avec l’instruction suivante :
java AfficheLogAvecParam 5 2.0 3.5 "Thivent Besson"
Les paramètres sont séparés par un espace. Le premier paramètre est un entier, les deux suivants
sont des codes à virgules et le dernier est une chaı̂ne de caractère. On peut voir l’effet de cette
commande dans une fenêtre terminal :
Exercice 4.6
Modifier votre programme inventé à l’exercice précédent de sorte à ce que l’appel de la ligne de
commande puisse lui passer des valeurs en paramètre. Compiler et faire exécuter le résultat par la
machine virtuelle java, en ligne de commande, bien entendu.
On peut remarquer que notre programme ne fait quasiment pas usage du fait que Java est
un langage orienté objet. Nous nous sommes bornés à utiliser quelques méthodes de classes
prédéfinies dans Java, mais nous n’avons instancié aucun objet dont nous aurions créé la classe
nous-mêmes.
C’est normal, car l’un des buts de ce paragraphe du cours est de faire un peu de programmation
procédurale en Java, c’est à dire de la programmation qui n’utilise pas le concept d’objet et qui
produit des suites d’instructions devant être traitées séquentiellement.
Nous espérons par ce biais vous permettre d’entraı̂ner les instructions de base du langage Java.
205 Généralités sur Java
Exercice 5.1
Faire tourner un programme contenant l’instruction suivante :
System.out.println(i++);
Quel sera le nombre affiché à la console ?
Exercice 5.2
Comment peut-on connaı̂tre les paramètres à fournir pour créer un nouvel objet ? En consultant ...
a) les constructeurs
b) les méthodes
c) les packages
d) les librairies
Exercice 5.3
La méthode dont la signature est donnée ci-dessous se trouve dans la classe Math, comment faire
pour calculer le sinus de 1 radian ?
public static double sin (double angle);
a) Math m = new Math(); m.sin(1);
b) new Math().sin(1);
c) Math.sin(1);
d) Math.static.sin(1);
Exercice 5.4
Que va afficher cette instruction à la console ?
System.out.println (4 + 5 + " enfants");
a) 45 enfants
b) 9 enfants
c) 0
d) 0 enfants
Exercice 5.5
Que vaut c après l’exécution du code suivant :
int a = 41, b = 10, c;
c = a / b;
a) 4.1
b) 4
c) 0
d) 1
21Exercice 5.6 Cette déclaration private int age; est faite dans une classe Person. Où cette variable ne sera-t-elle pas visible ? a) Dans les méthodes de la classe Person b) Dans le corps de la classe Person c) Dans le code qui utilise un objet de la classe Person d) Nulle part, elle sera visible partout Exercice 5.7 Le code ci-dessous est-il correct ? int [] tab; //tableau d’entiers for(int i=0 ; i
Exercice 5.10
Que manque-t’il pour que cette déclaration de méthode compile ?
public somme (int a, int b)
{
return a + b;
}
a) Rien du tout, c’est correct
b) Il manque le type de retour
c) On ne peut pas renvoyer directement a+b, il faut créer une variable locale, y placer le résultat
de a+b puis la renvoyer
d) Il manque le modificateur private
Exercice 5.11
Étant donné la définition suivante de la classe Test, quelles méthodes données plus bas pourraient
être placées après le commentaire ?
public class Test
{
public void maMethode(int i, String s){}
//ici
}
a) public void maMethode(String s, int i)
b) public int maMethode(int i, String s)
c) public void maMethode(int i, String texte)
d) public void maDeuxiemeMethode(int i, String s)
Exercice 5.12
Pour la classe Info définie ainsi :
public class Info
{
public Info()
{
System.out.println("Groupe");
}
public Info(int i)
{
this();
System.out.println(" OCI " + i);
}
}
Qu’affichera l’instruction suivante : Info x = new Info(2); ?
23a) erreur de compilation
b) erreur d’exécution
c) Groupe OCI 2
d) OCI 2
Exercice 5.13
Soit la classe C définie ainsi :
public class C
{
public static int i;
public int j;
public C()
{
i++;
j=i;
}
}
Qu’affichera le code suivant :
C x = new C();
C y = new C();
C z = x;
System.out.println(z.i + " et " + z.j);
a) 2 et 2
b) 1 et 1
c) 2 et 1
d) 1 et 3
Exercice 5.14
Observer les classes suivantes :
public class Person
{
public void talk()
{
System.out.print("I am a Person ");
}
}
public class Student extends Person
{
public void talk()
{
24System.out.print("I am a Student ");
}
}
Quel sera le résultat du morceau de code qui suit :
public class Test
{
public static void main(String[] args)
{
Person p = new Student();
p.talk();
}
}
a) I am a Person
b) I am a Student
c) I am a Person I am a Student
d) I am a Student I am a Person
6 Quelques exercices d’entraı̂nement
Ces exercices sont tirés du livre “Apprendre à programmer avec Python 3” de Gérard Swinnen.
Pour vous aider à faire ces exercices, il vous faudra peut-être une référence résumant les éléments
du langage Java vus jusqu’ici. Le site openclassrooms offre des explications de bonne qualité
et la page Bien commencer en Java du tutoriel de programmation en java vous sera sans doute
utile. L’URL du site est :
http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-en-java
6.1 Faire calculer la machine
Exercice 6.1
Écrire un programme qui calcule le volume d’un parallélépipède rectangle dont sont fournis au départ
la largeur, la hauteur et la profondeur.
Exercice 6.2
Écrire un programme qui convertit un nombre entier de secondes fourni au départ en un nombre
d’années, de mois, de jours, de minutes et de secondes (utiliser l’opérateur modulo : %).
6.2 Instructions répétitives
Exercice 6.3
Écrire un programme qui affiche en colonne les 20 premiers termes de la table de multiplication
25par 13, en signalant au passage à l’aide d’un décalage vers la droite ceux qui sont également des
multiples de 3.
Exercice 6.4
Écrire un programme qui affiche en colonne les n premiers termes de la table de multiplication par k,
en signalant au passage à l’aide d’un décalage vers la droite ceux qui sont également des multiples
de m. Les nombres n, m et k sont des entiers.
Exercice 6.5
Écrire un programme qui calcule les 50 premiers termes de la table de multiplication par 17, mais
n’affiche que ceux qui sont des multiples de 7.
Exercice 6.6
Écrire un programme qui calcule les n premiers termes de la table de multiplication par k, mais
n’affiche que ceux qui sont des multiples de m.
Exercice 6.7
Écrire un programme qui affiche un nombre donné de lignes avec sur chaque ligne un nombre d’étoile
correspondant au numéro de la ligne.
6.3 Données numériques
Exercice 6.8
Écrire un programme qui convertit en radians un angle fourni au départ en degrés, minutes et
secondes.
Exercice 6.9
Écrire un programme qui convertit en degrés, minutes et secondes un angle fourni au départ en
radians.
Exercice 6.10
Écrire un programme qui convertit en degrés Celsius une température exprimée au départ en degrés
Farenheit, ou l’inverse. La formule de conversion s’écrit :
9
TF = TC · + 32
5
Exercice 6.11
Écrire un programme qui calcule les intérêts accumulés chaque année pendant 20 ans, par capitali-
sation d’une somme de 100 francs placée en banque au taux fixe de 2.25%.
Exercice 6.12
Une légende de l’Inde ancienne raconte que le jeu d’échecs a été inventé par un vieux sage, que
son roi voulut remercier en lui affirmant qu’il lui accorderait n’importe quel cadeau en récompense.
Le vieux sage demanda qu’on lui fournisse simplement un peu de riz pour ses vieux jours, et plus
précisément un nombre de grains de riz suffisant pour que l’on puisse en déposer un seul sur la
26première case du jeu qu’il venait d’inventer, deux sur la suivante, quatre sur la troisième, et ainsi de
suite jusqu’à la 64ème case.
Ecrire un programme Java qui affiche le nombre de grains à déposer sur chacune des 64 cases du
jeu. Calculer ce nombre de deux manières :
a) sous la forme d’un nombre entier de grains ;
b) en exprimant le nombre de grains en notation scientifique.
6.4 Données alphanumériques
Exercice 6.13
Écrire un programme qui détermine si une chaı̂ne de caractères contient ou non le caractère “e”.
Exercice 6.14
Écrire un programme qui compte de nombre d’occurrences du caractère “e” dans une chaı̂ne de
caractères.
Exercice 6.15
Écrire un programme qui recopie une chaı̂ne dans une nouvelle variable, en insérant des astérisques
entre les caractères.
Ainsi, par exemple, “gaston” devra devenir “g*a*s*t*o*n”.
Exercice 6.16
Écrire un programme qui recopie une chaı̂ne dans une nouvelle variable, en l’inversant.
Ainsi, par exemple, “zorglub” devra devenir “bulgroz”.
Exercice 6.17
En partant de l’exercice précédent, écrire un programme qui détermine si une chaı̂ne de caractères
donnée est un palindrome, c’est à dire une chaı̂ne qui peut se lire indifféremment dans les deux sens,
comme par exemple “radar” ou “sugus”.
Exercice 6.18
Écrire un programme nommé MultiConcat qui prend comme paramètres une chaı̂ne de caractères
et un entier.
Ce programme retourne la chaı̂ne de caractères passée en paramètre concaténée avec elle-même n
fois, où n est l’entier passé en paramètre.
Par exemple, si la chaı̂ne de caractères est hi et l’entier n = 4, le programme retourne hihihihi.
Ce programme retourne la chaı̂ne originale si l’entier passé en paramètre est strictement plus petit
que deux.
276.5 Pour commencer avec les tableaux
Exercice 6.19
Écrire un programme qui affiche sur une ligne tous les éléments d’un tableau.
Par exemple , le tableau déclaré comme suit :
String[] tableauDesJours = {"Lundi", "Mardi", "Mercredi", "Jeudi",
"Vendredi", "Samedi", "Dimanche"}
devrait apparaı̂tre sous la forme ci-dessous.
Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche
Exercice 6.20
Écrire un programme qui recherche le plus grand élément présent dans un tableau de nombres donné.
Par exemple, si on l’appliquait au tableau déclaré comme suit :
int[] tableauNombres = {32, 5, 12, 8, 3, 75, 2, 15}
cela nous donnerait
Le plus grand élément de la liste a la valeur 75.
Exercice 6.21
Écrire un programme qui analyse un par un tous les éléments d’un tableau de nombres pour générer
deux nouveaux tableaux. L’un contiendra les nombres pairs de la liste initiale, et l’autre les nombres
impairs.
Exercice 6.22
Écrire un programme qui analyse un par un tous les éléments d’un tableau de mots pour générer
deux nouveaux tableaux. L’un contiendra les mots comptant moins de six caractères, l’autre les mots
comptant six caractères ou davantage.
287 La programmation objet en Java
Les concepteurs de langages cherchent les moyens de faciliter la création et la maintenance du
code. Une méthode souvent retenue consiste à structurer le langage au moyen de procédures qui
sont des blocs de code effectuant une action bien précise sur des données du programme. Il est
possible de regrouper ces procédures en bibliothèques utilisables par d’autres programmeurs.
Cette façon de faire est efficace mais présente l’inconvénient de séparer le code et les données
et d’être sensible aux effets de bord. L’idée de base des langages objets, comme Java, est de
regrouper données et code en une même entité l’objet. Cette réunion données-code se nomme
encapsulation.
7.1 Classes et Objets
Une classe est une collection
— d’attributs (ou champs) contenant des valeurs ;
— de constructeurs servant à créer les objets ;
— de méthodes définissant des actions.
On peut considérer une classe comme le moule qui permet de fabriquer les objets.
Un objet est une réalisation concrète et utilisable de la classe : on dit que c’est une instance de
la classe.
new
Classe Instances
objet 1
objet 2
objet 3
Voyons comment déclarer une classe en nous inspirant de Greenfoot et du scénario little-crab.
Les attributs et les méthodes sont adaptées pour rendre l’exemple plus parlant.
public class Animal
{
}
Pour déclarer les variables constituant les attributs de la classe, nous devons choisir leur type.
Prenons par exemple le type int pour l’âge, float pour la taille et String pour la couleur.
29public class Animal
{
public int age;
public float taille;
public String couleur;
}
L’étape suivante consiste à ajouter des méthodes à notre classe. Avant de déclarer une méthode,
il faut décider si elle prend des arguments et si elle retourne une valeur :
— Le constructeur Animal() qui est une méthode, sans valeur de retour, portant le même
nom que la classe. Cette méthode est invoquée lors de la création de l’objet de la classe
Animal (opérateur new).
— La méthode move() permet à l’animal de se déplacer. Elle n’a pas besoin d’argument et
ne retourne aucune valeur.
— La méthode turn(int angle) permet à l’animal de tourner d’un angle en degré dans le
sens des aiguilles d’une montre. Elle a besoin d’un argument et ne retourne aucune valeur.
— La méthode atWorldEdge() teste si l’animal est au bord du monde. Elle n’a pas besoin
d’argument et retourne true si c’est le cas ou false sinon.
La nouvelle version de la classe Animal ressemble à ceci :
public class Animal
{
public int age;
public float taille;
public String couleur;
public Animal()
{
...
}
public void move()
{
...
}
public void turn(int angle)
{
...
}
public boolean atWorldEdge()
{
...
}
}
307.2 Une classe et ses méthodes
Nous désirons gérer des comptes bancaires. Pour cela, nous implémentons une classe Compte
avec deux attributs :
— le numéro du compte
— le solde du compte
et quatre méthodes :
— deposer
— retirer
— avoirSolde
— avoirNumero
Nous résumons cette classe sous la forme d’un schéma :
Compte
int numero
double solde
– void deposer(double montant) –
void retirer(double montant)
int avoirNumero()
double avoirSolde()
L’implémetation est relativement simple, en quelques mots :
— la méthode deposer effectue la somme du solde courant et d’un montant :
solde = solde + montant
— la méthode retirer effectue la différence entre solde courant et d’un montant :
solde = solde - montant
— la méthode avoirNumero retourne le numéro du compte
— la méthode avoirSolde retourne le solde du compte
Voici l’implémentation de la classe Compte.
public class Compte
{
public int numero;
public double solde;
/**
* Déposer un montant sur le compte
*/
public void deposer(double montant)
{
31solde = solde + montant;
}
/**
* Retirer un montant du compte
*/
public void retirer(double montant)
{
solde = solde - montant;
}
/**
* Retourne le numero du compte
*/
public int avoirNumero()
{
return numero;
}
/**
* Retourne le solde du compte
*/
public double avoirSolde()
{
return solde;
}
}
Créons un compte bancaire Compte monCompte. Créons une classe Banque pour tester le tout
dans la méthode main :
class Banque
{
public static void main (String arg[])
{
Compte monCompte;
monCompte = new Compte();
System.out.println("****************");
System.out.println("Création d’un nouveau compte");
System.out.println(monCompte.numero);
System.out.println(monCompte.solde);
}
}
32Remarque
La déclaration Compte monCompte ne réserve pas d’emplacement pour un objet de type Compte,
mais seulement un emplacement pour une référence à un objet de type Compte. L’emplacement
pour l’objet proprement dit sera alloué sur une demande explicite du programme, en faisant
appel à l’opérateur new.
Ainsi l’expression :
new Compte() // attention à la présence des parenthèses
crée un emplacement pour un objet de type Compte et fournit sa référence en résultat.
Voici l’exécution du programme Banque :
La classe Compte ne contient pas de constructeur. La définition de cette méthode n’est pas
obligatoire dans la mesure où un constructeur par défaut (appelé parfois constructeur sans
argument) est défini par le compilateur Java si la classe n’en possède pas.
La création de l’objet (instance) attribue une valeur par défaut à chaque variable d’instance,
qu’elle soit d’un type primitif (dans notre cas : 0 pour la variable numero et 0.0 pour la variable
solde) ou de référence (sa valeur est alors null).
Modifions la classe Banque.
class Banque
{
public static void main (String arg[])
{
Compte monCompte;
monCompte = new Compte();
System.out.println("****************");
System.out.println("Création d’un nouveau compte");
monCompte.numero=200; // Affectation d’un numéro de compte
monCompte.solde=1535.75; // Affectation d’un solde au compte
System.out.println(monCompte.numero);
System.out.println(monCompte.solde);
monCompte.deposer(300.0);
33System.out.println("Le numéro de monCompte est : "+monCompte.avoirNumero());
System.out.println("Le solde de monCompte est : "+monCompte.avoirSolde());
}
}
L’instruction monCompte.numero=200 attribue un numéro de compte, tandis que l’instruction
monCompte.deposer(300.0) ajoute le nombre à virgule 300.0 au solde du compte (appel de
méthode).
Voici l’exécution du nouveau programme Banque :
Utilisation des objets
Accès aux données
La référence à une donnée définie dans une classe d’objet a pour syntaxe :
nomObjet . nomAttribut
Le point marque la séparation entre le nom de l’objet et le nom de la méthode de cet objet.
Accès aux méthodes
Quand on applique les méthodes aux objets, on dit qu’on envoie des messages aux objets.
Cela s’écrit ainsi :
nomObjet . nomMéthode()
7.3 La notion de constructeur
Dans l’exemple Compte, le compilateur utilise un constructeur par défaut.
Nous souhaitons définir immédiatement le numéro et le solde du compte dès sa création. Pour
cela nous avons besoins d’un constructeur.
Voici un exemple de constructeur :
public Compte(int a, double b)
{
numero=a;
solde=b;
}
34Dés lors les instructions
Compte monCompte;
monCompte = new monCompte(300 , 235.75);
initialise le compte monCompte avec le numéro 300 et un solde égal à 235.75.
Voici quelques règles à suivre concernant les constructeurs :
— un constructeur doit toujours être une méthode publique
— vous devez impérativement donner le même nom que votre classe au constructeur
— un constructeur ne retourne rien, c’est à dire que vous n’ajouterez pas de return dans
cette méthode
— vous ne devez pas mettre de void, même si le constructeur ne retourne rien
7.4 L’accessibilité aux attributs d’une classe
Dans l’introduction de ce chapitre, nous avons parlé d’encapsulation. L’encapsulation est
un mécanisme consistant à rassembler les données (les arguments) et les méthodes au sein
d’une structure en cachant l’implémentation de l’objet, c’est-à-dire en empêchant l’accès aux
données par un autre moyen que les services proposés. L’encapsulation permet donc de garantir
l’intégrité des données contenues dans l’objet.
L’encapsulation permet de définir des niveaux de visibilité des éléments de la classe. Ces niveaux
de visibilité définissent les droits d’accès aux données selon que l’on y accède par une méthode
de la classe elle-même, d’une classe héritière, ou bien d’une classe quelconque. Il existe trois
niveaux de visibilité :
— publique : les fonctions de toutes les classes peuvent accéder aux données ou aux
méthodes d’une classe définie avec le niveau de visibilité public. Il s’agit du plus bas
niveau de protection des données
— protégée : l’accès aux données est réservé aux fonctions des classes héritières, c’est-à-dire
par les fonctions membres de la classe ainsi que des classes dérivées
— privée : l’accès aux données est limité aux méthodes de la classe elle-même. Il s’agit du
niveau de protection des données le plus élevé
Dans la classe Compte définies au point 4.2, les attributs sont publiques. En les déclarant privés,
l’accès à ces attributs avec une expression monCompte.numero=200 n’est plus possible.
Voyons cela avec un exemple plus simple.
public class Test
{
private int x;
}
Créons une instance de Test et essayons d’accéder à l’attribut x. Voici une classe TestX qui
montre le résultat :
35class TestX
{
public static void main (String arg[])
{
Test test;
test = new Test();
System.out.println("****************");
System.out.println(test.x);
}
}
Nous obtenons une erreur de compilation, comme le montre la fenêtre ci-dessous :
Pour accéder ou modifier des attributs déclarés privés, on crée des méthodes nommées accesseurs
ou mutateurs.
7.4.1 La notion d’accesseur
Un accesseur est une méthode permettant de récupérer le contenu d’une donnée membre
protégée. Un accesseur, pour accomplir sa fonction :
— doit avoir comme type de retour le type de la variable à renvoyer
— ne doit pas nécessairement posséder d’arguments
Une convention de nommage veut que l’on fasse commencer de façon préférentielle le nom de
l’accesseur par le préfixe get, afin de faire ressortir sa fonction première.
La syntaxe d’un accesseur réduit à sa plus simple expression ressemble donc à ceci :
public class Test
{
private int x;
public int getX()
{
return x;
}
}
367.4.2 La notion de mutateur
Un mutateur est une méthode permettant de modifier le contenu d’une donnée membre
protégée. Un mutateur, pour accomplir sa fonction :
— doit avoir comme paramètre la valeur à assigner à la donnée membre. Le paramètre doit
donc être du type de la donnée membre
— ne doit pas nécessairement renvoyer de valeur (il possède dans sa plus simple expression
le type void)
Une convention de nommage veut que l’on fasse commencer de façon préférentielle le nom du
mutateur par le préfixe set.
La syntaxe d’un mutateur réduit à sa plus simple expression ressemble donc à ceci :
public class Test
{
private int x;
public void setX (int a)
{
x = a;
}
}
7.4.3 Les attributs statiques
Un attribut statique est un attribut qui est commun à tous les objets que vous pourrez créer. On
peut par exemple citer un compteur du nombres d’instances de classe que vous aurez lancées. Si
vous souhaitez compter le nombre de fois où vous avez instancié la classe ”Test” vous pourrez
écrire ceci :
public class Test2
{
public static int nombre=0;
public Test2() // Constructeur
{
nombre=nombre+1;
System.out.println("Nombre d’instances créées : " + nombre);
}
}
En testant cette classe :
class TestX2
37{
public static void main (String arg[])
{
System.out.println("****************");
Test2 test1 = new Test2();
Test2 test2 = new Test2();
Test2 test3 = new Test2();
}
}
Nous obtenons :
7.5 L’héritage
7.5.1 Introduction
L’avantage essentiel d’un langage orienté-objet est que le code est réutilisable. Grâce à l’héritage,
on peut faire dériver une nouvelle classe d’une classe existante et ainsi en récupérer les attributs
et méthodes, sans avoir à la réécrire complètement.
Nous avons rencontré la notion d’héritage dans Greenfoot.
Diagramme de classes dans Greenfoot
Dans ce scénario :
— la classe Animal est une sous-classe de la classe Actor
— la classe Actor est une super-classe de la classe Animal
38— les classes Crab, Worm et Lobster sont des sous-classes de la classe Animal
Si Enfant est une sous-classe de Parent, on dit que la classe Enfant hérite de la classe
Parent, qu’elle étend cette ancienne classe.
Enfant est alors une sous-classe de Parent.
Parent est une super-classe de Enfant.
Toujours dans Greenfoot, nous avons la classe Animal :
public class Animal
{
private int age;
private float taille;
private String couleur;
public Animal() { ... }
public void move() { ... }
public void act() { ... }
public void turn(int angle) { ... }
public boolean atWorldEdge() { ... }
}
et la classe Crab qui est une sous-classe de la classe Animal :
public class Crab extends Animal
{
private GreenfootImage image1;
private GreenfootImage image2;
private int wormsEaten;
public Crab() { ... }
public void act() { ... }
public void switchImage() { ... }
public void checkKeypress() { ... }
public boolean lookForWorm() { ... }
}
La classe Crab peut accéder à toutes les méthodes publiques de la classe Animal. Dans la classe
Crab, la méthode act() est redéfinie. Cela permet de redéfinir une méthode de la super-classe
39Animal, en proposant une nouvelle définition. Il faut respecter la signature de la méthode (type
des arguments), ainsi que le type de valeurs de retour. C’est alors cette nouvelle méthode qui
sera appelée sur tout objet de la sous-classe, masquant en quelque sorte la méthode de la classe
de base.
Une sous-classe reprend toutes les propriétés et méthodes de la super-classe, tout en pouvant
intégrer de champs nouveaux (attributs et méthodes). Ceux-ci caractériseront et distingue-
ront les objets de la classe héritée des objets de la classe parent. Autrement dit, cela signifie
qu’une instance de la classe Enfant aura la possibilité d’utiliser, outre des attributs et méthodes
supplémentaires, toutes les ressources définies dans Parent, si des modificateurs ne l’empêche
pas. Une méthode d’une classe Enfant n’a pas accès aux membres privés de sa classe Parent.
Si c’était le cas, il suffirait de créer une classe Enfant pour violer le principe d’encapsulation.
En Java, toutes les classes sont dérivées de la classe spéciale Object. C’est la racine de la
hiérarchie des classes (cela entraine que toute classe Java possède déjà à sa naissance un certain
nombre de variables et de méthodes).
Dans la déclaration d’une classe si la clause extends n’est pas présente, la surclasse est donc
Object directement.
7.5.2 Un exemple complet
Considérons un exemple complet d’une classe Parent Ville et d’une classe Enfant Capitale.
Ville
String nom
int nbHab
Ville(String leNom)
Ville (String leNom, int leNbHab)
String getNom()
int getNbHab()
void setNbHab(int nvNbHab)
String presenteToi()
Capitale
String pays
Capitale(String leNom, String lePays)
Capitale(String leNom, String lePays, int leNbHab)
String getPays
void setPays(String nomPays)
String presenteToi()
Voici l’implémentation de la classe Ville :
class Ville
40{
//le nom ne sera accessible que par la classe Ville, et pas par la classe Capitale
private String nom;
//le nombre d’habitant sera accessible par la classe Capitale
protected int nbHab;
public Ville(String leNom)
{
nom = leNom.toUpperCase( );//ainsi tous le noms de ville seront en majuscule
nbHab = -1; //-1 signifie que le nombre d’habitant est inconnu
}
public Ville (String leNom, int leNbHab)
{
nom = leNom.toUpperCase( );
if (leNbHab< 0)
{
System.out.println("Un nombre d’habitant doit e
^tre positif.");
nbHab = -1;
}
else
{
nbHab = leNbHab;
}
}
public String getNom( )
{
return nom;
}
//pas d’accesseur en écriture pour le nom
//donc il est impossible de changer le nom d’une ville
public int getNbHab( )
{
return nbHab;
}
public void setNbHab(int nvNbHab)
{
if (nvNbHab < 0)
{
System.out.println("Un nombre d’habitant doit e^tre positif.");
System.out.println("La modification n’a pas été prise en compte);
}
else
{
nbHab = nvNbHab;
}
41}
public String presenteToi()
{
String presente = "Ville "+ nom +" nombre d’habitants ";
if (nbHab == -1)
{
presente = presente + "inconnu";
}
else
{
presente = presente + " = " + nbHab;
}
return presente;
}
}
Et voici l’implémentation de la classe Capitale :
public class Capitale extends Ville
{
private String pays; //constructeurs public
Capitale(String leNom, String lePays)
{
super(leNom); //appel du constructeur de Ville
//nbHab est initialisé à {1 par ce constructeur
pays = lePays;
}
public Capitale(String leNom, String lePays, int leNbHab)
{
super(leNom, leNbHab);
pays = lePays;
}
//accesseurs supplémentaires
public String getPays( )
{
return pays;
}
public void setPays(String nomPays)
{
pays = nomPays;
}
//méthode presenteToi( ) redéfinie
42public String presenteToi( )
{
String presente = super.presenteToi( );
presente = presente + " Capitale de "+ pays;
return presente;
}
}
Pour tester ces deux classes, créons une classe TestVille :
public class TestVille
{
public static void main(String args[])
{
Ville v1 = new Ville("Lausanne", 1500000);
Ville v2 = new Ville("Vevey");
Capitale c1 = new Capitale("Paris", "France", 10000000);
Capitale c2 = new Capitale("Berne", "Suisse");
System.out.println("******************************");
System.out.println(v1.presenteToi( ));
System.out.println(v2.presenteToi( ));
System.out.println(c1.presenteToi( ));
System.out.println(c2.presenteToi( ));
System.out.println("******************************");
}
}
Finalement, l’exécution de ce dernier programme donne :
8 Exercices sur les objets en java
8.1 Figures géométriques
Exercice 8.1
Écrire une classe Rectangle avec deux champs longueur et largeur, avec un constructeur et
43avec les méthodes aire, perimetre et description (qui donne les caractéristiques du rectangle :
longueur, largeur, aire et périmètre).
Rectangle
int longueur
int largeur
– Rectangle(int x,int y) –
int aire()
int perimetre()
String description()
Exercice 8.2
Écrire une sous-classe Carre de la classe Rectangle.
Carre
– –
Carre(int c)
Exercice 8.3
Créer une méthode dessineRectangle de la classe Rectangle qui dessine sommairement le rec-
tangle à l’aide d’étoiles.
Créer ensuite une méthode main de la classe Rectangle telle que suite au lancement du programme,
on obtient la description et le dessin d’un carré si un seul argument (côté) est donné et d’un rectangle
si deux arguments (longueur, largeur) sont fournis.
Exercice 8.4
Écrire une classe représentant des cercles. Cette classe contient deux constructeurs :
a) Cercle() sans argument qui crée un cercle dont le rayon est égal à 1
44b) Cercle(double r) avec un argument qui crée un cercle de rayon r
Écrire les méthodes suivantes de la classe Cercle.
a) pour calculer l’aire
b) pour calculer le périmètre
c) pour obtenir le rayon
d) pour modifier le rayon d’un cercle déjà créé
e) pour donner les caractéristiques (rayon et aire) du cercle
Exercice 8.5
On peut considérer qu’un cylindre est un cercle dont la hauteur est donnée. Construire une classe
Cylindre qui dérive de la classe Cercle.
Créer un constructeur Cylindre() sans argument qui crée un cylindre dont le rayon du cercle de
base est égal à 1 et dont la hauteur est égale à 5 et un constructeur Cylindre(double r, double
h) qui crée un cylindre dont le rayon du cercle de base est r et dont la hauteur est h.
Écrire les méthodes qui calculent le volume et l’aire totale d’un cylindre, ainsi que la méthode qui
donne les caractéristiques (rayon, aire totale et volume) du cylindre
Formules : volume = π · r 2 · h et aire totale = 2 π r · (r + h)
Exercice 8.6
Créer une méthode main de la classe Cercle telle que suite au lancement du programme, on obtient
la description d’un cercle si un seul argument (rayon) est donné et d’un cylindre si deux arguments
(rayon, hauteur) sont fournis.
8.2 La citerne
Exercice 8.7
Il s’agit de développer une classe simulant une citerne d’eau potable. Développez la classe Citerne
qui possède les propriétés et fonctionnalités suivantes :
a) une citerne possède un volume maximal de 1000 litres,
b) une citerne a un volume d’eau actuel,
c) on peut ajouter de l’eau à la citerne (attention au volume maximal)
d) on peut retirer de l’eau de la citerne (attention au retrait maximal possible)
e) la citerne renseigne à l’aide d’un indicateur sur son volume actuel,
f) la citerne possède aussi un indicateur affichant le taux de remplissage en pourcents.
Ajouter un constructeur Citerne() sans argument qui permet de créer une citerne de 1000 litres
vide et une méthode main qui simule quelques remplissages et retraits aléatoires successifs.
Exercice 8.8
Modifiez votre classe Citerne en CiterneBis. Cette nouvelle version ne possède plus un volume
maximal fixe de 1000 litres.
Transformer le constructeur Citerne en un constructeur CiterneBis(double rayon, double
hauteur) qui permet de créer des citernes à volume variable selon leurs dimensions extérieures.
45Vous pouvez aussi lire
