Accueil
Professeurs et Démonstrateurs
Horaires et locaux
Notes de cours
Démonstrations et devoirs
Examens
Liens utiles
Au sujet du livre de cours
Consultez vos notes
Foire aux questions (FAQ)
|
|
Démonstration 5: Découpage d'un code en méthodes
Pourquoi introduire des méthodes: étude de cas
On désire ici écrire un programme qui affiche à l'écran trois
rectangles ainsi que leurs informations spécifiques (surface,contour,
etc.). Deux versions de ce programme sont données ici: l'une avec une
seule métode, l'autre avec un découpage en plusieurs méthodes.
Premier programme avec une seule méthode, la méthode main
/* Cette classe execute le main qui affiche la
surface, la longueur de la diagonale et la longueur du countour de
trois rectangles. L'affichage avec des étoiles de ces rectangles est également réalisé.*/
class Rectangle {
public static void main (String[] args){
// trois rectangles definis par leur base
et leur hauteur
double base1=10, hauteur1=4;
double base2=15, hauteur2=7;
double base3=9, hauteur3=12;
// variables
double surface1, surface2, surface3;
double diagonale1,diagonale2, diagonale3;
double contour1, contour2, contour3;
// calculs
surface1 = base1 * hauteur1;
surface2 = base2 * hauteur2;
surface3 = base3 * hauteur3;
diagonale1 = Math.sqrt(Math.pow(base1,2) + Math.pow(hauteur1,2));
diagonale2 = Math.sqrt(Math.pow(base2,2) + Math.pow(hauteur2,2));
diagonale3 = Math.sqrt(Math.pow(base3,2) + Math.pow(hauteur3,2));
contour1 = 2*base1 + 2*hauteur1;
contour2 = 2*base2 + 2*hauteur2;
contour3 = 2*base3 + 2*hauteur3;
System.out.print("\n");
System.out.print("\n");
// affichage rectangle1
for (double i = hauteur1; i>0; i--) {
for (double j = base1; j>0; j--)
{
System.out.print("*");
} // end for j
System.out.print("\n");
} // end for i
System.out.println("Ce rectangle a une surface de
" + surface1 + ", une diagonale de " +diagonale1 + " et un contour de "
+contour1 + ".");
System.out.print("\n");
System.out.print("\n");
// affichage rectangle2
for (double i = hauteur2; i>0; i--) {
for (double j = base2; j>0; j--)
{
System.out.print("*");
} // end for j
System.out.print("\n");
} // end for i
System.out.println("Ce rectangle a une surface de
" + surface2 + ", une diagonale de " +diagonale2 + " et un contour de "
+contour2 + ".");
System.out.print("\n");
System.out.print("\n");
// affichage rectangle3
for (double i = hauteur3; i>0; i--) {
for (double j = base3; j>0; j--)
{
System.out.print("*");
} // end for j
System.out.print("\n");
} // end for i
System.out.println("Ce rectangle a une surface de
" + surface3 + ", une diagonale de " +diagonale3 + " et un contour de "
+contour3 + ".");
} // end main
} // end class Rectangle
Deuxième programme avec découpage en méthodes
/* Cette classe contiend la méthode main et
aussi d'autres méthodes qui permettent de faire le même travail
que la classe Rectangle.*/
class Rectangle2 {
public static void main (String[] args){
// trois rectangles definis par leur base
et leur hauteur
double base1=10, hauteur1=4;
double base2=15, hauteur2=7;
double base3=9, hauteur3=12;
// variables
double surface1, surface2, surface3;
double diagonale1,diagonale2, diagonale3;
double contour1, contour2, contour3;
// calculs
surface1 = surface(base1, hauteur1);
surface2 = surface(base2, hauteur2);
surface3 = surface(base3, hauteur3);
diagonale1 = diagonale(base1, hauteur1);
diagonale2 = diagonale(base2, hauteur2);
diagonale3 = diagonale(base3, hauteur3);
contour1 = contour(base1, hauteur1);
contour2 = contour(base2, hauteur2);
contour3 = contour(base3, hauteur3);
System.out.print("\n");
System.out.print("\n");
// affichage
afficher(base1, hauteur1, surface1, diagonale1,
contour1);
afficher(base2, hauteur2, surface2, diagonale2,
contour2);
afficher(base3, hauteur3, surface3, diagonale3,
contour3);
} //main
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// autres méthodes (On
utilise "static" car il n'y a pas d'objet)
static double surface(double b, double
h){
return
(b*h);
}
static double diagonale(double b, double
h){
return
(Math.sqrt(Math.pow(b,2) + Math.pow(h,2)));
}
static double contour(double b, double
h){
return
(2*b + 2*h);
}
static void afficher(double b, double
h, double s, double d, double c){
for (double
i = h; i>0; i--) {
for (double j = b; j>0; j--) {
System.out.print("*");
} // end for j
System.out.print("\n");
} //
end for i
System.out.println("Ce
rectangle a une surface de " + s + ", une diagonale de " +d
+ " et un contour
de " +c + ".");
System.out.print("\n");
System.out.print("\n");
} // end afficher
} // end Rectangle2
Travail pratique (pas noté)
Nombres premiers et parfaits
Écrire une classe qui possède au moins les trois méthodes suivantes:
- une méthode static bool est_parfait (int nombre) qui
retourne true si le nombre passé en argument est parfait,
false sinon,
- une méthode static bool est_premier (int nombre) qui
retourne true si le nombre passé en argument est premier,
false sinon,
- une méthode public static void main (String [] args) qui
appelle les méthodes précédantes pour afficher tous les nombres entre 1 et 1000 qui sont premiers ou parfaits.
|
Qu'affiche à l'écran le programme suivant?
class Dem5Exo1 {
public static void main (String[] args){
int a=0,b=1,c=2,d;
double x=1.0, y=3.4;
String mot = ("allo") ;
System.out.println(methode1(a));
System.out.println(a);
System.out.println(methode1(b++));
System.out.println(b);
System.out.println(methode1(++b));
System.out.println(b);
d = methode1(c);
System.out.println(d);
System.out.println(c);
farfelu(a);
farfelu(a,b);
farfelu(x);
farfelu(x,y,b);
farfelu(mot);
} //main
static int methode1(int nb){
int a = 4;
nb++;
return(nb);
} // end methode1
static void farfelu(int a){
System.out.println("message1");
System.out.println(a);
} // farfelu
static void farfelu(int nb1, int nb2)
{
System.out.println("message2");
} // end farfelu
static void farfelu(double w, double
v, int g)
System.out.println("message3");
} // end farfelu
static void farfelu(double s) {
System.out.println("message4");
} // end farfelu
static void farfelu(String message)
{
System.out.println(message);
} // end farfelu
} // end Dem5Exo1
|
Qu'affiche à l'écran le programme suivant?
Écrire un programme qui demande à l'utilisateur de rentrer une chaîne
de caractères et qui affiche la chaîne transformée à l'écran. La
transformation de la chaîne se fait en parcourant de la droite vers la
gauche la chaîne entrée par l'utilisateur, puis à afficher tout
caractère de la chaîne d'origine qui n'a pas déjà été affiché.
Exemple: "Bonjour a toi" donne "iot arujnB"
Écrivez et utilisez pour cela deux méthodes:
static String inversion (String phrase)
static String sans_repetition(String phrase)
|
Exercice noté (1 point)
Amusons-nous
Écrire un programme Exercice5.java qui permet à son utilisateur de jouer à l'un des trois jeux suivants:
- Devine: est un jeu où l'utilisateur a au plus 10 coups
pour trouver un nombre secret que la machine a choisi. À chaque essai
infructeux, la machine indique à l'utilisateur si sa proposition est
plus grande ou plus petite que le nombre secret.
- Polynome: est un jeu hillarant où un utilisateur spécifie
les coefficients d'un polynome de degré deux, et gagne si le polynome
ainsi spécifié admet une ou deux racines.
- Calcul: est un jeu où l'ordinateur pose un problème de
calcul (simple) à l'utilisateur qui gagne si sa réponse est la bonne.
Votre programme doit proposer en boucle à l'utilisateur de jouer à
l'un de ces trois jeux, via le menu suivant:
A quel jeu voulez-vous jouer ?
1 - Devine
2 - Polynome
3 - Calcul
4 - Quitter
Entrez votre réponse:
Le détail de chacun des jeux est maintenant décrit; chaque jeu doit
être programmé dans une méthode dont l'entête est indiquée ci-après et
que votre méthode main doit appeler. Chaque méthode retourne
true si le joueur réussi le jeu, false s'il le perd.
- static bool devine(int min, int max)
L'ordinateur sélectionne un nombre entier entre min et
max (inclus) et demande à l'utilisateur de trouver ce nombre en
un maximum de 10 coups.
Si l'utilisateur trouve le nombre secret, l'ordinateur met fin au
jeu en affichant le message Félicitation, vous avez
trouvé le nombre secret en X coups; où X est le
nombre de coups qui ont été nécessaires à l'utilisateur pour trouver le code.
Si après 10 coups, l'utilisateur n'a toujours pas trouvé le nombre
secret, alors, le programme affiche: Raté, le nombre
secret était X; où X est la valeur du nombre
secret choisi par l'ordinateur au debut du jeu.
Après chaque coup infructueux, la machine aide l'utilisateur en lui précisant si le nombre qu'il a proposé est plus grand ou plus petit que le nombre secret, à l'aide d'un des messages suivants:
Trop grand
Trop petit
- static bool polynome(int a, int b, int c)
où a, b et c sont les coefficients du polynome a x 2 + bx + c.
Si le polynome n'admet pas de racine, le programme affiche le message: "Rate ! ce polynome n'a pas de racine
Si le polynome admet une racine double, le programme affiche le
message: Félicitation, votre polynome admet une racine
double X; où X est la valeur de la racine.
Si le polynome admet deux racines, alors le programme affiche le
message: Félicitation, votre polynome admet deux
racines X et Y ; où X est la plus petite racine et Y la plus grande.
- static bool calcul()
La machine sélectionne aléatoirement deux entiers x1 et
x2 entre 1 et 100 (inclus), et choisi aléatoirement une
opération op: l'addition ou la multiplication. Elle demande
alors à l'utilisateur le résultat du calcul en affichant le message
suivant:
Combien fait: x1 op x2 ?
où x1, op et x2 sont remplacés par les choix faits précédemment.
Si l'utilisateur répond correctement, la machine affiche:
Bravo!
Sinon, la machine affiche:
Raté! x1 op x2 vaut res ; où res est le résultat du calcul.
Lorsque l'utilisateur sort du menu (choix 4), l'ordinateur affiche le message:
Vous avez joué à nb jeux, et vous en avez gagné
gagne où nb est le nombre exact de jeux auxquels
l'utilisateur à joué, et gagne est le nombre de jeux réussis
par l'utilisateur.
Note 1: les deux premiers jeux nécessitent des variables
(bornes du nombre secret dans le jeu 1, valeurs des coefficients dans
le jeu 2. Ces valeurs sont demandées à l'utilisateur à même la méthode
main, en fonction du jeu choisi.
Note 2: plusieurs jeux nécessitent le choix de valeurs
aléatoires. Plutôt que d'écrire plusieurs fois ces choix, faites une
méthode qui génère une valeur entière entre des bornes passées en
argument de votre méthode:
static int alea(int min,max) { /* à compléter */}
Note 3: de la même manière, vous devez à plusieurs reprises faire la saisie d'un entier, après avoir affiché un message à l'utilisateur. Vous pouvez très bien écrire une fonction qui prompte l'utilisateur, qui réalise la saisie, et qui retourne l'entier saisi:
static int readInt(String message) { /* à compléter */}
Important: Vos programmes sont corrigés
pseudo-automatiquement, aussi, il vous est conseillé de suivre au
mieux (cad parfaitement :-) les instructions. Pour faciliter votre
travail, voici une trace d'exécution où tout
ce qui est en vert indique les entrées faites par l'utilisateur.
Pour remettre votre programme:
remise ift1010 demo05 Exercice5.java
Prenez note que chaque exercice noté est à remettre individuellement.
|
|