Département d’informatique et d’ingéniérie

INF1563 Programmation I Automne 2019

Examen intra #2
Durée : 3h00
Aucun document autorisé

Nom de l’étudiant(e) : ……………Corrigé………………………………….

Code permanent : ………………………………………………………………………….

Consignes:

1. Cet examen comporte 18 pages et 7 exercices: vérifiez que votre exemplaire est
complet.
2. Écrivez votre nom sur cette feuille. Écrivez vos réponses aux questions sur le sujet,
dans les espaces prévus.
3. L’examen porte sur les unités 1 à 4 du cours, qui seront chacunes notées satisfaisant
(S) ou échec (E). Une note S pour une unité rapporte des points pour la note finale
du cours, selon le barème suivant
- (1) Bases de la programmation impérative : 30 points
- (2) Algorithmique de base avec contrôle de flux : 25 points,
- (3) Tableaux et algorithmique : 20 points
- (4) Programmation Orientée Objet : 15 points
4. Une note E sur une unité ne rapporte aucun point. L’examen final donnera une autre
opportunité de valider toutes les unités.
5. Les étudiant.e.s ayant déjà obtenu une note S sur une ou plusieurs unités ne doivent
pas traiter les questions se rapportant à ces unités.
6. Lisez le sujet en entier avant de commencer.
7. Les questions ne seront pas expliquées pendant l’examen.
8. Si vous avez un doute sur comment interpréter une question, faites une hypothèse
raisonnable, et notez quelle est votre hypothèse. Mais relisez bien l’énoncé avant,
et ne faites pas d’hypothèses qui contredisent l’énoncé ou les exemples donnés.
9. Écrivez votre code Java tel qu’il serait sur un ordinateur: en particulier, utilisez *
pour une multiplication, et n’écrivez pas des fractions avec des lignes horizontales.
!"#$
Par exemple, au lieu de ! , vous devez écrire (2*a + b) / 2.
10. Des feuilles blanches de brouillon vous seront fournies sur demande.
11. Les deux dernières pages du sujet comportent des exemples de code Java vus en
cours afin de vous rappeler la syntaxe des différentes instructions.
page 1/19
Exercice 1 : Types et Expressions (unité 1)
Pour tout cet exercice, on supposera que :
- x est une variable de type int dont la valeur est 3,
- y est une variable de type double dont la valeur est 1.5
- la méthode cube est définie comme suit:
public static int cube(int z){
return z*z*z;
}
1.1 – Pour chacune des expressions java suivantes, donner le type et la valeur du résultat.
Si l’expression n’est pas valide, indiquer “non” dans la première colonne et laisser les autres
vides.
Expression Valide? Type Valeur
cube(1) – 2 oui int -1
3.0 + x oui double 6.0
4 / (int)(y * 3) oui int 1
10%2 + 6 + "cube" oui String "6cube"
0 || (cube(0) * 5) non
"f" + cube + 2 non
cube(2*x - 4) oui int 8

1.2 – Donner la valeur de l’expression booléenne suivante, en détaillant le calcul à l’aide

d’un "arbre" :
( (x % 2 ==0) && ( x > 0) ) || ! (y > x)
------ ----- -----
1 | true false
---------- ---------
false | true
------------------------------
false |
------------------------------------------
true

page 2/19
Exercice 2 : Fonctions (unité 1)
Dans cet exercice on va écrire un programme qui calcule le BMI (body-mass index) d’une
personne à partir de son poids et de sa taille, qu’elle entre au clavier.
Le BMI est un indice qui permet de déterminer si le poids corporel d’une personne est sain,
et se calcule comme suit :
𝑝𝑜𝑖𝑑𝑠 𝑒𝑛 𝑘𝑔
𝐵𝑀𝐼 =
(𝑡𝑎𝑖𝑙𝑙𝑒 𝑒𝑛 𝑚)!
Un exemple d’utilisation du programme est donnée ci-dessous (les valeurs utilisées sont un
exemple de ce que pourrait entrer l’utilisateur; le programme doit fonctionner pour n’im-
porte quelles valeurs):
Entrez votre taille, en pieds/pouces.
Nombre de pieds:
5
Nombre de pouces:
9
Entrez votre poids en livres:
165
Votre BMI est:24.36

Ce programme est à implémenter dans la classe CalculBMI, ci-dessous et page suivante.

Vous devez compléter l’implémentation des trois méthodes lbVersKg,
piedsPoucesVersMetres, et main, en utilisant les spécifications données.

import java.util.Scanner;

public class CalculBMI{

/* Méthode lbverskg : prend en entrée un poids en livres (de type
int) et retourne l’équivalent en kilogrammes (de type double).
Conversion : 1kg lb = 0.454 kg. */

public static …double…… lbVersKg(…………int livres……………………………………){

……………………………………………… double poidskg = livres * 0.454; ……………………………………………

……………………………………………… return poidskg; …………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

page 3/19
/* Méthode piedsPoucesVersMetres : prend en entrée une longueur en
pieds et pouces (deux paramètres de type int) et retourne l’équivalent
en mètres (type double). Conversion: 1 pied = 0.3048m; 1 pouce = 0.0254m
*/
public static double piedsPoucesVersMetres(…int pieds, int pouces…){

… return pieds*0.3048 + pouces * 0.0254;………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
}
/*Méthode main : l’utilisateur entre sa taille et son poids dans les
unités impériales; ces valeurs sont converties en kg et mètres en
utilisant les méthodes ci-dessus. Le BMI est calculé et affiché avec
deux chiffres après la virgule. (utiliser printf avec le code de for-
matage %.2f).*/
public static void main(String[] args){
Scanner clavier = new Scanner(System.in);

…………System.out.println("Entrez votre taille en pieds/pouces"); ………………………………

……… System.out.println("Nombre de pieds :"); …………………………………………………………………………

……… int feet = clavier.nextInt(); …………………………………………………………………………………………………………

……… System.out.println("Nombre de pouces :"); ……………………………………………………………………

……… int inches = clavier.nextInt(); …………………………………………………………………………………………………………

……… System.out.println("Entrez votre poids en livres "); ………………………………………………

……… int livres = clavier.nextInt(); …………………………………………………………………………………………………………

……… double poidsKg = lbVersKg(livres); ……………………………………………………………………………………

……… double taillem = piedsPoucesVersMetres(feet, inches); ……………………………………

……… double bmi = poidsKg / (taillem * taillem); …………………………………………………………………………

……… System.out.printf("Votre BMI est %.2f", bmi); ………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
page 4/19
………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
Exercice 3 : Contrôle de flux (unité 2)
On exécute le programme suivant :
int i=10;
while(i>0) {
int d1 = i/2;
int d2 = 5-d1;
for(int j=1; j<=d2; j++)
System.out.print(" ");
for(int j=1; j<=d1; j++)
System.out.print("\\");
for(int j=1; j<=d1; j++)
System.out.print("/");
System.out.println();
i = i-2;
} <- cette accolade manquait

Écrire dans le cadre ci-dessous le texte qui s’affiche à l’écran durant toute l’exécution du
programme (c’est un dessin ASCII).
Indications :
- L’instruction System.out.print("\\") affiche une seule barre oblique \ , elle
est doublée parce que c’est un caractère spécial.
- L’instruction System.out.println() n’affiche rien, mais revient à la ligne.
- Les caractères affichés à la console java ont tous la même largeur, y compris les
espaces.

\\\\\/////……………(i=10, d1=5, d2=0) …………………………………………………………………………………………………………

\\\\////…………… (i=8, d1=4, d2=1) …………………………………………………………………………………………………………

\\\///…………………(i=6, d1=3, d2=2) ………………………………………………………………………………………………………

\\//……………………(i=4, d1=2, d2=3)……………………………………………………………………………………………………………

\/………………………(i=2, d1=1, d2=4)………………………………………………………………………………………………………………

…………………………………………(i==0 la boucle while se termine) …………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
page 5/19
Exercice 4 : Contrôle de flux (unité 2)
Le but de cet exercice est d’écrire un programme qui affiche tous les nombres dans l’inter-
section de deux intervalles d’entiers, c’est-à-dire les nombres communs aux deux inter-
valles.
Par exemple, l’intersection des intervalles [-2; 9] et [6; 14] est l’intervalle [6; 9], contenant
les entiers 6, 7, 8, 9, et l’intersection des intervalles [67, 90] et [34, 39] est vide.

Le programme doit implémenter la procédure suivante :

L’utilisateur est invité à entrer au clavier les bornes des deux intervalles, puis le programme
affiche la liste des nombres dans l’intersection des deux intervalles. Si l’intervalle est vide,
alors le programme affiche le message « L’intervalle est vide. ».
Un exemple d’utilisation est donné ci-dessous :
Entrez les bornes du premier intervalle:
-2
9
Entrez les bornes du deuxième intervalle:
6
14
L’intervalle contient :
6
7
8
9

Le début du programme est donné page suivante.

Compléter le programme pour implémenter la procédure demandée.

Indications:
- On pourra supposer que pour chaque intervalle, les bornes sont données dans
l’ordre, c’est-à-dire n1<=n2 et n3<=n4.
- On ne fait aucune supposition sur l’ordre des intervalles.
- Si elle n’est pas vide, l’intersection est un intervalle. Trouver d’abord son premier
et dernier élément, puis parcourir cet intervalle à l’aide d’une boucle et afficher les
nombres qu’il contient à l’aide d’instructions System.out.println().

page 6/19
Scanner clavier = new Scanner(System.in);
System.out.println("Entrez les bornes du premier intervalle:");
int n1 = clavier.nextInt();
int n2 = clavier.nextInt();
System.out.println("Entrez les bornes du deuxième intervalle:");
int n3 = clavier.nextInt();
int n4 = clavier.nextInt();
………………………………………………………………………………………………………………………………………………………………………………………………………

………………… int borneinf, bornesup; …………………………………………………………………………………………………………………

…………………if (n1<n3) …………………………………………………………………………………………………………………

…………………… borneinf = n3; …………………………………………………………………………………………………………………

…………………else ………………………………………………………………………………………………………………………………………………………………

…………………… borneinf = n1; ………………………………………………………………………………………………………………………………

…………………if (n2<n4) ……………………………………………………………………………………………………………………………………………

…………………… bornesup = n2; ………………………………………………………………………………………………………………………………

…………………else …………………………………………………………………………………………………………………………………………………………

…………………… bornesup = n4; ………………………………………………………………………………………………………………………………

…………………if (bornesup<borneinf) { ……………………………………………………………………………………………………………………

…………………………… System.out.println("l’intervalle est vide"); …………………………………………

………………… } else { ………………………………………………………………………………………………………………………………………………………

…………………………… System.out.println("l’intervalle contient :"); …………………………………………

……………………………………………for (int i = borneinf; i<=bornesup;i++) ………………………………………………

…………………………………………………… System.out.println(i); …………………………………………………………………………………

…………………………… } …………………………………………………………………………………………………………………………………………………………………

………………………………(d’autres solutions existent) ………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
page 7/19
………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
Exercice 5 : Tableaux et algorithmique (unité 3)
Dans cet exercice on va écrire un programme pour calculer la monnaie qui doit être rendue
à un client dans une machine distributrice. Plus précisément, le programme prend en entrée
le montant à rendre, et calcule quelles pièces doivent être données. Les pièces doivent être
choisies dans la liste des pièces en circulation au Canada, représentées par le tableau {2, 1,
0.25, 0.1, 0.05}.
Par exemple, si la machine doit rendre $1.50, alors le programme doit calculer que la mon-
naie sera une pièce de $1 et deux pièces de $0.25, représentées par le tableau {1, 0.25,
0.25}.
Pour résoudre ce problème, on va utiliser la technique récursive suivante : on commence
par choisir la plus grande pièce qu’on puisse rendre, puis on calcule le montant restant
(après avoir rendu cette pièce). Dans notre exemple, la plus grande pièce qu’on peut utiliser
est $1, et le restant sera $0.50. On doit maintenant choisir des pièces pour obtenir ce nou-
veau montant plus petit: c’est notre problème de départ, et on peut donc récursivement
appliquer la technique, et ceci jusqu’à ce que le montant à rendre atteigne 0.
On va décomposer cette technique en trois méthodes séparées, qui sont l’objet des questions
de cet exercice.
5.1 – La première méthode détermine quelle est la première pièce à choisir pour faire un
montant de monnaie donné .
Écrire une méthode premierePiece qui prend en paramètre une valeur montant de type
double, et retourne la valeur de la plus grande pièce inférieure ou égale à ce montant.
On pourra utiliser le tableau piecesDisponibles qui donne la liste des pièces possible
en ordre décroissant (voir code).
Note : on supposera que tous les types de pièces sont toujours disponibles
public static double premierePiece(double montant){
double [] piecesDisponibles = {2, 1, 0.25, 0.1, 0.05};

……………………………… int i=0; ……………………………………………………………………………………………………………………………

…………………………… while (piecesDisponibles[i]>montant) …………………………………………………………

………………………………………… i+=1; ………………………………………………………………………………………………………………………………………

…………………………… return piecesDisponible[i]; …………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

…………………………(cette solution suppose que montant est au moins égal à 0.05) ………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
page 8/19
}
5.2 – Une des difficultés sera de mettre les pièces obtenues ensemble dans un tableau, dont
on ne connait pas initialement la longueur. Pour ceci on va écrire une méthode pour ajouter
un élément à un tableau.
Écrire une méthode faireListe qui prend en entrée une valeur e et un tableau tab (avec
k éléments) et renvoie un nouveau tableau de k+1 éléments, qui contient en première posi-
tion la valeur e, suivie des k éléments de tab.
public static double [] faireListe(double e, double[] tab){

……………………… double [] tableau = new double [tab.length+1]; ……………………………………

……………………… tableau [0] = e; ……………………………………………………………………………………………………………………………

……………………… for (int i = 1; i<=tab.length;i++) {………………………………………………………………………………

……………………………… tableau [i] = tab[i-1]; …………………………………………………………………………………………………………

………………………… } …………………………………………………………………………………………………………………………………………………………………

…………………………… return tableau;……………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
5.3 – On va maintenant écrire notre méthode principale faireMonnaie qui prend en entrée
………………………………………………………………………………………………………………………………………………………………………………………………………
un montant de monnaie à préparer, et retourne un tableau contenant les pièces nécessaires.
Exemple : faireMonnaie(1.50) doit retourner le tableau {1, 0.25, 0.25}.
………………………………………………………………………………………………………………………………………………………………………………………………………
}
Indications : La fonction faireMonnaie doit être récursive :
- Le cas de base est quand le montant est égal à zéro : on peut alors renvoyer un
tableau vide (un nouveau tableau de longueur zéro).
- Pour le cas récursif, on choisit la première pièce à utiliser (à l’aide la méthode
premierePiece), on détermine le montant restant, et on calcule récursivement les
pièces pour ce nouveau montant. Enfin, on ajoute la première pièce à celles qui
donnent le montant restant (en utilisant la méthode faireListe).
Note : On supposera que le montant donné est toujours réalisable de façon exacte (c’est-à-
dire que le montant est multiple de $0.05).

page 9/19
public static double [] faireMonnaie(double montant){

…………………………………………………………………………………………………………………………………………………………………………………………………………

…………………… if (montant==0) …………………………//cas de base…………………………………………………………………

…………………………… return new double[0]; …………………………………………………………………………………………………………

…………………… double piece1 = premierePiece(montant); …………………………………………………………………

…………………… double [] autresPieces = faireMonnaie(montant – piece1); ………………………

……………………… return faireListe(piece1, autresPieces); …………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………………………………………………………………………………………………………………

page 10/19
Exercice 6 : Programmation orientée objet (unité 4)
Pour chacune de ces questions de cours, entourer la bonne réponse. On suppose qu’on a
défini une classe Forme et une classe Cercle qui hérite de la classe Forme.
6.1 Dans la classe Cercle on définit une méthode public String couleur().
Parmi les options suivantes pour invoquer la méthode, laquelle (ou lesquelles) est valide?
(a) String s = Cercle.couleur();
(b) Cercle c = new Cercle();
String s = c.couleur();
(c) Les deux.

6.2 L’instruction Forme f = new Cercle(); est-elle valide ?

(a) oui
(b) non

6.3 L’instruction Cercle c = new Forme (); est-elle valide ?

(a) oui
(b) non

6.4 Dans une méthode non-statique, le nom de variable qui se réfère à l’objet sur lequel le
code est exécuté est :
(a) self
(b) this
(c) object
(d) instance

6.5 Toutes les classes héritent directement ou indirectement de la classe Object:

(a) vrai
(b) faux

6.6 On n’a pas défini de méthode public String toString() dans la classe Cercle
ni dans la classe Forme. Le code suivant causera une erreur de compilation:
Cercle c = new Cercle; <- Il manquait des parenthèses
System.out.println(c.toString()); (erreur de ma part)
(a) vrai (à cause des parenthèses)
(b) faux (faux si les parenthèses étaient là : toString() est bien définie
dans la super-classe Object)
6.7 On définit une méthode public static void agrandir(Cercle c).
La méthode agrandir()peut modifier l’objet passé en paramètre:
(a) vrai
(b) faux
page 11/19
Exercice 7 : Programmation orientée objet (unité 4)
Dans cet exercice, on va écrire un programme pour contrôler des robots : le code est une
partie de leur système embarqué (fictif).
La classe Robot modélise l'état et le comportement des robots. Chaque robot correspond à
un objet qui est une instance de cette classe.
Chaque robot a les attributs suivants:
- un nom (attribut nom de type String)
- une orientation, donnée par l'attribut orientation qui est du type énuméré Di-
rection. Ce type énuméré (fourni) a quatre valeurs possibles Direction.NORD,
Direction.EST, Direction.SUD et Direction.OUEST.
- des coordonnées entières (type int) x et y.
x augmente en allant vers l'Est et y augmente en allant vers le Nord.
Il y a un seul constructeur, qui prend en paramètre le nom, la position et l’orientation d'un
robot.
Les méthodes de la classe Robot sont les suivantes :
- Une méthode void avance() qui déplace le Robot d’un pas en avant, soit 5 unités
selon les coordonnées x ou y, dans la direction où le robot est orienté.
- Une méthode void tourne(Direction dir) qui tourne le robot dans la direc-
tion donnée en paramètre.

7.1 – Implémenter la classe Robot dans le cadre ci-dessous et page suivante.

- Inclure les attributs, le constructeur, et les deux méthodes spécifiées.
- Définir la visibilité des attributs et méthodes selon les bonnes pratiques respectant
le principe d’encapsulation.
- Ajouter une méthode public static void main(String[] args)qui crée
un nouveau robot appelé « Bob », placé en (0,0) face au Nord. Utiliser les méthodes
avance() et tourne() pour déplacer Bob jusqu’à la position x=15, y=10, face à
l’Est.
- Le type énuméré Direction est défini dans le même fichier, et n’a pas besoin
d’être modifié. Rappel : on se réfère aux valeurs d’un type énuméré en écrivant par
exemple Direction.NORD, Direction.SUD, etc. Dans les case d’un switch,
on peut omettre le nom du type (exemple : case NORD:)

enum Direction {
NORD, SUD, EST, OUEST
}
public class Robot {
………………………… private String nom; ………………………………………………………………………………………………

………………………… private Direction orientation; ………………………………………………………………………………………

……………………… private int x, y; ………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

page 12/19
………………………………………………………………………………………………………………………………………………………………………………………………………
……………… public Robot(String nom, Direction dir, int x, int y) { …………………………………………

……………………… this.nom = nom; …………………………………………………………………………………………………………………………

……………………… this.orientation = dir; ………………………………………………………………………………………………………………

……………………… this.x = x;…………………………………………………………………………………………………………………………………

……………………… this.y = y;…………………………………………………………………………………………………………………………………

………………………… } …………………………………………………………………………………………………………………………………………………………

……………… public void avance () { …………………………………………………………………………………………………………

……………………… switch(orientation){ ………………………………………………………………………………………………………………

……………………… case NORD: ………………………………………………………………………………………………………………………………………

…………………………………… y += 5; break; …………………………………………………………………………………………………………

……………………… case EST: ………………………………………………………………………………………………………………………………………

…………………………………… x += 5; break; …………………………………………………………………………………………………………

……………………… case SUD: ………………………………………………………………………………………………………………………………………

…………………………………… y -= 5; break; …………………………………………………………………………………………………………

……………………… case OUEST: ………………………………………………………………………………………………………………………………………

…………………………………… x -= 5; break; …………………………………………………………………………………………………………

………………………… } …………………………………………………………………………………………………………………………………………………………

……………… } ………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

……………… public void tourne (Direction dir) { ………………………………………………………………………………………

……………………… orientation = dir; ……………………………………………………………………………………………………………………………

………………… } ………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
page 13/19
………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
……………… public static void main (String [] args) { …………………………………………

……………………… Robot bob = new Robot("Bob", Direction.NORD, 0,0); ……………………

……………………… bob.avance(); ……………………………………………………………………………………………………………

……………………… bob.avance(); ……………………………………………………………………………………………………………

……………………… bob.tourne(Direction.EST); …………………………………………………………………………………………

……………………… bob.avance(); ……………………………………………………………………………………………………………

……………………… bob.avance(); ……………………………………………………………………………………………………………

……………………… bob.avance(); ……………………………………………………………………………………………………………

………………………… } …………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
}

page 14/19
7.2 – Il y a maintenant une nouvelle génération de robots, plus performants que les anciens.
Ils ont toutes les caractéristiques et fonctionnalités des anciens robots, plus la capacité de
varier leur vitesse, c’est-à-dire varier la distance parcourue en un pas. Cette fonctionnalité
prend la forme de deux méthodes supplémentaires accelerer() et ralentir(), qui
augmente ou diminue de 1 le nombre d’unités de distance parcourues en un pas.

Écrire ci-dessous la nouvelle classe RobotNG en utilisant l’héritage :

- Implémenter les attributs et méthodes nécessaires pour réaliser la fonctionnalité
demandée, en réutilisant autant que possible le code de la classe Robot.
- Implémenter un constructeur qui utilise le constructeur de la superclasse. Il prend
les mêmes paramètres, et fixe la vitesse initiale à 5 (le robot se déplace de 5 unités
de distance par appel de avance()).
- Ajouter les méthodes accelerer() et ralentir(), et un nouvel attribut pour
maintenir la vitesse.
- La vitesse ne doit jamais descendre en-dessous de zéro, ni dépasser le maximum
de 10 unités de distance par appel de avance().
Indiquer si des changements sont nécessaires (visibilité, variables supplémentaires…)
dans la classe Robot pour que la méthode avance() fonctionne correctement (utili-
ser le cadre marqué question 7.2.1). (si oui, indiquer quels changements)

// implémenter ici la classe RobotNG

…………… public class RobotNG extends Robot{ ………………………………………………………………………

………………… private int vitesse; ……………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

……………… public RobotNG(String nom, Direction dir, int x, int y) { ……………………………

……………………… super(nom, dir, x, y); ……………………………………………………………………………………………………………

……………………… this.vitesse = 5; ………………………………………………………………………………………………………………

……………… } …………………………………………………………………………………………………………………………………

……………… public void accelerer() { ………………………………………………………………………………………

……………………… if(vitesse<10) …………………………………………………………………………………………………………………………

………………………………… vitesse++; ………………………………………………………………………………………………………………………………

…………… } ………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
page 15/19
………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………
//suite classe RobotNG
………………………………………………………………………………………………………………………………………………………………………………………………………

………… public void ralentir() { ………………………………………………………………………………………

……………………… if(vitesse>0) …………………………………………………………………………………………………………………………

………………………………… vitesse--; ………………………………………………………………………………………………………………………………

…………… } ………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

……………… public void avance() { ………………………………………………………………………………………

……………………… switch(orientation){ ………………………………………………………………………………………………………………

……………………… case NORD: ………………………………………………………………………………………………………………………………………

…………………………………… y += vitesse; break; …………………………………………………………………………………………………………

……………………… case EST: ………………………………………………………………………………………………………………………………………

…………………………………… x += vitesse; break; …………………………………………………………………………………………………………

……………………… case SUD: ………………………………………………………………………………………………………………………………………

…………………………………… y -= vitesse; break; …………………………………………………………………………………………………………

……………………… case OUEST: ………………………………………………………………………………………………………………………………………

…………………………………… x -= vitesse; break; …………………………………………………………………………………………………………

………………………… } …………………………………………………………………………………………………………………………………………………………

……………… } ………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

page 16/19
// Question 7.2.1
………………………………………………………………………………………………………………………………………………………………………………………………………

………………… + la solution donnée requiert de modifier la visibilité de x et y, et

orientation à protected, où à ajouter des accesseurs / mutateurs publics

………………………………………………………………………………………………………………………………………………………………

……………… + une autre solution serait de mettre l’attribut vitesse dans Robot (le

fixer à 5) et on n’aurait alors pas besoin d’implémenter avance() dans Ro-

botNG ………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………………………………………………………………………

page 17/19
 Bibliothèque d’exemples

La conversion de types Scanner, System.out.printf

Scanner clavier = new Scanner(System.in);
(7 / 2.0) * 2 => 7.0 , double System.out.print("Entrer votre nom:");
7/2 => 3 , int String nom = clavier.next();
(7 / 2) * 2.0 => 6.0 , double System.out.print("Entrer votre âge:");
(double) 7%3 => 1.0 , double int age = clavier.nextInt();
(int) ((7 /2.0) * 2)=> 7 , int System.out.print("Entrer votre taille en m");
"2" + 2 + 2 => "222" , String double taille = clavier.nextDouble();
2.0 + 3.5 + "2" => "5.52" , String System.out.printf("Bonjour, %s, vous avez %d ans et
mesurez %.2f m.", nom, age, taille);

Bonjour, Alice, vous avez 14 ans et mesurez 1.45m.

Fonctions if-else imbriqués

if (note >= 80)
lettre = 'A';
rayon
double perimetre(double rayon){ else if (note >= 70)
lettre = 'B';
double p = 2 * Math.PI * rayon; else if (note >= 60)
return p; lettre = 'C';
else if (note >= 50)
} lettre = 'D';
périmètre else
lettre = 'F';

System.out.printf("La lettre correspondant

à %d est %c.", note, lettre);

switch while
System.out.println("Combien de pattes?"); double prix = 1.75;
int nbPattes = clavier.nextInt(); double argentPayé = 0;
switch(nbPattes){ double reste;
case 2: while (argentPayé < prix){
System.out.println("C’est un bipède"); reste = prix – argentPayé;
break;
System.out.printf("Reste a payer %.2f.
case 4:
Mettre une piece.", reste);
System.out.println("C’est un quadrupède");
piece = clavier.nextDouble();
break;
argentPayé += piece;
case 8:
System.out.println("C’est une araignée"); }
break; System.out.printf("Merci!\n Monnaie à
default: rendre:%.2f", argentPayé - prix);
System.out.println("Je ne sais pas! ");
break;
}

page 18/19
 Boucles for imbriquées Manipuler un tableau
for (int i=0; i<10; i++){ public static int[] getTableau(){
for (int j=0; j<10; j++){ int [] monTableau = {3, 4, 56, -1};
System.out.print(i*10 +j +" "); return monTableau;
} }
System.out.println(); 0 1 2 3 4 5 6 7 8 9
} 10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29 public static void doublerValeurs(int[] a){
30 31 32 33 34 35 36 37 38 39
for (int i = 0; i < a.length; i++){
40 41 42 43 44 45 46 47 48 49
Sortie: 50 51 52 53 54 55 56 57 58 59 a[i] = a[i]*2;
60 61 62 63 64 65 66 67 68 69 }
70 71 72 73 74 75 76 77 78 79 }
80 81 82 83 84 85 86 87 88 89
90 91 92 93 94 95 96 97 98 99

Calculer une somme Fonction récursive puissance

// calcule xn
public static int somme(int[] a){
public static double puissance(double x, int n){
int somme = 0; if (n==1)
for (int i = 0; i < a.length; i++){ return x;
somme = somme + a[i];
return x * puissance(x, n-1);
} }
return somme;
} public static void main(String[] args){
System.out.println(puissance(5,3));

11

Définir une classe Héritage

public class Cercle {
public class Forme {
private double x_centre;
private double y_centre; public double perimetre(){
private double rayon;
…
public Cercle(double x, double y, double r){ }
x_centre = x; }
y_centre = y; public class Cercle extends Forme {
rayon = r;
} …
public double perimetre(){
public double perimetre(){
return 2 * Math.PI * rayon; return 2 * Math.PI * rayon;
} }

} }

page 19/19