Les structure 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 :

Les alternatives en java.
Une instruction bien particulière, le switch.
Les structure répétitives en java.
Le break et le continue.
Exercices (Les alternatives)
Solution des exercices (les alternatives)
Exercices (Les répétitives)
Solution des exercices (Les répétitives)

Les alternatives en java.

Partie I (suite)

Alternatives et conditions

Une alternative est en fait un test dans un programme qui peut être soit vérifié ou non
Les programmes procéduraux à la base se déroulaient en suivant les instructions depuis le début du programme jusque à la fin (de haut en bas sans arrêts), mais on a ensuite élaboré des structures afin que certaines instructions soit exécutées ou non en fonction sur base d'un test.

Si le test est vérifié, on exécute une série d'instructions sinon on exécute une autre série d'instructions

Une alternative se fait sur base d'une condition.

Oui, mais comment établir une condition en java ?

D'abord sachez qu'il y a deux sortes de conditions, les conditions simples, et les conditions multiples

La condition simple :

C'est en fait une bête comparaison entre deux (ou plusieurs) variables ou une (ou des) variable(s) et une (ou des) valeur(s)
Une condition s'exprime de manière générale :
nomVar1 opérateur_logique nomVar2;

Exemple : var1 < var2. (On effectue ce que l'on appelle un prédicat, un test

Les opérateurs logiques en Java sont :

"==" pour l'égalité. (le double égal

Attention, un seul égal = l'affectation, et donc erreur en compilation!

Mettez donc 2 égales "==" pour la comparaison entre 2 variables

On peut aussi bien sur comparer une variable avec une valeur

var1 == 1

Les autres opérateurs de comparaisons :

< pour plus petit qu
> pour plus grand qu
<= pour plus petit ou égal
>= pour plus grand ou égal
!= pour différent d

Un test ne renverra toujours que deux valeurs, soit vrai ou faux

Les variables booléennes.

Elle peuvent contenir soit vrai, ou faux. (ce qui correspond à 0 ou autre valeur en C)
On les utilise pour pas confondre les variables de type entier qui servent à faire des tests et les autres

Car en c, si toute valeur est différente de 0, la condition est vraie.
En c++ il y a ces fameuses variables booléennes
Exemple de programme :

Code : Java

class Exemple3 
       private int age;
       private boolean existe = false;
       Scanner lectureClavier = new Scanner (System.in);
       System.out.println("Quel âge avez vous ?");
       age = lectureclavier.nextInt ();
       if(age > 0) 
            //Si il a plus de 0 an, il existe, sinon erreur
            existe = true;
       } else 
            System.out.println("Vous êtes pas encore né :D");
       }          
       if (existe) { //Simplifie le if (existe == true)
            //Si il existe
            if (age < 15) 
                 //S'il à moins de 15 ans;
                 System.out.println("Vous êtes jeune");
            } else if (age < 20) 
                 S'il à moins de 20 ans
                 System.out.println("Vous êtes adolescent");
            } else if (age < 50) 
                 //S'il a moins de 50 ans
                 System.out.println("Vous êtes adulte");
            } else 
                 //Si toutes les conditions précédentes sont fausses
                 System.out.println("Vous êtes un vieillard");

Pour simplifier if (existe == false) on écrit un point d'exclamation devant le nom de la variable booléenne tout simplement

Syntaxe : if (!existe) { ....

Éviter les tests inutiles du style

Code : Java

if (existe) 
    if (age > 50) 
           System.out.println("Vous êtes un vieillard")
           if (age < 20) { ...

Si il a plus de 50 ans, il n'est pas nécessaire de vérifier s'il en a moins de 20 car s'il en a plus que 50 ans, il en a forcément pas moins que 20!

En java, on a donc également simplifié la tâche avec les booléens, pour ne pas confondre avec les int

Affectation d'un booléen : varBool = true ou varBool = false. (2 valeurs possibles seulement)

Comme java est un langage compacte, il suffira d'indiquer tout simplement le nom de la variable booléenne dans le if

La structure if
Justement, parlons du if maintenant. Sa structure est pareille qu'en C comme dans le cours de David. (erf il l'a effacé, pas grave je vous la remet) ^^

La syntaxe

Code : Java

if (condition) 
    //instructons si vrai
} else 
    //instructions si faux

Votre condition se mettra donc entre les parenthèses après un if.
Si la condition est vraie, les instructions dans le bloc if sont exécutées et si la condition est fausse, les instructions dans le bloc else sont exécutées
On peut aussi écrire

C'est le "else if"

Evitez d'écrire :

Code : Java

if(condition1) 
           //si vrai
} else 
  if(condition2) 
     //si vrai
  } else 
     //si faux
  }

Car c'est moins claire. Il vaut mieux employer le else if

Le else est facultatif car, on pourrait très bien ne rien faire si la condition est fausse.

Les conditions multiples (utilisation d'opérateurs booléens) :

C'est un ensemble de plusieurs conditions simples reliées entre elles à l'aide d'opérateurs logiques
L'ensemble est appelé une expression booléenne et une expression booléennes peut avoir une ou plusieurs conditions. (mais n'en faîtes pas trop, votre code doit rester claire

Il existe plusieurs sorte de liaisons

Le et qui se note &&
Le ou inclusif qui se note ||
Le ou exclusif qui se note |
Le non qui se note !

Le et : sert a comparer plusieurs conditions et il renvoie vrai si toutes les conditions sont vraies
NB : En java, si la première condition est fausse, la seconde ne sera même pas vérifiée, il renvoie faux d'office
C'est ce qui s'appelle des opérateurs logiques à cours circuit. Un seul & provoque la vérification de toutes les conditions de l'expression même si la première condition est fausse ce qui est inutil.

Le ou inclusif : renvoie faux uniquement lorsque toutes les conditions sont fausse.
Sinon si l'une d'elle ou même toutes à la fois sont vraie, il renvoie vrai

Le ou exclusif : c'est la même chose que le ou inclusif sauf que si toutes les conditions sont vraies en même temps, ça renvoie faux! Bien faire la distinction entre ces 2 types de ou

Le non : renvoie vrai lorsqu'une expression booléennes est fausse.
Comme je vous l'ai montrée avec la variable booléenne "existe" si dessus. (on rajoute le ! devant qui équivaut à existe = false

Les tables de vérités

Elles permettent de déterminer quelle valeur va nous renvoyer une expression booléenne. (Selon que les conditions dans les expressions booléennes soient vrai ou fausse
Je vais vous mettre les 4 tables de vérités de base (avec donc deux test seulement) :
Tables de vérité du et, du ou, du ou exclusif et du non. (avec un seul test pour le nom)
Image utilisateur

Ou T1 représente le premier test, t2 le second test et r le résultat de l'expression booléenne
v = vrai et f = faux
Exemple avec ces quatre liaisons là

Code : Java

if (age > 0) 
    existe = true
 
 
if (age > 20 && age < 50) {
 
 
 
 
 
 
 
 
 
//S'il a plus que 20 ans et moins que 50
    System.out.println("Vous êtes adulte")
} else if (age < 20 | age >50) 
//Si il a moins de 20 ans ou si il a plus de 50 ans
        System.out.print("Vous n'êtes pas adulte vous êtes : ")
    if (age < 15 || !existe) 
        //Si il a moins de 15 ans ou moins de 0 a
        System.out.prinln("jeune ou pas encore né?")
    else if (!(age > 20 && age < 10)) 
        //Si il n'a pas plus de 20 ans et moins de 10 ans
        System.out.prinln("adolescent")
    } else 
        System.out.println("Vieillot^^")

Remarque : j'ai fait exprès de faire ça pour bien que vous compreniez, j'aurais bien sur sinon du le faire avec des conditions plus simples. Mais parfois les conditions multiples sont utiles; évitent de faire trop de test et d'utiliser trop de if et on ne s'y retrouve plus après.
Notamment lorsque vous devrez gérer des gestions de collision ou il y aura plein de tests à faire pour pas foncé dans les murs =D
Voilà maintenant je crois que vous savez tout sur les conditions. ^

NB : comme pour les opérateurs mathématiques, il existe un raccourci assez pratique.

Syntaxe : condition ? si vrai : si faux

Attention, l'opérateur ternaire doit être mit entre () pour que ça compile.

Exemple : On veut créer un programme qui fait deviner un nombre à l'utilisateur et ce nombre est compris entre un et dix

La classe Math permet de faire tirer un nombre au hasart à l'utilisateur :

Code : Java

import java.util.Scanner;
//Pour importer le répertoire ou se trouve la classe scanner.
public class exemple {
     public static void main (String [] args) {
            private int iNbGenere;
            private int iProposition;
            iNbGenere = (int) Math.random ()*10;
            Scanner lectureClavier = new Scanner (System.in);
            System.out.println("Entrer votre proposition : ");
            iproposition = lectureClavier.nextInt ();
            if (iProposition != iNbGenere)
                  System.out.println("Non, le nombre est trop "+ (iProposition <   iNbGenere ? "petit." : "grand."));
            } else 
                  System.out.println("Bravo, vous avez trouver !");
            
      
}

Ca simplifie le code tout simplement, plutôt que de devoir écrire :

Code : Java

if (iProposition < iNbGenere) 
        System.out.println("Le nombre est trop petit");
else 
        System.out.println("Le nombre est trop grand");

Remarque : s'il n'y a qu'une seule instruction après le if ou le else, on est pas obligé de mettre des crochets, mais sinon obligation d'en mettre!!!

Si vous voulez comparer par exemple des chaînes de caractères, le == ne marchera pas et les autres opérateurs (<, <=, >=, >) ne marcheront pas non plus!

Utiliser la méthode equals de la classe String pour comparer deux chaînes de caractères entre elles :
exemple :

Code : Java

if (chaine1.equals(chaine2)) {
   System.out.println("Ces deux chaînes sont identiques!");
}

Une instruction bien particulière, le switch.

Uilité du switch

Le "switch" permet de faire un choix d'instruction(s) à éxé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 celà, 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 vouler une entrée tapper 1");
System.out.println ("Si vous vouler le potage tapper 2");
System.out.println ("Si vous vouler le plat principal tapper 3");
System.out.println ("Si vous vouler un dessert tapper 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 ?

Parcequ'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 possiles 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ême 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 inconnus.

Exemple : Compter par 3 jusqu'à ce que l'utilisateur veille qu'on arrête.

Code : Java

System.out.println("Continuer ? (Tappez '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 ? (Tappez 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 ? (tapper '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, elle 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 parler 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ère 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 le 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)

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)

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 par32 : "+ nombre)
         if (nombre % 5 == 0)
              System.out.println("Ce nombre est divisible par 5 : "+ nombre)

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 faire plus simple mais je vous 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éré 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êl;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)

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);
}
}

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);
}
}

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 boolenen 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'un boucle, ou alors ignorer des instructions dans celle-ci.

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

Rédigé par Lo

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

Les Tutoriaux Les Forums Les Liens

Les structure de contrôle de java.

Les alternatives en java.

Partie I (suite)

Alternatives et conditions

La condition simple :

Les variables booléennes.

Les conditions multiples (utilisation d'opérateurs booléens) :

Les tables de vérités

Une instruction bien particulière, le switch.

Uilité du switch

Des exemples pour bien comprendre

Les structure répétitives en java.

La structure pour

La structure tant que.

La structure fait tant que.

Les boucles infinies

Le break et le continue.

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

Le "continue".

Exercices (Les alternatives)

Solution des exercices (les alternatives)

Exercices (Les répétitives)

Solution des exercices (Les répétitives)