Jeux Libres

Plateforme de création de jeux vidéo (Le site est en cours de création / réorganisation)


» Les Tutoriaux » La programmation de jeux avec le langage Java » Les structures de contrôle de java

Les structures de contrôle de java


Ici nous allons voir donc comment créer des alternatives et des boucles en java. C'est similaire au C.


Sommaire du chapitre :


Chapitre précédent     Sommaire     Chapitre suivant

Les alternatives en java

parse : document non valide.



Une instruction bien particulière, le switch


Utilité du switch



Le "switch" permet de faire un choix pour les instruction(s) à exécuter en fonction des valeurs possibles que peut prendre une variable.

On le note comme en C : switch (variable) { ... }

Cette variable ne peut être que de type byte, short, int, long ou char et pas autre chose! (char est aussi un nombre, je vous le montrerai plus tard ^^)

Des exemples pour bien comprendre



Exemple de programme avec le switch :
Code : Java

int menu;
Scanner lectureClavier = new Scanner (System.in);
System.out.println ("Si vous voulez une entrée taper 1");
System.out.println ("Si vous voulez le potage taper 2");
System.out.println ("Si vous voulez le plat principal taper 3");
System.out.println ("Si vous voulez un dessert taper 4");
menu = lectureClavier.nextInt ();
switch (menu) {
     case 1 : System.out.println("Vous avez choisis une entrée.");
     case 2 : System.out.println("Vous avez choisis un potage.");
     case 3 : System.out.println("Vous avez choisis un plat principal.");
     case 4 : System.out.println("Vous avez choisis un dessert.");
     default : System.out.println("Menu pas valide");
}
 

On constate que si vous taper 1; il affiche aussi les 3 phrases suivantes. Pour éviter cela, il faut lui dire de sortir du switch après l'instruction, en rajoutant un break.
Code : Java

int menu;
Scanner lectureClavier = new Scanner (System.in);
System.out.println ("Si vous voulez une entrée taper 1");
System.out.println ("Si vous voulez le potage taper 2");
System.out.println ("Si vous voulez le plat principal taper 3");
System.out.println ("Si vous voulez un dessert taper 4");
menu = lectureClavier.nextInt ();
switch (menu) {
     case 1 : System.out.println("Vous avez choisis une entrée."); break;
     case 2 : System.out.println("Vous avez choisis un potage."); break;
     case 3 : System.out.println("Vous avez choisis un plat principal."); break;
     case 4 : System.out.println("Vous avez choisis un dessert."); break;
     default : System.out.println("Menu pas valide!");
}
 

Le "default" sert lorsque la valeur de la variable ne correspond à aucune valeur de case. En effet si vous taper 5, il y a rien.

Pourquoi un break ?

Parce qu'on pourrait très bien vouloir faire les instructions suivantes.
Par exemple si l'entrée est d'office accompagnée du reste.

Ça c'est à vous de voir lorsque vous programmer quels instructions il faut exécuter en fonction des différents cas possibles que pourra prendre votre variable.

Je sais que c'est pas toujours évidement d'analyser, des fois moi aussi j'ai des problèmes et je passe une heure devant l'écran avant de comprendre pourquoi ça ne marche pas, mais le temps est votre ami.

Les structure répétitives en java


Il en existe 3 en java. Elles sont utilisées en fonction de ce qu'on doit appliquer comme traitement.
Elle permettent de répéter plusieurs fois les mêmes instructions.

La structure pour



Elle est composée d'une variable de type entière, qui aura une valeur initiale, une valeur finale, et une valeur d'incrémentation. Elle est a privilégiée lorsqu'on connait le nombre de répétitions à effectuer.

Toutes les instructions se trouvant dans le bloc d'instructions du for seront répétées. (pratique non?)

Exemple : programme qui compte par deux jusqu'à 100.
Code : Java

for (int i = 0; i <= 100; i += 2) {
    Systme.out.println(i); //i varie donc de 0 à 100 et est
/*incrémenté de 2 à chaque fois que l'on revient au for     (après avoir affiché i dans ce cas si)*/
}
 

Attention, on ne peut pas modifier la variable i dans la structure pour.

Ne pas décrémenter i sinon i va se diriger dans les nombres négatis : -2, -4, et ne sera jamais égal à 100, dans ce cas votre programme va tourner à l'infini sans s'arrêter! Il faut alors fermer et relancer blue-j ce qui est bien embêtant.

On peut aussi incrémenter plusieurs variables à la fois dans un for comme ceci :
Code : Java

for (int i = 0; j = 1; i <= 100; i += 2; j += 3) {  }
 


La structure tant que.



Utilisée lorsqu'il peut y avoir aucune, 1 ou n répétitions des instructions qui se trouvent à l'intérieur du bloc.

Elle est utilisée lorsque le nombre de répétitions nous est inconnu.

Exemple : Compter par 3 jusqu'à ce que l'utilisateur souhaite que l'on arrête.
Code : Java

System.out.println("Continuer ? (Tapez 'o' pour oui et autre chose pour non)");
Scanner lectureClavier = new Scanner (system.in);
char rep = lectureClavier.next ().charAt(0);
int compteur = 0;
while (rep == 'o') {
     compteur = compteur + 3;
     System.out.println(compteur);
     System.out.println("Continuer ? (Tapez o pour oui  et autre chose pour non)");
     rep = lectureClavier.next().charAt(0);
}
 


La structure fait tant que.



Utilisée lorsqu'il y a au minimum une répétition à faire.

Exemple : reprenons le programme du dessus, mais on veut qu'il affiche d'office trois sans demander l'avis à l'utilisateur.
Code : Java

Scanner lectureClavier = new Scanner (system.in);
int compteur = 0;
char rep;
do {
     compteur = compteur + 3;
     System.out.println(compteur);
     System.out.println("Continuer ? (taper 'o' pour oui et autre chose pour non)");
     rep = lectureClavier.next ().charAt(0);
} while (rep == 'o');
 

Ne pas oublier le ";" après la ")" de fin de la condition dans le while.

Les conditions sont donc soit utilisées dans une boucle, ou alors dans une alternative, mais pas ailleurs!
Et oui, elles ne vous lâcherons plus ces conditions, c'est donc important de pouvoir bien les maîtriser.


Comme pour les alternatives, on peut se passer des crochets s'il n'y a qu'une seule instruction dans la boucle.
Attention de ne pas les oublier si vous en avez plusieurs!! Sinon, seule la première instruction sera répétée!

Les boucles infinies



A n'utiliser que en cas de besoin!

Aller je vous les donnes quand même mais attention à n'utiliser qu'en cas de besoin sinon votre programme ne s'arrêtera jamais et plantera.

Pour le for : for ( ; ; ) {} //On écrit rien à l'intérieur à part les points virgules.

Pour le while et le do while :

while (true) {}
do {} while(true);

On utilise donc nos valeurs spéciales de nos variables booléennes dont je vous ai plus haut si vous vous en souvenez bien, sinon aller revoir.
Si vous avez bien compris, si on met while (false) {} ce qui se trouve dans la boucle ne sera jamais exécuté.

Le break et le continue


Ce sont deux instructions particulières que l'on rencontre dans une boucle. L'une permet d'en sortir, l'autre permet d'ignorer certaines instructions dans une boucle.

Le "break" : permet de sortir d'une boucle!



Exemple : on veut un programme qui compte jusqu'à 10 mais qui s'arrête quand l'utilisateur tape non.
(je sais je lai déjà fait avec un while, mais maintenant je vais le faire avec un for pour que vous compreniez bien son principe même si il y'a mieux.

Code : Java

import java.util.Scanner;
public class Exemple {
public static void main (String [] args) {
private char rep;

Scanner lecture = new Scanner (System.in);

for (int i = 0; i <= 10; i++) {
     System.out.println("Compteur = " + i);
     System.out.println("Voulez vous continuer ? => taper 'n' pour non.");
     rep = lecture.next().charAt(0);
     if (rep == 'n') break;
//Oulala, j'étais encore bourré quand j'ai fait le code là! (pfff)
//Nah j'ai fais les changements.
}
 


Le "continue".



Supposons maintenant que l'on veut un programme qui compte jusqu'à dix, mais on ne veut pas qu'il affiche 8.

Exemple :
Code : Java

for (int i = 0; i <= 10; i++) {
       
               if (i == 8) continue;
               System.out.println("Le compteur vaut : "+i)
}
 


Lorsque i vaut 8, l'instruction continue va renvoyer le programme au for de la boucle et va incrémenter i de 1, sans afficher 8. L'instruction d'affichage est ignorée lorsque i vaut 8.

break et continue peuvent aussi s'utiliser dans un while et un do while.

Mais attention, avec l'instruction continue :
Code : Java

int i=0;
while (i = 10) {
      i++;
      if (i == 8) continue;
      //Ne pas mettre i++ ici!!
      System.out.pritln("Le compteur vaut : "+i);
}
 

Attention de bien incrémenter la variable i avant le if, sinon, le continue va sans cesse renvoyer le programme au début du while, en ignorant l'instruction d'incrémentation, le "i++", quand i vaudra 8, votre programme va donc planter!!

Exercices (Les alternatives)


Pour générer un nombre aléatoire utiliser la méthode random () de la classe Math

Math.random () => Génère un nombre aléatoire de type double et supérieur ou égale à 0.0 et inférieur à 1.0.

2)Ecriver un programme capable de générer un entier aléatoire et d'indiquer s'il est divisible par 2, par 3 ou 5. Truc : utiliser le reste de la division (opérateur modulo) lors du test.

3)Ecriver un programme capable de générer 4 entiers compris entre 0 et 999 inclus et d'écrire le minimum et le maximum.

4)Ecriver et exécuter un programme capable de faire deviner à l'utilisateur un nombre généré aléatoirement par la machine, et d'indiquer à chaque tentatives si ce nombre est trop petit ou trop grand. (max 5 tentatives)

5)Ecriver et exécuter un programme capable de simuler une machine à calculer dont les opérations sont l'addition, la soustraction, la multiplication et la division.
Vous dever utiliser la structure switch pour évaluer l'opérateur encodé par l'utilisateur (+, -, *, /). Pour récupérer le caractère de l'opérateur, utiliser les instructions suivantes :
Code : Java

Scanner lectureClavier = new Scanner (System.in);
operateur = lectureClavier.next().charAt(0);
 

Un division par zéro est une opération non conforme!

Solution des exercices (les alternatives)


1)
Code : Java
class exo1 {
    public static void main (String[] arg) {
           int nombre;
           nombre = (int) (Math.random () * 100); //Génère un nombre aléatoire entre //1 et 100
           if (nombre > 0) {
               System.out.println("Le nombre est bien positif : "+nombre);
 
           }
    }
}

2)
Code : Java
class exo2 {
    public static void main (String [] args) {
         int nombre;
         nombre = (int) (Math.random () * 100);
         if (nombre % 2 == 0) 
              System.out.println("Ce nombre est divisible par 2 : "+ nombre);
         if (nombre % 3 == 0)
              System.out.println("Ce nombre est divisible par 3 : "+ nombre);
         if (nombre % 5 == 0)
              System.out.println("Ce nombre est divisible par 5 : " + nombre);
    
    }
}

3)
Code : Java
class exo 3 {
    public static void main (String [] args) {
          int nombre1, nombre2, nombre3, nombre4, min, max
          nombre1 = (int) (Math.random () * 1000)
          nombre2 = (int) (Math.random () * 1000)
          nombre3 = (int) (Math.random () * 1000)
          nombre4 = (int) (Math.random () * 1000)
          if (nombre1 < nombre2 && nombre1 < nombre3 && nombre1 < nombre4) {
               min = nombre1;
          } else if (nombre2 < nombre1 && nombre2 < nombre3 && nombre2 < nombre4) {
               min = nombre2;
          } else if (nombre3 < nombre1 && nombre3 < nombre2 && nombre3 < nombre4) {
               min = nombre3;
          } else 
               min = nombre4;
          
          if (nombre1 > nombre2 && nombre1 > nombre3 && nombre1 > nombre4) {
               max = nombre1;
          } else if (nombre2 < nombre1 && nombre2 < nombre3 && nombre2 < nombre4) {
               max = nombre2;
          } else if (nombre3 < nombre1 && nombre3 < nombre2 && nombre3 < nombre4) {
               max = nombre3;
          } else 
               max = nombre4;
      }
 }

Remarque : il y a moyen de faire plus simple mais je vous force d'utiliser ça afin de bien maitriser les if et les opérations booléennes car elle seront importantes et nombreuse lors de la création de vos jeux.
4)
Code : Java
import java.util.Scanner
public class Exo {
 
    public static void main (String[] args) {
            int nbAlea, nbPropose;
            nbAlea = (int) (Math.random () * 100);
            Scanner lectureClavier = new Scanner (System.in);
            System.out.println("L'ordinateur à générer un nombre entre 0 et 100");
            System.out.println("Devinez le et entrer votre proposition : ");
            nbPropose = lectureClavier.nextInt ()
            if (nbPropose != nbAlea) {
                 System.out.println("Manqué, le nombre est trop : " + (nbPropose < nbAlea ? "petit." : "grand."));
            } else {
                 System.out.println("Bien joué vous avez trouvé le nombre!");
                 System.exit (0)
            }
            System.out.println("Devinez le et entrer votre proposition : ");
            nbPropose = lectureClavier.nextInt ();
            if (nbPropose != nbAlea) {
                 System.out.println("Manqué, le nombre est trop : " + (nbPropose < nbAlea ?  "petit." : "grand."));
            } else {
                 System.out.println("Bien joué vous avez trouvé le nombre!");
                 System.exit (0);
            }
            System.out.println("Devinez le et entrer votre proposition : ");
            nbPropose = lectureClavier.nextInt ();
            if (nbPropose != nbAlea) {
                 System.out.println("Manqué, le nombre est trop : " + (nbPropose < nbAlea ?  "petit." : "grand."));
            } else {
                 System.out.println("Bien joué vous avez trouvé le nombre!");
                 System.exit (0);
            }
            System.out.println("Devinez le et entrer votre proposition : ");
            nbPropose = lectureClavier.nextInt ();
            if (nbPropose != nbAlea) {
                 System.out.println("Manqué, le nombre est trop : " + (nbPropose < nbAlea ?  "petit." : "grand."));
            } else {
                 System.out.println("Bien joué vous avez trouvé le nombre!");
                 System.exit (0);
            }
            System.out.println("Devinez le et entrer votre proposition : ");
            nbPropose = lectureClavier.nextInt ();
            if (nbPropose != nbAlea) {
                 System.out.println("Manqué, le nombre est trop : " + (nbPropose < nbAlea ?  "petit." : "grand.&));
                 System.out.println("C'était votre dernier essai vous avez perdu désolé; le nombre était : " + nbAlea);
            } else {
                 System.out.println("Bien joué; vous avez trouvé le nombre!");
                 System.exit (0);
            }

Même remarque que l'exo précédant
5)
Code : Java
import java.util.Scanner
class Exo5 {
     char operateur;
     double nb1, nb2, resultat;
     Scanner lectureClavier = new Scanner (System.in);
     System.out.println("Entrer le premier nombre : ");
     nb1 = lectureClavier.nextInt ();
     System.out.println("Entrer le second nombre : ");
     nb2 = lectureClavier.nextInt ();
     System.out.println("Entrer l'opérateur (+, -, * ou /) : ");
     operateur = lectureClavier.next().charAt (0);
     switch (operateur) {
         case '+' : resultat = nb1 + nb2; break;
         case '-' : resultat = nb1 - nb2; break;
         case '*' : resultat = nb1 * nb2; break;
         case '/' : if (nb2 == 0) 
                          System.out.println("Opération non conforme!");
                    else 
                          resultat = nb1 / nb2; 
                    break;
         default : System.out.println("Opérateur non valide!");
     
     System.out.println ("Le résultat vaut : "+resultat);

Si vous avez du mal à comprendre, relisez le cours, regarder bien la solution et essayez de comprendre puis essayer de refaire l'exercice tout seul.
Si vous ne comprenez toujours pas, posez moi des questions sur le forum.



Exercices (Les répétitives)


1)
Ecrivez et exécuter un programme capable de générer 5 nombres entiers aléatoire et d'afficher leur moyenne.
2)
Ecrivez et exécuter un programme capable de rechercher huit triplet de Pythagore.
Equation : a² + b² = c².
a, b et c seront générer aléatoirement et sont comprit entre 1 et 100.
Utiliser l'instruction continue lorsque l'équation est fausse.
3)
Modifier le programme de l'exercice 5 sur les alternatives :
cette fois-ci l'utilisateur à droit à autant de tentatives qu'il le souhaite.
Indiquer combien de tentatives il lui a fallut pour trouver le nombre.
Si vous voulez aller encore plus loin, associer un score en fonction du nombre de tentatives qu'il a dû effectué avant de trouver le bon nombre.

Solution des exercices. (Les répétitives)


1)
Code : Java

import java.util.Scanner;
class exerc1 {
    public static void main (String [] args) {
           int nombre, moyenne = 0;
           for (int i = 0; i < 5, i++) {
               nombre = (int) (Math.random () * 100);
               moyenne = moyenne + nombre;
           }
           moyenne = moyenne / 5;
           System.out.println("Moyenne = "+moyenne);
    }
}
 

2)
Code : Java

public class exerc2 {
      public static void main (String[] args) {
          int a, b, c, nbTouves = 0;
          do {
                a = (int) (Math.random () * 100 + 1);
                b = (int) (Math.random () * 100 + 1);
                c = (int) (Math.random () * 100 + 1);
                int hypothenuse = c * c;
                int sommeCotes = a * a + b * b;
                if (hypothenuse != sommeCotes) {
                          continue;
                nbTrouve++;
                System.out.println("Triplet trouvé n° "+nbTrouve+" : ");
                System.out.println("a = "+a+"\nb = "+b+"\nc = "+c);
           } while (nbTrouve < 8);
        }
}
 

3)
Code : Java

import java.util.Scanner;
public class exerc3 {
      public static void main (String args[]) {
             Scanner lectureClavier = new Scanner (System.in);
             int nbAlea, nbPropose, nbTentatives = 1, score;
             nbAlea = (int) (Math.random () * 100);
             System.out.println("L'ordinateur à généré un nombre entre 0 et 100...");
             do {
                System.out.println("Devinez le en entrant une proposition : ");
                nbpropose = lectureClavier.nextInt();
                if (nbPropose != nbAlea) {
                      System.out.println("Manqué, le nombre est trop : " + (nbPropose < nbAlea ? "petit." : "grand."));
                nbTentatives++;
             } while (nbPropose != nbAlea);
             System.out.println("Vous avez trouvé le nombre au bout de "+nbTentatives+".");
             if (nbTentatives == 1) score = 100;
             else if (nbTentatives <= 5) score = 80;
             else if (nbTentatives <= 10) score = 60;
             else if nbTentatives <= 15) score = 40;
             else if (nbTentatives < 20) score = 20;
             else score = 0;
             System.out.println("Votre score est de : "+score);
      }
}
 



On a donc un type de variable booléen pour simplifier l'écriture d'une condition.
Il y a 2 structures alternatives, le if {} else {} et le switch (variable) { case 1: ... break; }.

Et une structure particulière pour simplifier : condition ? si vrai : si faux;

Il y a 3 types de boucles(for, while et do{...} while )
2 instructions particulières : break, et continue pour sortir d'une boucle, ou alors ignorer des instructions dans celle-ci.

A vous de voir quelle structure il convient le mieux d'employer.


Chapitre précédent     Sommaire     Chapitre suivant



Rédigé par Lo


Hébergeur du site : 1and1.fr



Site de création de Jeux Vidéo
Apprenez à créer vos propres Jeux Video

A propos de la construction du site... 		373006 pages ont été consultées sur le site !
Dont 268 pages pendant les 24 dernières heures.

Page générée en 5.901 secondes


Nos partenaires
- Otium Production : Aide aux débutants à créer leurs jeux
- A.C.S.E.L. : Club de patinage artistique de Caen


  © 2005-2009 www.jeux-libres.com - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.