IFT1010 Programmation I

Département d'informatique et de
recherche opérationnelle

Hiver 2002


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


Pratique | Exercice Noté

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)

    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 ?
    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é gagnenb 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.



Dernière mise à jour : Sun Feb 10 14:24:42 EST 2002
dift1010@iro.umontreal.ca