IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

avec Java Discussion :

Mon premier programme en Java


Sujet :

avec Java

  1. #1
    Membre du Club
    Profil pro
    Inscrit en
    Août 2006
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 99
    Points : 62
    Points
    62
    Par défaut Mon premier programme en Java
    Bonjour,

    C'est mon premier programme en Java et en langage compilé tout court d'ailleurs.

    La base c'est un devoir qu'on avait à faire en cours mais, pas satisfait, je l'ai "un peu" amélioré.

    J'aimerais vos commentaires par exemple s'il y a des façons de mieux organiser le code, de faire quelque chose de pus court, ou si mon indentation est pas cohérente, etc.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    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
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    /*
     * 
     *      PourcentageNbNegatifs3.java
     *      
     */
     
    import java.io.*;
    import java.util.regex.* ;
    public class PourcentageNbNegatifs3
        {
        public static void main (String args[]) 
            {        
        //Initialisation des variables         -----------------------------------------------------------------------
            int nbNombres, nbNegatifs, nbPositifs, addition, choix;
            float pourcentageNegatifs, moyenne;
            int [] tabNb;    
            String recommencer = "";
     
        //Titre        -----------------------------------------------------------------------------------------------
            System.out.println("\n\n\n////////////////////////////////////////////////////////////////");
            System.out.println("//                                                            //");    
            System.out.println("// Programme pour faire divers calcul sur une série d'entiers //");    
            System.out.println("//                                                            //");    
            System.out.println("////////////////////////////////////////////////////////////////\n\n");
     
        // Programme    -------------------------------------------------------------------------------------------        
            recommencer = "liste";
            while (recommencer == "liste")
                {                
                System.out.println("Combien voulez vous entrer de nombre ?");
                nbNombres = isInt();
                System.out.println("\nMerci vous pouvez maintenant entrer les " + nbNombres + " nombres entiers " 
                    + "que vous voulez (validez avec entrée apres chacun d'eux)");
                nbNegatifs = 0;
                tabNb = new int [nbNombres];
     
                //Récupération des nombres entrés dans un tableaux et accompagnement de la saisie 
                for (int i = 0; i < nbNombres; i++)
                    {    
                    tabNb[i] = isInt();
                    if ((i != 0 && i != nbNombres-1) || i == 0)
                        {
                        System.out.println("il reste " + (nbNombres - (i + 1)) + " nombres à taper,");
                        }
                    else 
                        {
                        System.out.println("\n");
                        }//fin if
                    if (tabNb[i] < 0)
                        {
                        nbNegatifs++;    
                        }
                    }//for
                recommencer = "operation";
                while (recommencer == "operation")
                    {
                    System.out.println("\nTapez le numéro correspondant à l'opération que vous souhaitez réaliser  :\n"
                        + "1 - Calculer le pourcentage d'entiers négatifs entrés\n"
                        + "2 - Calculer le pourcentage d'entiers positifs entrés\n"
                        + "3 - Faire la moyenne de tous les entiers entrés\n"
                        + "4 - Additionner tous les entiers entrés\n");
                    choix = 0;
                    while (choix != 1 && choix != 2 && choix != 3 && choix != 4)
                        {
                        choix = isInt();
                        if (choix != 1 && choix != 2 && choix != 3 && choix != 4)
                            {
                            System.out.println("Ce choix n'est pas disponible, veuillez rééssayer");
                            }
                        }
     
                    switch(choix)
                        {
                        case 1:
                            pourPosNeg(false, nbNegatifs, nbNombres);
                        break;
                        case 2:
                            nbPositifs = nbNombres - nbNegatifs;
                            pourPosNeg(true, nbPositifs, nbNombres);
                        break;
                        case 3:
                            moyenne = moyenne(tabNb);
                            System.out.println("La moyenne des entiers de la liste vaut : " + moyenne + "\n");
                            break;
                        case 4:
                                addition = addition(tabNb);
                            System.out.println("La somme des entiers de la liste vaut : " + addition + "\n");
                        break;
     
                        default:
                            System.out.println("Ce cas n'existe pas!");
                        break;
                        }// switch
     
                    System.out.println("Si vous souhaitez faire des opérations sur une autre liste de nombre tapez 'liste', \n" 
                        + "si vous voulez faire une autre opération sur la même liste tapez 'opération', \n" 
                        + "enfin si vous voulez arreter, tapez 'arrêter' !");
     
                    //récupération de l'entrée clavier et convertion en minuscule des attendus opération, liste ou arrêter
                    recommencer = "arreter";
                    boolean bListe = false;
                    boolean bArreter = false; 
                    boolean bOperation = false;
                    try
                        {    
                        while (!bListe && !bOperation && !bArreter)
                            {
                            String again = in.readLine();    
     
                            Pattern pListe = Pattern.compile("liste",Pattern.CASE_INSENSITIVE);
                            Matcher mListe = pListe.matcher(again);
                            bListe = mListe.matches();
     
                            Pattern pOperation = Pattern.compile("op[eé]ration",Pattern.CASE_INSENSITIVE);
                            Matcher mOperation = pOperation.matcher(again);
                            bOperation = mOperation.matches();
     
                            Pattern pArreter = Pattern.compile("arr[eê]ter",Pattern.CASE_INSENSITIVE);
                            Matcher mArreter = pArreter.matcher(again);
                            bArreter = mArreter.matches();
     
                            if(bListe)
                                {
                                recommencer = "liste";
                                }
                            else if (bOperation)
                                {
                                recommencer = "operation";
                                }                    
                            else if (!bArreter)
                                {
                                System.out.println("Vous avez entré " + again 
                                    + ", vous devez entrer liste, operation ou arreter !");
                                }
                            }//while (!bListe && !bOperation && !bArreter)
                        }//try
                    catch (IOException e)
                        {
                            System.out.println("IOException");
                           }                
                    }// while(recommencer == "operation")
                }// while (recommencer == "liste")        
            System.out.println("\nMerci d'avoir utilisé ce programme !\n");
            }//public static void main (String args[])     
     
     
     
        ////////////////////////////
        //propriétées et méthodes //
        ////////////////////////////
     
     
        static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
     
        /**********************************************************************
         * Methode isInt()
         * 
         * vérification que l'entrée clavier est bien un entier
         * 
        ***********************************************************************/ 
        public static int isInt()
            {
            boolean ok = false;
            int i = 0;
            while (!ok)    
                {
                try 
                    {
                    String tmp = in.readLine();
                    i = Integer.parseInt(tmp);    
                    ok = true;
                       }
                catch (IOException e)
                    {
                    System.out.println("IOException");
                       }
                catch (NumberFormatException e)
                    { 
                       System.out.println("Vous devez entrer un entier !");
                    }
                }//while
            return i;     
            }//public static int isInt()
     
        /*******************************************************************
         * Methode pourPosNeg()
         * 
         * Calcul du pourcentage de concernes sur total et affichage d'une 
         * pharse annoncant le resultat
         * 
        ********************************************************************/
        public static void pourPosNeg(boolean positifs, int concernes, int total)
            {
            float pourcentage = concernes * 100 / total;
            if (positifs = true)
                {
                if (concernes == 0)
                    {
                    System.out.println("Vous n'avez pas entré de nombre positif, le pourcentage est donc nul!");    
                    }
                else
                    {
                    System.out.println(pourcentage + "% (" 
                    + concernes + "/" + total + ") des " + total + " entiers entrés sont "
                    + "des nombres positifs.\n\n");
                    }
                }
            else
                {
                if (concernes == 0)
                    {
                    System.out.println("Vous n'avez pas entré de nombre négatif, le pourcentage est donc nul!");    
                    }
                else
                    {
                    System.out.println(pourcentage + "% (" 
                    + concernes + "/" + total + ") des " + total + " entiers entrés sont "
                    + "des nombres négatifs.\n\n");
                    }
                }
            }
     
        /*******************************************************************
         * Methode moyenne()
         * 
         * Calcul et retour de la moyenne des valeurs contenu dans le tableau 
         * entré en argument
         * 
        ********************************************************************/
        public static float moyenne(int [] tab)
            {
            int total = 0;
            int i = 0;
            float moyenne;
            for (i = 0; i < tab.length; i++)
                {
                total += tab[i];
                }
            moyenne = (float)total/(float)tab.length;
            return moyenne;
            }
     
        /*******************************************************************
         * Methode addition()
         * 
         * Calcul et retour de la somme des valeurs contenu dans le tableau 
         * entré en argument
         * 
        ********************************************************************/
        public static int addition(int [] tab)
            {
            int total = 0;
            for (int i = 0; i < tab.length; i++)
                {
                total += tab[i];    
                }
            return total;
            }
     
        }//public class PourcentageNbNegatifs2
    Tout vos commentaires sont les bienvenus.

    Merci d'avance pour votre aide.

  2. #2
    Membre chevronné
    Avatar de CheryBen
    Inscrit en
    Mai 2005
    Messages
    1 599
    Détails du profil
    Informations personnelles :
    Âge : 42

    Informations forums :
    Inscription : Mai 2005
    Messages : 1 599
    Points : 2 197
    Points
    2 197
    Par défaut
    Bonjour,

    1) Tout d'abord, comme tu le soulignais, l'indentation est très mal faite (c'est peut-être en partie du au copié/coller dans le forum). Un IDE comme Eclipse permet d'indenter automatiquement le code.
    Il y a 2 façons de faire les blocs :
    - soit on mets la 1ère accolade au même niveau que la déclaration du bloc, mais sur la ligne en-dessous.
    - soit on la mets sur la même ligne, et on met l'accolade fermante au même niveau que le nom du bloc.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    public static int addition(int [] tab)
    {
        int total = 0;
        for (int i = 0; i < tab.length; i++) {
            total += tab[i];
        }
        return total;
    }
    2) Ensuite, tu as une ENORME méthode main, essai de la découper en plusieurs méthodes, cela facilitera la relecture et le débuggage.

    3) Tu recompiles chaque fois tes Pattern, est-ce vraiment utile? il me semble qu'ils ne changent pas entre 2 itérations de boucle.

    4) Pour comparer des String, il faut utiliser la méthode equals(). Voir la FAQ : Comment comparer des chaînes de caractères ?

    Ça fait déjà pas mal, au niveau conception, je pense qu'il y a moyen d'améliorer mais j'ai un peu de mal à y voir clair dans ton code avec cette énorme méthode et la mauvaise indentation.

  3. #3
    Membre expérimenté
    Profil pro
    Inscrit en
    Mai 2004
    Messages
    1 252
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Mai 2004
    Messages : 1 252
    Points : 1 419
    Points
    1 419
    Par défaut
    Tout d'abord, tu peux réutiliser les méthodes que tu écris :

    public static int moyenne(int[] tab) peut être réécrit de cette manière :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    public static int moyenne (int[] tab) {
      if (tab.length == 0)
        return 0;
      return addition(tab) / tab.length;
    }
    Ensuite, tu forces l'utilisateur à entrer N nombres. Pourquoi ne pas lui laisser le choix du nombre de nombres sans avoir à entrer le nombre N au départ ? Ceci est facilement réalisable avec les listes au lieu d'un tableau. 'fin bon, ça change peut-être l'énoncé du problème...

  4. #4
    regseb
    Invité(e)
    Par défaut
    Salut,

    1) Il est conseillé d'écrire des lignes de moins de 80 caractères. C'est plus facile à lire ; Quand tu imprimes, il n'y pas de retour à la ligne ; Et certains éditeurs n'ont pas une fenêtre assez large pour afficher et il faut utiliser la barre de défilement pour lire la fin de la ligne.
    Il est aussi conseillé d'utiliser des espaces à la place des tabulations. Car certains personnes utilisent des tabulations de 2, 4 ou 8 espaces et dans ce cas là ton code est "déformé".

    2) Si un bloc d'un if ou d'une boucle contient une seule instruction, les accolades sont facultatives.

    3) Il est conseillé de déclarer les variables quand tu en as besoin et non en début de programme. Ça optimise ton programme et tu repères plus facilement les variables non utilisées. Dans ton code la variable pourcentageNegatifs est inutile.

    4) Tu utilises souvent des variables de transition qui sont inutiles. Tu peux remplacer le code suivant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    moyenne = moyenne (tabNb);
    System.out.println ("La moyenne des entiers de la liste vaut : "
                        + moyenne + "\n");
    par
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    System.out.println ("La moyenne des entiers de la liste vaut : "
                        + moyenne (tabNb)+ "\n");
    5) Lors de la capture d'une exception, c'est plus facile de déboguer si la trace est affichée. Par exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    catch (final IOException p_exc) {
        p_exc.printStackTrace ();
    }
    6) Dans la méthode pourPosNeg (), la division des entiers (concernes * 100) et total retourne un entier et non un float. Pour avoir un float en retour, il suffit de convertir un des nombres en float. Le f après le 100 indique que la variable est un flottant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    final float pourcentage = concernes * 100f / total;
    Ensuite dans le premier if, tu ne compares par la variable positifs à true, mais tu affectes true à positifs. Il faut l'opérateur ==. Mais comme tu compares des booléen, la ligne suivante suffit :
    7) Après que l'utilisateur est entré son choix, tu vérifies que le choix est valide 3 : dans le while, dans le if et dans le switch. Voici un code où le choix n'est vérifié qu'une seule fois :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    30
    31
    32
    33
    34
    35
    36
                    System.out.println ("\n"
                        + "Tapez le num\u00E9ro correspondant \u00C0 "
                          + " l'op\u00E9ration que vous souhaitez r\u00E9aliser"
                          + " :\n"
                        + "1 - Calculer le pourcentage d'entiers n\u00E9gatifs"
                          + " entr\u00E9s\n"
                        + "2 - Calculer le pourcentage d'entiers positifs"
                          + " entr\u00E9s\n"
                        + "3 - Faire la moyenne de tous les entiers entr\u00E9s\n"
                        + "4 - Additionner tous les entiers entr\u00E9s\n");
                    while (true) {
                        switch (isInt ()) {
                          case 1:
                            pourPosNeg (false, nbNegatifs, nbNombres);
                            break;
                          case 2:
                            pourPosNeg (true, nbNombres - nbNegatifs, nbNombres);
                            break;
                          case 3:
                            System.out.println (
                                "La moyenne des entiers de la liste vaut : "
                                + moyenne (tabNb) + "\n");
                            break;
                          case 4:
                            System.out.println (
                                "La somme des entiers de la liste vaut : "
                                + addition (tabNb) + "\n");
                            break;
                          default:
                            System.out.println (
                                "Ce choix n'est pas disponible, veuillez"
                                + " r\u00E9\u00E9ssayer\n");
                            continue;
                        } // switch (isInt ())
                        break;
                    } // while (true)
    regseb

  5. #5
    Expert confirmé
    Avatar de RomainVALERI
    Homme Profil pro
    POOête
    Inscrit en
    Avril 2008
    Messages
    2 652
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : POOête

    Informations forums :
    Inscription : Avril 2008
    Messages : 2 652
    Points : 4 164
    Points
    4 164
    Par défaut
    Citation Envoyé par CheryBen Voir le message
    1) Tout d'abord, comme tu le soulignais, l'indentation est très mal faite (c'est peut-être en partie du au copié/coller dans le forum)
    Non c'est un style, disons "minoritaire", mais tout-à-fait existant et formalisé sous le doux nom de Whitesmiths style ^^

    (perso je suis plutôt BSD moi aussi comme la plupart des developpeurs java, mais je voulais juste dire que ce n'était pas du copier-coller qui était à l'origine de cette douleur dans tes yeux )

    ...pour les linguistes et les curieux >>> générateur de phrases aléatoires

    __________________

  6. #6
    Membre du Club
    Profil pro
    Inscrit en
    Août 2006
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 99
    Points : 62
    Points
    62
    Par défaut
    Wow que de réponse plus complete les unes que les autres!

    Pour commencer par le debut qui est aussi la fin

    Je confirme ce que dis Romain Valeri, c'est bien le style Whitesmith que j'utilise, pour une simple raison , c'est que je trouve ca plus lisible et logique ( mais j'ai peut etre une logique particuliere).
    Cependant cheryben, tu fais bien de le souligner, c'est un point interessant.

    (perso je suis plutôt BSD moi aussi comme la plupart des developpeurs java, mais je voulais juste dire que ce n'était pas du copier-coller qui était à l'origine de cette douleur dans tes yeux )
    Donc BSD est le style le plus populaire en java? c'est pas K&R ou allman ?
    Moi la douleur dans les yeux c'est le BSD qui me la fait

    tu as une ENORME méthode main, essai de la découper en plusieurs méthodes, cela facilitera la relecture et le débuggage.
    Alors là je dis oui, je viens de php ou je codais en procédurale, d'ou l'ENORME methode , d'ou aussi le fait que je sache pas trop comment séparer tout ca, je dois faire une methode pour chaque action que je veux faire? je vais essayer ce week end.

    Tu recompiles chaque fois tes Pattern, est-ce vraiment utile? il me semble qu'ils ne changent pas entre 2 itérations de boucle.
    Euh non tout a fait, merci !

    Pour comparer des String, il faut utiliser la méthode equals().
    Oui tu as raison, et la question qui me vient a l'esprit c'est , pourquoi ca marche ?


    @dingoth

    public static int moyenne(int[] tab) peut être réécrit de cette manière :
    En effet c'est mieux que tout refaire! je pensais betement qu'il est mieux de garder les methodes complement independantes les unes des autres, mais comme elles sont toutes dans la meme classe toute facon, tu as raison !

    Ensuite, tu forces l'utilisateur à entrer N nombres. Pourquoi ne pas lui laisser le choix du nombre de nombres sans avoir à entrer le nombre N au départ ? Ceci est facilement réalisable avec les listes au lieu d'un tableau.
    Oui alors euh je connais pas du tout les listes dont tu parles , c'est sans doute le pourquoi de la chose , j'vais m'documenter


    @regseb

    1) ok je note pour les lignes de 80 caractères, Pour l'indentation je pensais naivement que lors de l'enregistrement du fichier la tabulation etait automatiqueemnt converti en espace , je mettrais 2 espaces dorénavant.

    2) accolade facultative sur les if: ca j'ai beau le savoir j'arrive pas m'y faire ):

    3) Il est conseillé de déclarer les variables quand tu en as besoin et non en début de programme. Ça optimise ton programme et tu repères plus facilement les variables non utilisées. Dans ton code la variable pourcentageNegatifs est inutile.
    ahah, ben d'habitude je fais pas comme ca , mais avec cette super syntaxe, "int var,var2 .. var15" je me suis dit que ce serait bien plus pratique! mais tu as sans doute raison.

    Dans ton code la variable pourcentageNegatifs est inutile.
    contren exemple parfait de ce que je pensais juste au dessus, cette variable etait pour l'utilisation d'une methode qui n'existe plus.

    4) methode dans une string : tres interessant ca, et bien plus rapide que la variable de transition en effet.

    5)pour les exception on l'a pas vu en cour et je me suis pas mal avancé , j'ai pas encore tout saisie, faut que je bosse ca de plus pres. mais je prends note de ce que tu me dis.

    6)
    le f après le 100 indique que la variable est un flottant :
    Est ce un equivalent du cast "(float)100" ?
    Est ce aussi utilisable avec une variable ?

    7) merci! j'ai deja vu ce while(true) mais j'avoue pas trop comprendre la chose, logiquement ca devrais faire une boucle infinie non?
    et a quoi ca sert de mettre ca si de toute facon tu break a la fin?
    je connaissait pas l'instruction "continue" pour switch, c'est génial, ca marche pour d'autres condition?



    Bon il me reste plus qu'un truc a dire avant de me replonger dans mon code :
    >>>>>>>>BEAUCOUP

  7. #7
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Tourneur Fraiseur
    Inscrit en
    Avril 2002
    Messages
    4 552
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Tourneur Fraiseur

    Informations forums :
    Inscription : Avril 2002
    Messages : 4 552
    Points : 15 463
    Points
    15 463
    Par défaut
    Donc BSD est le style le plus populaire en java? c'est pas K&R ou allman ?
    En effet BSD est le plus populaire, Allman arrive derrière et les autres sont très rare.

    Oui tu as raison, et la question qui me vient a l'esprit c'est , pourquoi ca marche ?
    Parce pour des raisons d'optimisation Java utilise un cache de String en interne et que quand c'est possible, plutôt que de créer deux instances identique Java utilise la même référence dans les deux variables. Mais le fait que ça marche n'est absolument pas garanti et il y a de nombreux cas ou ça ne marchera pas.

    Est ce un equivalent du cast "(float)100" ?
    C'est en effet équivalent à un "(float)100" mais ce n'est utilisable que sur les nombres dans ton programme.

    merci! j'ai deja vu ce while(true) mais j'avoue pas trop comprendre la chose, logiquement ca devrais faire une boucle infinie non?
    et a quoi ca sert de mettre ca si de toute facon tu break a la fin?
    je connaissait pas l'instruction "continue" pour switch, c'est génial, ca marche pour d'autres condition?
    L'interêt est justement que si on a continue, le break n'a pas lieu et la boucle continue.
    Mais c'est vrai qu'il doit y avoir moyen de faire la chose de manière plus claire. Je ne trouve pas intuitif qu'une boucle ait pour fin normale une interruption.

  8. #8
    Membre du Club
    Profil pro
    Inscrit en
    Août 2006
    Messages
    99
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 99
    Points : 62
    Points
    62
    Par défaut
    Merci homme de l' Est!

    au sujet du switch ca reste pour moi confu presque autant que cette phrase :
    L'interêt est constement que si on a continue le break n'a pas lieu et la boucle continue.
    un peu fatigué peut etre?

    Enfin bref si je reprend un code similaire a celui donné

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
     
    while (true) {
        switch (isInt ()) {
          case 1:
            prog1;
          break;
          case 2:
            prog 2;
          break;
          case 3:
            prog 3;
          break;
          default:
            prog defaut;
          continue;
        } // switch (isInt ())
        break;
    } // while (true)
    On entre dans le while, le switch attends l'entrée clavier,
    si l'utilisateur tape 1 on a le prog 1, si 2 => le prog 2 si 3 => le prog 3, dans ces 3 cas juste apres on sort du switch (break) et on sort automatiquement du while (re-break) ? (a moin qu'il y ait une autre alternative qui ferait l'interet du while ?)

    Et si l'utilisateur tape n'importe quoi d'autre => prog defaut et relancement de la methode du switch en l'occurence switch(isInt()).

    Donc ma question c'est a quoi sert le while (true) puisque le switch gére tous les cas?

    Pour le reste merci de tes eclaircissements Uther!

  9. #9
    Membre éclairé Avatar de unknow0
    Homme Profil pro
    Inscrit en
    Juillet 2008
    Messages
    452
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 452
    Points : 676
    Points
    676
    Par défaut
    Bonjour,

    Le while(true) ne sert que lorsque ce n'est pas un noubre 1 2 ou 3 dans se cas la on recommence a demander un nombre et ce jusqu'a u'on ai un 1 2 ou 3.

    le switch seul ne demanderai qu'une seul fois un nombre et ce quel qu'il soit.

    voila si c'est plus clair

  10. #10
    Expert éminent sénior Avatar de Uther
    Homme Profil pro
    Tourneur Fraiseur
    Inscrit en
    Avril 2002
    Messages
    4 552
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Pyrénées Orientales (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Tourneur Fraiseur

    Informations forums :
    Inscription : Avril 2002
    Messages : 4 552
    Points : 15 463
    Points
    15 463
    Par défaut
    Citation Envoyé par eilijah Voir le message
    un peu fatigué peut etre?
    En effet j'aurais du me relire avant de poster ce truc. Je vais essyer d'être plus clair.

    L'intérêt du while est de recommencer la saisie dans le cas ou on n'aurait pas une valeur valide.

    En effet le continue fait qu'on entame immédiatement un nouveau tour de boucle. On n'atteint donc le break après le switch qui permet de quitter la boucle. Il n'est atteint que si la saisie est valide.

  11. #11
    regseb
    Invité(e)
    Par défaut
    Alors là je dis oui, je viens de php ou je codais en procédurale, d'ou l'ENORME methode , d'ou aussi le fait que je sache pas trop comment séparer tout ca, je dois faire une methode pour chaque action que je veux faire
    Tu peux créer des fonctions pour les codes qui sont inutiles à la compréhension du programme. Par exemple, la méthode utilisée pour collecter les nombres saisis par l'utilisateur et les stocker dans un tableau est inutile à la compréhension globale. Tu peux déporter la boucle for dans une fonction qui retourne un tableau.

    Est ce un equivalent du cast "(float)100" ?
    Oui, mais c'est mieux d'utiliser 100f que (float)100. Car pour (float)100 : tu crée un entier puis tu le convertir en flottant. Alors que pour 100f, tu crée directement en flottant.

    je connaissait pas l'instruction "continue" pour switch, c'est génial, ca marche pour d'autres condition?
    L'instruction continue est associé au while (et non au switch). L'instruction continue indique que le programme doit passer à la prochaine itération de la boucle. Cela permet de court-circuiter le reste du corps de la boucle. continue peut-être aussi utiliser avec la boucle for. Voici un exemple qui affiche tous les nombres de 0 à 20, sauf le nombre 13 (ça porte malheur ) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    for (int i = 0; i <= 20; ++i) {
        if (i == 13) {
            System.out.println ("Le nombre 13 est exclu");
            continue;
        }
        System.out.println (i);
    }
    regseb

Discussions similaires

  1. Mon premier programme java ?
    Par WhiteTigerZ dans le forum Général Java
    Réponses: 7
    Dernier message: 05/07/2010, 11h35
  2. mon premier programme j2me
    Par adilo dans le forum Java ME
    Réponses: 1
    Dernier message: 14/09/2006, 09h43
  3. [JDOM] Mon premier programme java-xml
    Par adilo dans le forum Format d'échange (XML, JSON...)
    Réponses: 3
    Dernier message: 12/07/2006, 14h12
  4. [Language] Aide sur mon premier programme Java?
    Par hash2zo dans le forum Langage
    Réponses: 15
    Dernier message: 27/09/2005, 20h26
  5. [Débutant] Mon premier programme: rien ne va...
    Par vincent0 dans le forum OpenGL
    Réponses: 10
    Dernier message: 02/08/2005, 14h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo