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

 Java Discussion :

Question sur paramètres des méthodes


Sujet :

Java

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2019
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2019
    Messages : 6
    Points : 4
    Points
    4
    Par défaut Question sur paramètres des méthodes
    Bonjour

    Est-ce que vous pouvez m'aider avec les méthodes qui en utilisent d'autres, qui en utilisent d'autres, (etc.), je ne suis pas sûr d'avoir bien compris comment faire

    J'ai un projet avec l'école où il faut entrer une dimension de pneu et une saison et avec celles-ci on obtient un prix unitaire.
    On rentre après un nombre X de pneus à acheter.
    Avec le prix unitaire et le nombre de pneus on obtient un sous total.
    Il y a un rabais si on achète un certain nombre de pneus.

    Et c'est à partir d'ici que ça marche pu hahahha:

    il y a une méthode sous total rabais, qui est sensée prendre le montant du sous total et enlever le rabais (si jamais le rabais s'applique).
    y a la méthode des taxes qui est sensée prendre le sous total avec le rabais et calculer les taxes.
    et la méthode du montant total qui additionne le sous total et les taxes ensemble.

    Je ne cherche pas que vous faissiez le code pour moi, je veux le faire! Mais j'aimerais juste comprendre comment faire comprendre à ma méthode X que la valeur retournée dans la méthode Y, qui a retournée une méthode utilisée dans une méthode Z, sera utilisée dans la méthode X.

    Je sais vrm pas si je suis clair :/ je vous laisse le code ci-dessus, merci encore!
    Je peux clarifier si jamais!

    Merci de m'expliquer comment bien utiliser les "return" et les paramètres dans les méthodes! J'ai vu qqs exemples sur Internet, mais quand c'est aussi compliqué et empilé comme dans ce devoir je ne comprends plus ahahaha

    ---

    Toutes les méthodes marchent individuellement, mais je ne comprend pas comment les "lier". Voici ce que j'ai fait:

    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
     
    //3. on calcule (et retourne) le sous total de la facture, en fonction du prix unitaire du modèle choisit et du nombre de pneus demandés
        public static double calculSoustotal (double calculPrixUnitaire, int nombrePneus){
            double calculSoustotal = calculPrixUnitaire*nombrePneus;
            return calculSoustotal;}
     
        //4. on retourne le diamètre de la jante présent dans la dimension du pneu
        public static String extraireDiametreJate (String dimensionPneu){
            String diametreJante = dimensionPneu.substring(7,9);
            return diametreJante;}
     
            //#5
     
        //6. on calcule (et retourne) le rabais dans la facture en fonction du nombre de pneus achetés
        public static double rabais (String extraireDiametreJate, int nombrePneus){
    rabais = 1;
            if ("14".equals(extraireDiametreJate) || "15".equals(extraireDiametreJate)){
                if (nombrePneus > 4){
                    rabais = 0.15;}}
            if ("16".equals(extraireDiametreJate)){
                if (nombrePneus > 6){
                    rabais = 0.10;}}
            return rabais;}
     
        //7. on calcule (et retourne) le montant du rabais à enlever de la facture 
        public static double calculRabais (double rabais, double calculSoustotal){
            double montantRabais = calculSoustotal*rabais;
            return montantRabais;}
     
        //8. on calcule (et retourne) le sous total de la facture en enlevant le rabais de celle-ci
        public static double calculRabaisSousTotal (double calculRabais, double calculSoustotal){
            double sousTotalRabais = calculSoustotal - montantRabais;
            return sousTotalRabais;}
     
        //9. on calcule (et retourne) le montant du prix de l'installation en fonction du nombre de pneus à installer
        public static double calculSoutTotalInstallation (double prixInstallation, int pneusInstaller){
            double sousTotalInstallation = prixInstallation*pneusInstaller;
            return sousTotalInstallation;}
     
        //10. on calcule (et retourne) le sous total de la facture en comptant le montant de pneus achetés et installés
        public static double calculSousTotalTotal (double calculRabaisSousTotal, double calculSoutTotalInstallation){
            double sousTotalTotal = calculRabaisSousTotal + calculSoutTotalInstallation;
            return sousTotalTotal;}
     
        //11. on calcule (et retourne) le montant de la taxe TPS en fonction du sous total calculé
        public static double taxeTps (double calculSousTotalTotal){
            double taxeTps = calculSousTotalTotal + (calculSousTotalTotal*TAXE_TPS);
            return taxeTps;}
     
        //12. on calcule (et retourne) le montant de la taxe TVQ en fonction du sous total calculé
        public static double taxeTvq (double calculSousTotalTotal){
            double taxeTvq = calculSousTotalTotal + (calculSousTotalTotal*TAXE_TVQ);
            return taxeTvq;}
     
        //13. on calcule (et retourne) le montant total de la facture en additionant le sous total et les deux taxes
        public static double montantTotal (double calculSousTotalTotal, double taxeTps, double taxeTvq){
            return montantTotal;}
    et après quand je l'affiche ça ne marche jamais

    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
     
    //18 (extra). on affiche le message de félicitation s'il y a un rabais
        public static String messageRabais(double calculRabais){
            if (calculRabais >0){
                messageRabais = "-------------------------------------------------------- \n" +
                "Wow, vous avez économisé un total de $ " + calculRabais;
                System.out.println(messageRabais);}
            return messageRabais;   
        }
        //19 (extra). on affiche la facture du rabais
        public static String factureRabais(double calculSoustotal, double calculRabaisSousTotal){
            if (calculRabaisSousTotal != calculSoustotal){
                factureRabais = "Sous-total sans rabais: $" + calculSoustotal + "\n" +
                "Sous-total avec rabais: $" + calculRabaisSousTotal + "\n";
            }else if(calculRabaisSousTotal == calculSoustotal){
                factureRabais = "Sous-total: $" + calculSoustotal;
            }
            return factureRabais;   
        }
        //3.4
        //0 (extra). affichage de l'entête de la facture
        public static String enteteFacture(int numeroFacture, String dateHeure){
            enteteFacture = "Experts-Pneus \n"+
            "Date et heure: " + dateHeure() + "Facture No : " + numeroFacture() + "\n" +
            "2020 rue Hakuna, Matata, QC                     (450) 515 - 0055 \n" +
            "----------------------------------------------- \n" +
            "Description                     Nombre de pneus               Prix unitaire \n";
     
            return enteteFacture;
        }
        //1. on affiche la facture de la vente de pneus (option 1 du menu principal)
        public static void affichageFactureVente(String enteteFacture, String factureRabais, String messageRabais, String dimensionPneu, int nombrePneus, double calculPrixUnitaire, double taxeTps, double taxeTvq, double montantTotal){
            enteteFacture(numeroFacture, dateHeure);
            System.out.println(dimensionPneu + "            " + nombrePneus + "            $" + calculPrixUnitaire);
            System.out.println("");
            System.out.print(factureRabais);
            System.out.println("Montant TPS : $" + taxeTps + "\n" +
                "Montant TVQ : $" + taxeTvq + "\n" +
                "Montant total : $" + montantTotal + "\n" +
                " \n");
            System.out.print(messageRabais);
            System.out.println("--------------------------------------- \n"+
                "Merci pour votre confiance \n");
        }
    pis je mets tout ça dans la méthode main:

    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
     
     //méthode main où toutes les fonctions sont utilisées
        public static void main (String[] params) {
            messageBienvenue();
            resumeProgramme();
            do{
                menuPrincipal();
                choixMenuPrincipal = choixMenu();
                if (choixMenuPrincipal == 1){
                    saisonUtilisation  = saisonUtilisation();
                    dimensionPneu  = dimensionPneu();
                    nombrePneus = nombrePneus();
                    System.out.println("Désirez-vous entrer une nouvelle facture?");
                    affichage1 = 1;
                }else if( choixMenuPrincipal == 2){
                    do{
                        menuInstallation();
                        choixMenuInstallation = choixMenuInstallation();
                        if (choixMenuInstallation == 1){
                            pneusInstaller = nombrePneusInstaller();
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
     
                        }else if(choixMenuInstallation==2){
                            pneusInstaller = nombrePneusInstaller();                
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
                        }
                    }while (choixMenuInstallation != 0);
                }else if( choixMenuPrincipal == 3){
                    saisonUtilisation  = saisonUtilisation();
                    dimensionPneu  = dimensionPneu();
                    nombrePneus = nombrePneus();
                    affichage1 = 1;
     
                    do{
                        menuInstallation();
                        choixMenuInstallation = choixMenuInstallation();
                        if (choixMenuInstallation == 1){
                            pneusInstaller = nombrePneusInstaller();
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
     
                        }else if(choixMenuInstallation==2){
                            pneusInstaller = nombrePneusInstaller();                
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
     
                        }
                    }while (choixMenuInstallation != 0);
                }else if( choixMenuPrincipal == 4){ //## a entender##
                    affichageFacture(dateHeure(), dimensionPneu, nombrePneus);
                }
            } while(choixMenuPrincipal !=0);
     
            if (affichage1 > 0 && affichage2 == 0){
                affichageFactureVente(enteteFacture(numeroFacture(), dateHeure()), factureRabais(calculSoustotal(calculPrixUnitaire(dimensionPneu, saisonUtilisation), nombrePneus), calculRabaisSousTotal(montantRabais, calculSoustotal)), messageRabais(calculRabais(rabais, calculSoustotal)),dimensionPneu, nombrePneus, calculPrixUnitaire(dimensionPneu, saisonUtilisation), taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)));
            }
            else if(affichage1 == 0 && affichage2 > 0){
                affichageFactureInstallation(factureRabais, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)), enteteFacture, descriptionInstallationPneu(choixMenuInstallation), calculPrixInstallation(choixMenuInstallation), pneusInstaller);
            }else if(affichage1 > 0 && affichage2 > 0){
                affichageFactureDouble(factureRabais, messageRabais, enteteFacture, dimensionPneu, descriptionInstallationPneu(choixMenuInstallation), calculPrixInstallation(choixMenuInstallation), nombrePneus, pneusInstaller, calculPrixUnitaire(dimensionPneu, saisonUtilisation), calculSoustotal(calculPrixUnitaire(dimensionPneu, saisonUtilisation), nombrePneus), calculRabaisSousTotal(montantRabais, calculSoustotal), calculRabais, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)));
            }
     
        }
    si jamais vous voulez tout le code pour mieux voir le voici, la classe Clavier c'est une classe Scanner obligatoire dans notre uni:
    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
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    public class Tp2Inf1120Grpe21A2019 {
        //declaration de variables et constantes
        public static String dimensionPneu = "";
        public static String saisonUtilisation = "";
        public static int choixMenuInstallation;
        public static int choixMenuPrincipal;
        public static double prixUnitaire;
        public static int nombrePneus;
        public static String diametreJante; //##inutile??
        public static double rabais = 1;
        public static double calculSoustotal;
        public static double montantRabais;
        public static double prixInstallation;
        public static int pneusInstaller;
        public static double calculSousTotalInstallation;
        public static double calculSousTotalTotal;
        public static final double TAXE_TPS = 0.05;
        public static final double TAXE_TVQ = 0.09975;
        public static double calculRabais;
        public static int numeroFacture = 0;
        public static String dateHeure;
        public static int choix;
        public static String descriptionInstallation = "";
        public static String messageRabais = "";
        public static String factureRabais = "";
        public static String enteteFacture = "";
        public static int affichage1 = 0;
        public static int affichage2 = 0;
        public static int affichage3 = 0;
        public static double calculPrixUnitaire;
    
        //3.2
        //1. message de bienvenue
        public static void messageBienvenue(){
            System.out.println("Bienvenue au programme de compilation de facture de Experts-pneus.");}
        //2.resumé du programme
        public static void resumeProgramme(){
            System.out.println("Sous peu, vous allez pouvoir générer des factures pour vos achats de pneus. \n" +
                "On vous demandera d’entrer la saison d’utilisation de vos pneus, le diamètre \n" +
                "de la jante, la longueur du pneu, le numéro de série de celui-ci ainsi que \n" +
                "la quantité désirée. Finalement, une facture vous sera affichée. Bons achats.");
        }
        //3. menu principal
        public static void menuPrincipal(){
            System.out.println(" 0: Quitter \n" +
                " 1: Vente de pneus \n" +
                " 2: Installation de pneus \n" +
                " 3: Vente et installation de pneus \n" +
                " 4: Nombre de pneus vendus selon la dimension de pneus \n"+
                " \n");
        }
        //4. choix du menu, on choisit l'un de cinq menus possibles et on retourne le choix
        public static int choixMenu(){
            do{
                System.out.println("Veuillez sélectionner une option de menu valide");
                choix = Clavier.lireIntLn();
    
                if (choix > 4 || choix < 0){
                    System.out.println("Choix de menu principal invalide!");
                }
            } while (choix > 4 || choix < 0);
            return choix;
        }
        //5. saisie de la saison d'utilisation, on saisit la saison d'utilisation et on la retourne
        public static String saisonUtilisation(){
            do{
                System.out.println("Veuillez choisir une saison (H ou h pour hiver, E ou e pour été)");
                saisonUtilisation = Clavier.lireString();
                saisonUtilisation = saisonUtilisation.substring(0,1).toUpperCase();
                if (!"H".equals(saisonUtilisation) && !"E".equals(saisonUtilisation)){
                    System.out.println("Saison d’utilisation des pneus invalide!");
                }
            }while (!"H".equals(saisonUtilisation) && !"E".equals(saisonUtilisation));
    
            return saisonUtilisation;
        }
        //6. saisie de la dimension du pneu, on saisit la dimension désirée, si le modèle (000/00R00) n'est pas respecté on affiche erreur, 
        //et si la dimension n'existe pas on l'affiche aussi. On retourne la dimension du pneu
        public static String dimensionPneu(){
            boolean pasSortir = true;
            do{
                System.out.println("Veuillez écrire une dimension de pneu de cette forme: \n" +
                    "largeur du pneu + / + serie du pneu + R + diamètre de la jante. \n" +
                    "Par exemple, 175/65R14");
                dimensionPneu = Clavier.lireString();
                int longueur = dimensionPneu.length();
    
                if(longueur == 9){
    
                    char slash = dimensionPneu.charAt(3);
                    char r = dimensionPneu.charAt(6);
                    String largeurPneu = dimensionPneu.substring(0,3);
                    String seriePneu = dimensionPneu.substring(4,6);
                    String diametreJante = dimensionPneu.substring(7,9);
    
                    if (slash == '/' && r == 'R'){                                      
    
                        if ("175".equals(largeurPneu)){                                     
    
                            if ("65".equals(seriePneu)){                                       
    
                                if ("14".equals(diametreJante) || "15".equals(diametreJante)){        
    
                                    return dimensionPneu;
                                }else{System.out.println("Cette dimension du pneu n’existe pas dans notre entrepôt!");}
    
                            }else if("185".equals(largeurPneu)){
                                if ("65".equals(seriePneu)){
                                    if ("15".equals(diametreJante)){
                                        return dimensionPneu;
    
                                    }else{System.out.println("Cette dimension du pneu n’existe pas dans notre entrepôt!");}
    
                                }else if("215".equals(largeurPneu)){
                                    if ("65".equals(seriePneu)){
                                        if ("16".equals(diametreJante)){
                                            return dimensionPneu;
                                        }else if ("70".equals(seriePneu)){
                                            if ("16".equals(diametreJante)){
                                                return dimensionPneu;
    
                                            }else{System.out.println("Cette dimension du pneu n’existe pas dans notre entrepôt!");}
    
                                        } else if ("225".equals(largeurPneu)){
                                            if ("70".equals(seriePneu)){
                                                return dimensionPneu;
    
                                            }else{System.out.println("Cette dimension du pneu n’existe pas dans notre entrepôt!");}
    
                                        }else{ 
                                            System.out.println("Cette dimension du pneu n’existe pas dans notre entrepôt!");}
    
                                    }else{ System.out.println("Format de la dimension invalide!");}
                                }}}}
    
                }else{System.out.println("Format de la dimension invalide!");}
    
            }while (pasSortir);
            return dimensionPneu;
        }
        //7. on saisit le nombre de pneus désirées entre 1 et 16, on retourne ce même nombre
        public static int nombrePneus(){
            do{
                System.out.println("Veuillez écrire le nombre de pneus que vous voulez acheter, entre 1 et 16");
                nombrePneus = Clavier.lireIntLn();
    
                if (nombrePneus < 1 || nombrePneus > 16){
                    System.out.println("Nombre de pneus non valide");
                }
            }while (nombrePneus < 1 || nombrePneus > 16);
            return nombrePneus;
        }
        //8. affichage du menu d'installation de pneus
        public static void menuInstallation(){
            System.out.println(" 0: Quitter \n" +
                " 1: Installation des pneus montés sur jantes \n" +
                " 2: Installation des pneus non montés sur jantes\n" +
                " \n");
        }
        //9. choix du menu d'installation de pneus, on choisit entre les trois options et on retourne le choix fait
        public static int choixMenuInstallation(){
            do{
                System.out.println("Veuillez sélectionner une option de menu valide");
                choixMenuInstallation = Clavier.lireIntLn();
    
                if (choixMenuInstallation > 2 || choixMenuInstallation < 0){
                    System.out.println("Choix de menu non valide");
                }
            } while (choixMenuInstallation > 2 || choixMenuInstallation < 0);
            return choixMenuInstallation;
        }
        //10. on saisit le nombre de pneus à installer, on doit les saisir entre 1 et 20. On retourne le choix effectué
        public static int nombrePneusInstaller(){
            do{
                System.out.println("Veuillez écrire le nombre de pneus que vous voulez installer, entre 1 et 20"); 
                pneusInstaller = Clavier.lireIntLn();
                if (pneusInstaller < 1 || pneusInstaller > 20){
                    System.out.println("Nombre de pneus non valide");
                }
            }while (pneusInstaller < 1 || pneusInstaller > 20);                           
            return pneusInstaller;
        }
        //3.3
        //1. on calcule (et retourne) le prix unitaire du modèle de pneu voulu en fonction de sa dimension et de la saison d'utilisation choisie
        public static double calculPrixUnitaire (String dimensionPneu, String saisonUtilisation){
            if ("H".equals(saisonUtilisation)){
                switch (dimensionPneu){
                    case "175/65R14" : prixUnitaire = 131.60;
                    break;
                    case "175/65R15" : prixUnitaire = 148.50;
                    break;
                    case "185/65R15" : prixUnitaire = 141.35;
                    break;
                    case "215/70R16" : prixUnitaire = 177.10;
                    break;
                    case "215/65R16" : prixUnitaire = 182.15;
                    break;
                    case "225/70R16" : prixUnitaire = 181.95;
                    break;
                    default :
                    break;
                }
            }else if ("E".equals(saisonUtilisation)){
                switch (dimensionPneu){
                    case "175/65R14" : prixUnitaire = 110.95;
                    break;
                    case "175/65R15" : prixUnitaire = 120.95;
                    break;
                    case "185/65R15" : prixUnitaire = 125.95;
                    break;
                    case "215/70R16" : prixUnitaire = 150.95;
                    break;
                    case "215/65R16" : prixUnitaire = 159.95;
                    break;
                    case "225/70R16" : prixUnitaire = 160.95;
                    break;
                    default :
                    break;
                }
            }        return prixUnitaire; 
        }
        //2. on calcule (et retourne) le prix d'installation des pneus à installer en fonction du choix dans le menu d'installation
        public static double calculPrixInstallation (int choixMenuInstallation){
            if (choixMenuInstallation == 1){
                prixInstallation = 9.95;
            }else if (choixMenuInstallation == 2){
                prixInstallation = 15.95;
            }
            System.out.println("Calcul prix installation :" + prixInstallation); //###
            return prixInstallation;
        }
        //3. on calcule (et retourne) le sous total de la facture, en fonction du prix unitaire du modèle choisit et du nombre de pneus demandés
        public static double calculSoustotal (double calculPrixUnitaire, int nombrePneus){
            double calculSoustotal = calculPrixUnitaire*nombrePneus;
                    System.out.println("Calcul sousTotal :" + calculSoustotal + "est egal à prix unitaire: " + calculPrixUnitaire + "fois nb de pneus " + nombrePneus); //###
    
            return calculSoustotal;}
        //4. on retourne le diamètre de la jante présent dans la dimension du pneu
        public static String extraireDiametreJate (String dimensionPneu){
            String diametreJante = dimensionPneu.substring(7,9);
                    System.out.println("Extraction du diametre de la jante : " + diametreJante); //###
    
            return diametreJante;}
            
            //#5
    
        //6. on calcule (et retourne) le rabais dans la facture en fonction du nombre de pneus achetés
        public static double rabais (String extraireDiametreJate, int nombrePneus){
            System.out.println(extraireDiametreJate);
            if ("14".equals(extraireDiametreJate) || "15".equals(extraireDiametreJate)){
                if (nombrePneus > 4){
                    rabais = 0.15;}}
            if (diametreJante == "16"){
    
                if (nombrePneus > 6){
    
                    rabais = 0.10;}}
                                    System.out.println("Rabais en fnct de lextraction : " + rabais); //###
    
            return rabais;}
            
        //7. on calcule (et retourne) le montant du rabais à enlever de la facture 
        public static double calculRabais (double rabais, double calculSoustotal){
            double montantRabais = calculSoustotal*rabais;
                rabais ("14", 7);
                extraireDiametreJate (dimensionPneu); //#####
            System.out.println("calcul rabais = calcul sous total * rabais : " + montantRabais + " sous total " + calculSoustotal + " fois rabais " + rabais); //#####
            return montantRabais;}
    
        //8. on calcule (et retourne) le sous total de la facture en enlevant le rabais de celle-ci
        public static double calculRabaisSousTotal (double calculRabais, double calculSoustotal){
            calculRabais (rabais, calculSoustotal);
            calculSoustotal (calculPrixUnitaire, nombrePneus);
            double sousTotalRabais = calculSoustotal - montantRabais;
            System.out.println("calcul rabais TOTAL = calcul sous total MOINS rabais : " + sousTotalRabais + " sous total " + calculSoustotal + " moins rabais " + rabais); //#####
    
    
            return sousTotalRabais;}
        //9. on calcule (et retourne) le montant du prix de l'installation en fonction du nombre de pneus à installer
        public static double calculSoutTotalInstallation (double prixInstallation, int pneusInstaller){
            double sousTotalInstallation = prixInstallation*pneusInstaller;
            System.out.println("calcul sous total installation = prix installation fois pneus installer : " + sousTotalInstallation + " prix installation " + prixInstallation + " pneus a installer " + pneusInstaller); //#####
    
            return sousTotalInstallation;}
        //10. on calcule (et retourne) le sous total de la facture en comptant le montant de pneus achetés et installés
        public static double calculSousTotalTotal (double calculRabaisSousTotal, double calculSoutTotalInstallation){
            double sousTotalTotal = calculRabaisSousTotal + calculSoutTotalInstallation;
            System.out.println("calcul total total = rabais sous total PLUS sous total installation : " + sousTotalTotal + " rabais sous total " + calculRabaisSousTotal + " sous total installation " + calculSoutTotalInstallation); //#####
    
    
            return sousTotalTotal;}
        //11. on calcule (et retourne) le montant de la taxe TPS en fonction du sous total calculé
        public static double taxeTps (double calculSousTotalTotal){
            double taxeTps = calculSousTotalTotal + (calculSousTotalTotal*TAXE_TPS);
                    System.out.println("calcul taxe tps = calcul sous total total plus (sous total total FOIS taxe) : " + taxeTps + " rabais sous total total " + calculSousTotalTotal + " calcul sous total total * taxe tps " + (calculSousTotalTotal*TAXE_TPS)); //#####
    
            return taxeTps;}
        //12. on calcule (et retourne) le montant de la taxe TVQ en fonction du sous total calculé
        public static double taxeTvq (double calculSousTotalTotal){
            double taxeTvq = calculSousTotalTotal + (calculSousTotalTotal*TAXE_TVQ);
                            System.out.println("calcul taxe tvq = calcul sous total total plus (sous total total FOIS taxe) : " + taxeTvq + " rabais sous total total " + calculSousTotalTotal + " calcul sous total total * taxe tvq " + (calculSousTotalTotal*TAXE_TVQ)); //#####
    
            return taxeTvq;}
        //13. on calcule (et retourne) le montant total de la facture en additionant le sous total et les deux taxes
        public static double montantTotal (double calculSousTotalTotal, double taxeTps, double taxeTvq){
            double montantTotal = calculSousTotalTotal + taxeTps + taxeTvq;
                    System.out.println("montant total = sous total total plus taxes : " + montantTotal + " calculSousTotalTotal " + calculSousTotalTotal + " taxes tps tvq " + taxeTps + " " + taxeTvq); //#####
    
            return montantTotal;}
        //14. on calcule (et retourne) la date et l'heure du système au moment de l'achat
        public static String dateHeure(){
            LocalDateTime dateHeureSysteme = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
            String dateHeure = dateHeureSysteme.format(formatter);
            return dateHeure;}
        //15. on définit la description détaillée du pneu en fonction de sa dimension et de la saison saisie, on retourne cette description
        public static String descriptionPneu (String dimensionPneu, String saisonUtilisation){
            if (saisonUtilisation == "H"){
                saisonUtilisation = "Hiver";
            }else if (saisonUtilisation == "E"){
                saisonUtilisation = "Été";
            }
            String diametreJante = dimensionPneu.substring(7,8);
            String descriptionPneu = dimensionPneu + " – Pneu " + saisonUtilisation + " de " + diametreJante + "  pouces.";
            return descriptionPneu;   
        }
        //16. on définit la description de l'installation des pneus en fonction du choix de menu d'installation, on retourne cette description
        public static String descriptionInstallationPneu (int choixMenuInstallation){
            if (choixMenuInstallation == 1){
                descriptionInstallation = "Installation de pneus montés sur jantes";
            }else if (choixMenuInstallation == 2){
                descriptionInstallation = "Installation de pneus non montés sur jantes";
            }
            return descriptionInstallation;   
        }
        //17 (extra). on calcule le numéro de la facture
        public static int numeroFacture (){
            return numeroFacture;}
        //18 (extra). on affiche le message de félicitation s'il y a un rabais
        public static String messageRabais(double calculRabais){
            if (calculRabais >0){
                messageRabais = "-------------------------------------------------------- \n" +
                "Wow, vous avez économisé un total de $ " + calculRabais;
                System.out.println(messageRabais);}
                System.out.println("calcul rabais das string message rabais : " + calculRabais); //##########
            return messageRabais;   
        }
        //19 (extra). on affiche la facture du rabais
        public static String factureRabais(double calculSoustotal, double calculRabaisSousTotal){
            if (calculRabaisSousTotal != calculSoustotal){
                factureRabais = "Sous-total sans rabais: $" + calculSoustotal + "\n" +
                "Sous-total avec rabais: $" + calculRabaisSousTotal + "\n";
            }else if(calculRabaisSousTotal == calculSoustotal){
                factureRabais = "Sous-total: $" + calculSoustotal;
            }
            System.out.println("FACTURE RABAIS " + calculRabaisSousTotal + " c t rabais sous total, et mtn sous total : " + calculSoustotal); //#####
            return factureRabais;   
        }
        //3.4
        //0 (extra). affichage de l'entête de la facture
        public static String enteteFacture(int numeroFacture, String dateHeure){
            enteteFacture = "Experts-Pneus \n"+
            "Date et heure: " + dateHeure() + "Facture No : " + numeroFacture() + "\n" +
            "2020 rue Hakuna, Matata, QC                     (450) 515 - 0055 \n" +
            "----------------------------------------------- \n" +
            "Description                     Nombre de pneus               Prix unitaire \n";
            
            return enteteFacture;
        }
        //1. on affiche la facture de la vente de pneus (option 1 du menu principal)
        public static void affichageFactureVente(String enteteFacture, String factureRabais, String messageRabais, String dimensionPneu, int nombrePneus, double calculPrixUnitaire, double taxeTps, double taxeTvq, double montantTotal){
            enteteFacture(numeroFacture, dateHeure);
            System.out.println(dimensionPneu + "            " + nombrePneus + "            $" + calculPrixUnitaire);
            System.out.println("");
            System.out.print(factureRabais);
            System.out.println("Montant TPS : $" + taxeTps + "\n" +
                "Montant TVQ : $" + taxeTvq + "\n" +
                "Montant total : $" + montantTotal + "\n" +
                " \n");
            System.out.print(messageRabais);
            System.out.println("--------------------------------------- \n"+
                "Merci pour votre confiance \n");
        }
      
        //2. on affiche la facture de l'installation de pneus (option 2 du menu principal)
        public static void affichageFactureInstallation(String factureRabais, double taxeTps, double taxeTvq, double montantTotal, String enteteFacture, String descriptionInstallationPneu, double calculPrixInstallation, int nombrePneusInstaller){
            System.out.println(enteteFacture);
            System.out.println(descriptionInstallationPneu + nombrePneusInstaller + " $" + calculPrixInstallation);
            System.out.println("");
            System.out.print(factureRabais);
            System.out.println("Montant TPS : $" + taxeTps + "\n" +
                "Montant TVQ : $" + taxeTvq + "\n" +
                "Montant total : $" + montantTotal + "\n" +
                " \n");
            System.out.println("--------------------------------------- \n"+
                "Merci pour votre confiance \n");
        }
        //3. on affiche la facture de la vente et de l'installation de pneus (option 3 du menu principal)
        public static void affichageFactureDouble (String factureRabais, String messageRabais, String enteteFacture, String dimensionPneu, String descriptionInstallationPneu, double calculPrixInstallation, int nombrePneus, int nombrePneusInstaller, double calculPrixUnitaire, double calculSousTotal, double calculRabaisSousTotal, double calculRabais, double taxeTps, double taxeTvq, double montantTotal){
            String entete = enteteFacture;
            String dimension = dimensionPneu;
            int nombre = nombrePneus;
            double prixUnit = calculPrixUnitaire;
    
            System.out.print(enteteFacture);
            System.out.println(dimension + nombre + " $" + prixUnit);
            System.out.println(descriptionInstallationPneu + nombrePneusInstaller + " $" + calculPrixInstallation);
            System.out.println("");
            System.out.print(factureRabais);
            System.out.println("Montant TPS : $" + taxeTps + "\n" +
                "Montant TVQ : $" + taxeTvq + "\n" +
                "Montant total : $" + montantTotal + "\n" +
                " \n");
            System.out.print(messageRabais);
            System.out.println("--------------------------------------- \n"+
                "Merci pour votre confiance \n");
        }
        //4. on affiche le nombre de pneus selon leur dimension
        public static void affichageFacture(String dateHeure, String dimensionPneu, int nombrePneus){
            System.out.println("Experts-Pneus");
            System.out.println("Date et heure: " + dateHeure());
            System.out.println("Dimension               Nombre de pneus vendus");
            System.out.println(); //###a entender, afichar 6 ultimos
        }
    
        //méthode main où toutes les fonctions sont utilisées
        public static void main (String[] params) {
            messageBienvenue();
            resumeProgramme();
            do{
                menuPrincipal();
                choixMenuPrincipal = choixMenu();
                if (choixMenuPrincipal == 1){
                    saisonUtilisation  = saisonUtilisation();
                    dimensionPneu  = dimensionPneu();
                    nombrePneus = nombrePneus();
                    System.out.println("Désirez-vous entrer une nouvelle facture?");
                    affichage1 = 1;
                }else if( choixMenuPrincipal == 2){
                    do{
                        menuInstallation();
                        choixMenuInstallation = choixMenuInstallation();
                        if (choixMenuInstallation == 1){
                            pneusInstaller = nombrePneusInstaller();
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
    
                        }else if(choixMenuInstallation==2){
                            pneusInstaller = nombrePneusInstaller();                
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
                        }
                    }while (choixMenuInstallation != 0);
                }else if( choixMenuPrincipal == 3){
                    saisonUtilisation  = saisonUtilisation();
                    dimensionPneu  = dimensionPneu();
                    nombrePneus = nombrePneus();
                    affichage1 = 1;
    
                    do{
                        menuInstallation();
                        choixMenuInstallation = choixMenuInstallation();
                        if (choixMenuInstallation == 1){
                            pneusInstaller = nombrePneusInstaller();
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
    
                        }else if(choixMenuInstallation==2){
                            pneusInstaller = nombrePneusInstaller();                
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
    
                        }
                    }while (choixMenuInstallation != 0);
                }else if( choixMenuPrincipal == 4){ //## a entender##
                    affichageFacture(dateHeure(), dimensionPneu, nombrePneus);
                }
            } while(choixMenuPrincipal !=0);
            
            if (affichage1 > 0 && affichage2 == 0){
                affichageFactureVente(enteteFacture(numeroFacture(), dateHeure()), factureRabais(calculSoustotal(calculPrixUnitaire(dimensionPneu, saisonUtilisation), nombrePneus), calculRabaisSousTotal(montantRabais, calculSoustotal)), messageRabais(calculRabais(rabais, calculSoustotal)),dimensionPneu, nombrePneus, calculPrixUnitaire(dimensionPneu, saisonUtilisation), taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)));
            }
            else if(affichage1 == 0 && affichage2 > 0){
                affichageFactureInstallation(factureRabais, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)), enteteFacture, descriptionInstallationPneu(choixMenuInstallation), calculPrixInstallation(choixMenuInstallation), pneusInstaller);
            }else if(affichage1 > 0 && affichage2 > 0){
                affichageFactureDouble(factureRabais, messageRabais, enteteFacture, dimensionPneu, descriptionInstallationPneu(choixMenuInstallation), calculPrixInstallation(choixMenuInstallation), nombrePneus, pneusInstaller, calculPrixUnitaire(dimensionPneu, saisonUtilisation), calculSoustotal(calculPrixUnitaire(dimensionPneu, saisonUtilisation), nombrePneus), calculRabaisSousTotal(montantRabais, calculSoustotal), calculRabais, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)));
            }
    
        }
    
    }

  2. #2
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    septembre 2009
    Messages
    11 922
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2009
    Messages : 11 922
    Points : 28 183
    Points
    28 183
    Billets dans le blog
    2
    Par défaut
    Salut,

    Citation Envoyé par pedro2163 Voir le message
    Mais j'aimerais juste comprendre comment faire comprendre à ma méthode X que la valeur retournée dans la méthode Y, qui a retournée une méthode utilisée dans une méthode Z, sera utilisée dans la méthode X.
    Pour utiliser la valeur retournée par une méthode, il suffit de l'appeler, ce que tu fais déjà, donc tu sais comment. Pour chaîner, c'est pareil.

    Mettons que tu as une méthode :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    public static int fois2(int n) {
        return n*2; // retourne la valeur du paramètre multiplié par 2
    }
    et une autre méthode :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    public static int plus(int a, int b) {
        return a+b; // retourne la somme des valeurs des deux paramètres
    }
    Pour utiliser cette méthode :
    ou sur une variable, n par exemple :
    15 comme n ce sont des expressions. En expression, on peut mettre un calcul (c'est le résultat du calcul qui sera utilisé comme valeur passée en paramètre) :
    et on peut mettre aussi un appel de méthode (c'est le retour de cette méthode qui sera utilisé comme valeur passée en paramètre).
    Evidemment, on peut combiner. Tant que ce sont des expressions valables syntaxiquement pour Java (et que les méthodes sont bien accessibles) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    fois2( plus(n,5) + fois2( n - 18 + fois1(plus(n,n)) );

    Une méthode peut aussi appeler une autre méthode :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    public static int calcul(int a, int b) {
        return plus( fois2(a) , b); // multiplie a par 2 puis l'ajouter à b et retourne le résultat
    }
    Tu peux passer par une variable intermédiaire si tu veux :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public static int calcul(int a, int b) {
        int intermediaire = fois2(a); // multiplie a par 2 et stocke le résultat dans intermediaire
        return plus( intermediaire , b); //  puis ajoute b à intermediaire et retourne le résultat
    }
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  3. #3
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    septembre 2009
    Messages
    11 922
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2009
    Messages : 11 922
    Points : 28 183
    Points
    28 183
    Billets dans le blog
    2
    Par défaut
    J'ai regardé un peu plus tout ton code. Je n'ai pas trop le temps pour l'instant d'approfondir en détail mais j'ai vu deux ou trois petites choses :

    Tu écris souvent, pour ne pas dire tout le temps, des méthodes sous cette forme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    public String methodeMachin() {
     
          variable = machinTruc(); // ici un appel à la classe Clavier, ou expression calculée, ou autre, peu importe
          // du code éventuellement
         return variable;
     
    }
    avec variable déclarée en static dans la classe Tp2Inf1120Grpe21A2019 que tu utilises en direct dans d'autres méthodes.

    Alors, on peut procéder comme ça, c'est syntaxiquement correct, mais ça mélange en fait deux fonctionnements différents, et ce mélange peut porter à des confusions, qui concrètement peuvent déclencher des bugs.
    Normalement, soit une méthode retourne un résultat et on peu le stocker dans une variable, de classe, ou locale à une méthode ;

    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
    public class Machin {
     
     
       public static String calculer(String param) {
               String resultat = // on imagine ici un code très compliqué et très long qui aboutit au résultat...
               return resultat ;
       }
     
       private static String unevariable;
     
       public static void main(String[] args) {
               unevariable = calculer("truc");  // on modifie la variable static String unevariable
               String uneautrevariable = calculer("machin"); // on stocke le résultat de calculer() dans une variable locale à main()
       }
     
    }
    La méthode calculer() n'utilise aucune variable externe à elle-même, autre que des paramètres. Elle est isolée de tout le reste du programme. On peut l'appeler plusieurs fois, y compris en même temps (processus parallèle) sans aucun souci de conflit ou de concurrence d'accès, et elle ne décide pas elle-même de la valeur de variables qui lui sont externes.

    Tu l'as bien fait ici :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     public static String dateHeure(){
            LocalDateTime dateHeureSysteme = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
            String dateHeure = dateHeureSysteme.format(formatter);
            return dateHeure;}

    pourquoi ne pas le faire systématiquement.
    Alors, c'est sûr parfois, ça complique un peu les choses lorsqu'une méthode a besoin du résultat d'une autre. On peut choisir de faire :

    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
    public class Machin {
     
     
       public static void calculer(String param) {
               String resultat = // on imagine ici un code très compliqué et très long qui aboutit au résultat...
               unevariable = resultat ;
       }
     
       private static String unevariable;
     
       public static void main(String[] args) {
               calculer("truc");  // on modifie la variable static String unevariable dans la méthode.
               // String uneautrevariable = calculer("machin"); // ça on peut plus l'écrire
       }
     
    }
    Du coup on peut utiliser facilement unevariable dans n'importe quelle méthode de Machin, mais il faut déjà absolument appeler calculer("truc") avant sinon elle n'a pas de valeur (si on oublie, on aura une erreur d'exécution), et être obligé d'appeler deux méthodes dans un ordre imposé, ce n'est jamais bon, (surtout quand il y a 40 méthodes, pour se souvenir qu'il faut les appeler dans un ordre bien précis, c'est quasi impossible). On ne peut pas appeler la méthode pour calculer plusieurs résultats, c'est toujours le dernier qui remplace le précédent. Enfin, ça ne concerne pas trop ton programme, mais en général, il ne faut surtout pas appeler la méthode dans deux processus parallèles, non seulement on ne sait pas quel résultat on aura, mais ça risque même de planter.
    Et en tout cas, faire les deux en même temps ça ne sert à rien.



    Regardons aussi par exemple (problème vu dans un autre sujet que tu as ouvert sur ce forum) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public static void affichageFactureVente(String enteteFacture, String factureRabais, String messageRabais, String dimensionPneu, int nombrePneus, double calculPrixUnitaire, double taxeTps, double taxeTvq, double montantTotal){
            enteteFacture(numeroFacture, dateHeure);
            System.out.println(dimensionPneu + "            " + nombrePneus + "            $" + calculPrixUnitaire);
            System.out.println("");
            System.out.print(factureRabais);
            System.out.println("Montant TPS : $" + taxeTps + "\n" +
                "Montant TVQ : $" + taxeTvq + "\n" +
                "Montant total : $" + montantTotal + "\n" +
                " \n");
            System.out.print(messageRabais);
            System.out.println("--------------------------------------- \n"+
                "Merci pour votre confiance \n");
        }
    Ici tu as :
    1. un paramètre enteteFacture que tu passes bien en paramètre en appelant la méthode qui en construit la valeur
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      affichageFactureVente(enteteFacture(numeroFacture(), dateHeure()), factureRabais(calculSoustotal(calculPrixUnitaire(dimensionPneu, saisonUtilisation), nombrePneus), calculRabaisSousTotal(montantRabais, calculSoustotal)), messageRabais(calculRabais(rabais, calculSoustotal)),dimensionPneu, nombrePneus, calculPrixUnitaire(dimensionPneu, saisonUtilisation), taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)));
      Je suppose qu'on t'a imposé la signature de la méthode affichageFactureVente (la signature = tous les paramètres et leur type respectif, dans l'ordre). Si ce n'est pas le cas dit le tout de suite, parce qu'il faut changer l'approche globale (qui sera beaucoup plus simple d'ailleurs).

      Et donc le premier paramètre de affichageFactureVente est l'entête de la facture, calculée par une autre méthode :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      public static String enteteFacture(int numeroFacture, String dateHeure){
              enteteFacture = "Experts-Pneus \n"+
              "Date et heure: " + dateHeure() + "Facture No : " + numeroFacture() + "\n" +
              "2020 rue Hakuna, Matata, QC                     (450) 515 - 0055 \n" +
              "----------------------------------------------- \n" +
              "Description                     Nombre de pneus               Prix unitaire \n";
       
              return enteteFacture;
          }
      méthode qui retourne son résultat (ce qui permet à ce qu'il passe en paramètre de affichageFactureVente ), et le stocke aussi dans une variable static externe.
      Et puis en plus dans affichageFactureVente :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      public static void affichageFactureVente(String enteteFacture, String factureRabais, String messageRabais, String dimensionPneu, int nombrePneus, double calculPrixUnitaire, double taxeTps, double taxeTvq, double montantTotal){
          enteteFacture(numeroFacture, dateHeure);
          System.out.println(dimensionPneu + "            " + nombrePneus + "            $" + calculPrixUnitaire);
      Tu rappelles au début la méthode qui calcule et stocke l'entête, que tu as déjà dans le paramètre enteteFacture, et tu n'utilises pas le retour de enteteFacture. Bon, c'est tant mieux, puisque tu as déjà la valeur dans le paramètre enteteFacture (et aussi dans la variable static enterFacture... ça fait beaucoup d'entêtes de facture tout ça... alors qu'une seule suffit, celle passée en paramètre, calculée lors de l'appel de la méthode affichageFactureVente(enteteFacture(numeroFacture(), dateHeure()), ...Mais le pire c'est que tu calcules deux fois l'entête, et tu as deux variables (dont un paramètre) qui stockent sa valeur, mais tu ne l'affiches pas... il faudrait un System.out.println( enteteFacture ) pour ça...

      En revanche, ici :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      public static void affichageFactureInstallation(String factureRabais, double taxeTps, double taxeTvq, double montantTotal, String enteteFacture, String descriptionInstallationPneu, double calculPrixInstallation, int nombrePneusInstaller){
              System.out.println(enteteFacture);
      tu as bien un paramètre enteteFacture, et tu affiches bien la valeur de ce paramètre. En revanche, la signature de cette méthode n'est pas très cohérente avec l'autre. Pourquoi le paramètre enteteFacture n'est au même endroit.

      Si on regarde l'invocation
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
                  affichageFactureInstallation(factureRabais, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal), montantTotal(calculSousTotalTotal, taxeTps(calculSousTotalTotal), taxeTvq(calculSousTotalTotal)), enteteFacture, descriptionInstallationPneu(choixMenuInstallation), calculPrixInstallation(choixMenuInstallation), pneusInstaller);
      On voit que le paramètre enteteFacture est alimenté par taxeTps(calculSousTotalTotal)... pas très logique tout ça...



    Il y a aussi ton menu qui me semble bien compliqué pour pas grand chose. Il te faut quatre variables pour déterminer le traitement et l'affichage, ça complique vraiment les choses (c'est difficile à comprendre pour moi, alors j'imagine comment tu galères pour mettre au point tous les enchaînements). Et le traitement est fait dans la boucle de menu alors qu'une partie de l'affichage est géré en dehors et une autre partie en dedans. Aussi, à partir du moment au affichage1 est passé à 1, jamais plus il ne passe à zéro. C'est normal ?

    Et puis regarde ce code :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    if (choixMenuInstallation == 1){
                            pneusInstaller = nombrePneusInstaller();
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
     
                        }else if(choixMenuInstallation==2){
                            pneusInstaller = nombrePneusInstaller();                
                            System.out.println("Désirez-vous entrer une nouvelle facture?");
                            affichage2 = 1;
     
                        }
    C'est normal qu'on fasse exactement la même chose dans les deux cas ?

    Il me semble que si tu faisais un découpage plus "élémentaire", ce serait plus simple :

    Code pseudojava : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    do{
       affichermenu()
       choix = lirechoix()
       if ( choix==1 ) {
              traiterChoix1(); // fait un traitement et gère l'affichage qui en résulte
       } else if ( choix==2 ) {
              traiterChoix2();// fait un traitement et gère l'affichage qui en résulte
       }
       else etc...
    } while(choix != quitter )
    et traiterChoix2() peiut être aussi
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    do{
       affichermenu2()
       choix = lirechoixMenu2()
       if ( choix==1 ) {
              traiterChoix2_1(); // fait un traitement et gère l'affichage qui en résulte
       } else if ( choix==2 ) { 
              traiterChoix2_2();// fait un traitement et gère l'affichage qui en résulte
       }
       else etc...
    } while(choix != quitter )

    Petite question annexe : tu ne connais pas le type boolean ? Si non, ok. Si tu le connais, plutôt qu'un int qui vaut 0 ou 1, c'est mieux d'utiliser un boolean.

    Enfin, et je vais arrêter là, pour le moment, du moins :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    System.out.println("Désirez-vous entrer une nouvelle facture?");
    Pourquoi ce message affiché plein de fois à plein d'endroit (alors que bien placé, ça éviterait de dupliquer), alors qu'on ne semble pas faire de lecture du clavier qui permettrait de répondre oui ou non (ou O ou N, peu importe).
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  4. #4
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2019
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2019
    Messages : 6
    Points : 4
    Points
    4
    Par défaut Réponse
    Je suppose qu'on t'a imposé la signature de la méthode affichageFactureVente (la signature = tous les paramètres et leur type respectif, dans l'ordre). Si ce n'est pas le cas dit le tout de suite, parce qu'il faut changer l'approche globale (qui sera beaucoup plus simple d'ailleurs).

    Non on me l'a pas imposé! Il y a façon plussimple de faire??

    -----

    Aussi, à partir du moment au affichage1 est passé à 1, jamais plus il ne passe à zéro. C'est normal

    Oui! Je voulais juste pouvoir savoir si je dois afficher le menu de vente, d'installation ou les deux ensemble!
    Le boolean est une bonne idee merci!!

    ---

    C'est normal qu'on fasse exactement la même chose dans les deux cas ?

    Oui! La seule chose qui change est un prix, qu'on détermine avec le choix du menu.

    ----

    Pour le désirez vous entrer une autre facture, ça retourne au menu principal. Le "non" serait techniquement faire "quitter" et le oui choisir une autre option.

    -----

    Merci vraiment pour le temps que tu consacres à ce post!
    Tout de même, je ne suis pas certain de comprendre, comment tu lies des methodes entre elles quand y en a vrm bcp d'empillees ?
    Par exemple, les méthodes de rabais, comment je faiz pour qu'elle comprenne que les méthodes dans ses paramètres aient déjà été calculées ?

    Quand je pars le programme, ca me donne taxe: 0$, total: 0$, rabais: 0$

  5. #5
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    septembre 2009
    Messages
    11 922
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2009
    Messages : 11 922
    Points : 28 183
    Points
    28 183
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par pedro2163 Voir le message
    Je suppose qu'on t'a imposé la signature de la méthode affichageFactureVente (la signature = tous les paramètres et leur type respectif, dans l'ordre). Si ce n'est pas le cas dit le tout de suite, parce qu'il faut changer l'approche globale (qui sera beaucoup plus simple d'ailleurs).

    Non on me l'a pas imposé! Il y a façon plussimple de faire??
    Et bien au lieu d'avoir une palanquée de paramètres, pense tes factures comme un succession d'éléments. Par exemple :

    1. il y a toujours une entête au début avec la date et le numéro
    2. puis il y a peut-être un bloc avec les coordonnées du client
    3. puis il y a un bloc avec la liste détaillées des articles et leur prix
    4. puis il y a un bloc de total ht
    5. puis il y a un bloc de total ttc
    6. puis il y a un bloc d'info
    7. ...

    En gros, toute facture peut être définie comme une suite de bloc, qui vont s'afficher les uns après les autres. Ici j'ai mis un exemple qui correspond ou pas avec l'un de tes cas, mais voilà c'est juste pour avoir un exemple. Il faut bien sûr que tu décomposes chaque facture en bloc.
    Donc si tu fais une méthode par bloc, déjà un moyen super simple d'afficher une facture est d'appeler ces méthodes successivement. Et certaines des méthodes pourront être appelées par plusieurs méthodes différentes pour des factures différentes si nécessaires. Il peut aussi y avoir des blocs composés de plusieurs blocs. Peut-être qu'il y a un bloc d'entête étendue qui affiche d'abord le bloc d'entête simple puis le bloc de coordonnées clients qui n'est jamais affiché autrement que dans ce bloc d'entête étendue. Bref, tu composes tes méthodes en fonction des besoins, de manière à limiter la duplication de code.

    Ensuite il y a le problème des paramètres : soit on les a en static, partagés par tout le monde, et ça pose les problèmes dont je t'ai parlés éventuellement, soit il faut les passer en paramètre et quand on a quarante paramètres, c'est carrément fastidieux et on peut facilement se planter (en inversant deux paramètres, en en oubliant, en ne passant pas le bon, etc).
    1. Lorsqu'on a beaucoup de paramètre la première solution simple est de faire une classe qui contient les paramètres, ce qu'on va appeler un contexte ou un descripteur (un descripteur est initialisé au début et ne change plus, un contexte c'est pareil, mais on peut l'enrichir au fur et à mesure du traitement, localement (dans une méthode on va remplacer temporairement des valeurs, et on va restaurer les valeurs en sortant de la méthode). Les contextes peuvent être également hiérarchisés (on va avoir un contexte global, puis différents contextes qui en héritent et qui sont plus spécifiques. Dans ton cas commençons juste par un descripteur. C'est juste une classe qui a plein d'attributs, ou d'informations, si tu préfères (une date, un numéro, un id de client, etc). Au plus simple, ils sont tous public, du coup on peut les modifier n'importe comment, et ça pose les mêmes problèmes qu'avec les attributs static. Ou alors on procède en deux temps. On fait ce qu'on appelle un builder qui va fabriquer l'instance de descripteur qui elle protège l'écriture ses attributs. Avec un builder, on peut envisager facilement des public final, donc lisible facilement (sans accesseur) mais qu'on ne peut pas modifier, donc pas de problème de conflit ou concurrence d'accès.
      Exemple :
      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
      public class Descripteur {
          public final String clientId;
          public final String factureId;
          public final LocalDate dateFacture;
       
          private Descripteur(String clientId, String factureId, LocalDate dateFacture) {
                 this.clientId=clientId;
                 this.factureId=factureId;
                 this.dateFacture=dateFacture;
          }
       
          // on peut quand même avoir des méthodes si on veut
          public String formatDate(String pattern) {
              if ( dateFacture==null ) return "---";
              else return dateFacture.format(DateTimeFormatter.ofPattern(pattern);
          }
       
          public static Builder builder() {
                   return new Builder();
          }
       
          public static class Builder {
               private String clientId;
               private String factureId;
               private LocalDate dateFacture;
       
               public Builder() {
                        // on affecte éventuellement des valeurs par défaut
                       dateFacture = LocalDate.now();
                       factureId = FactureIdFactory.newId();
               }
       
                public Builder setFactureId(String factureId) {
                          // on peut mettre ici des contrôles
                          this.factureId=Objects.requireNonNull(factureId, "Numéro de facture obligatoire");
                          return this;
                }
       
                public Builder setClientId(String clientId) {
                          this.clientId=clientId;
                          return this;
                }
       
                public Builder setDate(LocalDate dateFacture) {
                          this.dateFacture=dateFacture;
                          return this;
                }
       
                public Descripteur create() {
                          return new Descripteur( clientId, factureId, dateFacture );
                }
       
          }
       
      }
      Pour l'appeler :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      Descripteur desc = Descripteur.builder()
       .setClientId("xxx")
       .setDate( LocalDate.of(2019, Month.APRIL, 1) ) // petit rétro datage
       .create();
       
      System.out.println("date facture " + desc.formatDate("dd/MM/yyyy") +" Client: " + desc.clientId;
    2. On peut aussi faire un peu moins "débutant" en faisant de l'objet. Java est un langage objet autant en profiter. Il y a plein de principes dans la Programmation Orientée Objet. La définition la plus simple d'un objet : des attributs et des méthodes. Mais d'après moi les principes principals, sont l'encapsulation, la notion de "boite noire". On n'a pas à savoir comment ça doit s'afficher une facture, c'est la facture qui doit savoir. Du coup, notre descripteur avec ses attributs devient un objet quand on lui ajoute des méthodes, comme afficher() par exemple. cette méthode va appeler pleins de méthodes les unes après les autres pour constituer la facture finale. S'il y a plusieurs types de facture, on crée plusieurs classes une pour chaque, et on utilise héritage et polymorphisme pour les distinguer. S'il y a des méthodes en commun, comme l'entête de facture, on fait une abstraction qui les contient. On peut toujours utiliser notre système de builder pour générer la partie "informations", les attributs

      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
      public abstract class AbstractFacture {
       
          // les attributs ne sont plus public : boite noire !
          private final String clientId;
          private final String factureId;
          private final LocalDate dateFacture;
       
          protected void enteteFacture() {
                System.out.println("Facture: " + factureId + " / date: " + formatDate("dd/MM/yyyy"));
          } 
       
          protected void blocTtc() {
                System.out.println("...");
          }
       
          public abstract void afficher();
       
      }
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      public class FactureMachin extends AbstractFacture {
       
                 public void afficher() {
                       enteteFacture();
                       blocMachin();
                       blocTruc();
                       ...
                 }
       
      }
      Le code devient très simple. On lit presque directement ce que fait chaque méthode. Le code compliqué est très isolé dans des méthodes avec juste quelques lignes, au lieu d'avoir une grosse méthode avec 100 lignes de code qui fait des println de formules avec 40 variables...
      Et si on veut changer ça pour qu'au lieu d'afficher en console, on affiche dans ce qu'on veut (un fichier, un page web, 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
      public abstract class AbstractFacture {
       
          // les attributs ne sont plus public : boite noire !
          private final String clientId;
          private final String factureId;
          private final LocalDate dateFacture;
       
          protected void enteteFacture(PrintStream out) {
                out.println("Facture: " + factureId + " / date: " + formatDate("dd/MM/yyyy"));
          } 
       
          protected void blocTtc(PrintStream out) {
                out.println("...");
          }
       
          public abstract void afficher(PrintStream out);
       
      }
      et l'appel :

      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      Facture.builder()
      .setClientID(...)
      .setFactureID(...)
      .create()
      .afficher(System.out);
      C'est un exemple, mais on peut décomposer si on veut :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      Facture.Builder builder = Facture.builder()
      .setClientID(...);
       
      if ( cecicela ) {
         builder.setFactureID(...);
      }
      else {
         builder.setFactureID(...).setDate( ... );
      }
      Facture facture = builder.create();
       
      facture.afficher(System.out);
      Le code reste très lisible même si on ne connait pas trop Java : on comprend ce qu'il se passe, on donne un id de client, un id de facture, on créer un facture, on l'affiche...
    3. On peut utiliser aussi des "fonctions", via des expressions lambda. Puisqu'une facture, c'est une liste de bloc, on peut faire des fonctions pour chaque bloc, les mettre dans une liste quand on construit la facture, et en suite il suffit de parcourir la liste pour afficher chaque bloc, ce qui donne la facture final. La composition (la succession, l'ordre, la présence ou non d'un bloc) n'est plus une question de succession d'appel de méthode en dur dans le code, mais le résultat d'une évaluation dynamique, qui pourrait être même configurée dans un fichier de configuration externe, ou par choix de l'utilisateur. Mais même si ce n'est pas si compliqué que ça, au niveau débutant, on peut se contenter de faire un objet et les principes de POO.



    Citation Envoyé par pedro2163 Voir le message
    -----

    Aussi, à partir du moment au affichage1 est passé à 1, jamais plus il ne passe à zéro. C'est normal

    Oui! Je voulais juste pouvoir savoir si je dois afficher le menu de vente, d'installation ou les deux ensemble!
    Le boolean est une bonne idee merci!!
    Ok. C'est naturel que tu sois arrivé à avoir 2 variables. Mais comme ton code au final c'est if/else if/else if, alors on peut forcément simplifier en ayant qu'une seule variable, mais pas un booléen forcément, puisque 2 variables booléennes vont donner 4 valeurs différentes possibles. Une enum pourrait être la solution. Je ne sais pas si tu connais.

    Citation Envoyé par pedro2163 Voir le message
    ---

    C'est normal qu'on fasse exactement la même chose dans les deux cas ?

    Oui! La seule chose qui change est un prix, qu'on détermine avec le choix du menu.
    Ok. Mais comme cette variable est externe au bloc de code, il n'y a aucune raison de l'avoir deux fois.

    ----
    Citation Envoyé par pedro2163 Voir le message
    Pour le désirez vous entrer une autre facture, ça retourne au menu principal. Le "non" serait techniquement faire "quitter" et le oui choisir une autre option.
    Ok. Effectivement, le menu se réaffiche toujours après.

    -----
    Citation Envoyé par pedro2163 Voir le message

    Merci vraiment pour le temps que tu consacres à ce post!
    Tout de même, je ne suis pas certain de comprendre, comment tu lies des methodes entre elles quand y en a vrm bcp d'empillees ?
    Par exemple, les méthodes de rabais, comment je faiz pour qu'elle comprenne que les méthodes dans ses paramètres aient déjà été calculées ?
    Alors déjà ce serait plus simple par en vrai objet. Le code avec des méthodes statiques et des attributs statiques, ça ressemble plus à du procédural avec variables globales. Et c'est justement l'un des problèmes : quand appeler des méthodes au bon moment ?

    Difficile d'y répondre, parce qu'il n'y a pas vraiment de bon moment. Il faut plutôt penser en terme de succession d'invocations (d'appel). Pour répondre à ta question "comment je faiz pour qu'elle comprenne que les méthodes dans ses paramètres aient déjà été calculées", tu ne dois pas te poser cette question en ces termes. On pourrait le faire dans un paradigme fonctionnel réactif. On peut faire ça en Java. Mais si sa syntaxe possède des moyens de faire des trucs qui peuvent ressembler à ça, ce n'est pas un langage conçu pour faire ça, et du coup, ça demande d'avoir déjà un bon niveau pour le faire.
    Donc tu ne dois pas te poser la question "les méthodes comprennent que ça déjà été calculées", mais "fais le calcul d'abord, et passe le paramètre ensuite" : dans cet ordre, pas besoin de comprendre que ça déjà été calculé ou pas, on s'en fout : on passe le paramètre et il est utilisé dans la méthode. S'il n'a pas été calculé avant : bug (affichage erroné, plantage ou erreur de calcul). Il faut donc bien faire attention à appeler les méthodes dans le bon ordre. Et cela est facilité par la suppression de tous les static final. Puisqu'on ne peut pas référencer quelque chose qui n'est pas déclaré, tu seras obligé de référencer une méthode qui va produire la donnée que tu as besoin de passer en paramètre. En contrepartie, tu vas avoir un code avec des cascade d'appel de méthodes et quarante paramètres pour chaque méthode, si tu ne fais pas soit du descripteur, soit de l'objet.
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  6. #6
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2019
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2019
    Messages : 6
    Points : 4
    Points
    4
    Par défaut Réponse
    Salut!!

    Merci pour toute ton aide! Je vais prendre le temps de lire comme il faut et bien comprendre.

    Pour la POO, on ne l'a tjs pas apprise! On va l'apprendre dans 1 mois! L'excercice est plus pour bien apprendre et saisir les méthodes!

  7. #7
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    septembre 2009
    Messages
    11 922
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2009
    Messages : 11 922
    Points : 28 183
    Points
    28 183
    Billets dans le blog
    2
    Par défaut
    Si le but est de pratiquer les méthodes, dans un mode procédural (sans objet donc), c'est qu'il faut pratiquer le passage de paramètres. Tu ne devrais donc n'avoir aucune variable static, et d'avoir plutôt des paramètres pour tes méthode. Pour limiter le nombre de paramètres, il faut un bon découpage en méthodes. Dans la mesure où ton programme est monothread, tu peux compter sur l'ordre d'exécution pour que les différents affichages soient successifs (dans le bon ordre). Il faut éviter donc un maximum d'avoir à propager des paramètres très profondément dans les invocations imbriquées (des invocations de méthode à l'intérieur d'autres méthodes). Ensuite le découpage se fait par rapport au besoin technique et le besoin de réutilisation (comme une méthode pour afficher une entête de facture qu'on utilise dans le cadre de plusieurs fonctions). Il ne faut pas non plus hésiter à faire des méthodes pour regrouper des traitements tant que la méthode a une logique fonctionnelle (elle représente une fonction de l'application, comme afficher une facture).

    Je te donne un exemple standard, je ne me base pas sur tes specs, que je ne connais pas par ailleurs, juste pour montrer qu'un découpage adéquate permet d'avoir un code simple, avec peu de paramètres.

    Si je prends le cas d'un affichage de facture. J'ai un numéro. Une date. On peut éviter d'avoir à passer la date en paramètre.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    void afficherEntete(int numero) {
       System.out.printf("Numéro : %d Date : %2$td %2$tB %2$tY ", numero, LocalDate.now());
    }]
    Le numéro peut être déterminé au dernier moment, du coup :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    int afficherFacture(String produit, float prix, float rabais) {
        int numero getNouveauNumeroFacture();
        afficherEntete( numero ); // si le numéro dépend du produit, on passe le produit en paramètre
        afficherPrixProduit( produit, prix );
        afficherRabais( rabais );
        return numero;
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    int afficherFactureSansRabais(String produit, float prix) {
        int numero getNouveauNumeroFacture();
        afficherEntete( numero );
        afficherPrixProduit( produit, prix );
        return numero;
    }]
    Si le numéro, on n'en a besoin que dans l'entête, on se complique pas la vie :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    void afficherEntete() {
       System.out.printf("Numéro : %d Date : %2$td %2$tB %2$tY ", getNouveauNumeroFacture(), LocalDate.now());
    }]
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    void afficherFacture(String produit, float prix, float rabais) {
        afficherEntete( ); // si le numéro dépend du produit, on passe le produit en paramètre
        afficherPrixProduit( produit, prix );
        afficherRabais( rabais );
    }]

    Pour le reste, par exemple :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    void vendre() {
    String produit = saisirProduit(); // demander à l'acheteur de saisir le produit qu'il veut acheter
    if ( produit==null ) { // vente annulée
         return;
    }
    float prix = getPrixProduit(produit); // déterminer le prix du produit demandé
    if ( isRabais(produit) ) { // si le produit conduit à un rabais
        float  rabais = evaluer(produit, prix); // calculer le rabais
        afficherFacture(produit, prix, rabais);
    }
    else {
        afficherFactureSansRabais(produit, prix);
    }
    }
    Ensuite, pour répondre à nouveau à la question initiale, il n'y a pas à se préoccuper de savoir comment une méthode fait pour comprendre que le résultat d'une autre a été calculée, il suffit de faire les choses dans l'ordre.
    Donc soit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int methode1() { // méthode qui calcule un truc
        return ...
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    void methode2(int param) { // méthode qui utilise un truc calculé par methode1, passé en paramètre
       System.out.println(param);
    }
    avec
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    methode2( methode1() );
    ou
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    int truc = methode1(); 
    methode2(truc);
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    void methode3() { // méthode qui utilise un truc calculé par methode1, invoquée en interne
       int truc = methode1();
       System.out.println(truc);
    }

    Pour le cas
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    methode2( methode1() );
    pour que tu comprennes, par rapport à ta question :

    1. "java" se dit "tiens je dois appeler methode2"...
    2. ... donc j'ai un paramètre, quel est-t-il ? l'expression methode1().
    3. donc je dois appeler methode1(), ce que je fais, j'entre dans la méthode 1 et je fais tout ce qu'elle dit de faire, et je retourne un résultat à la fin
    4. je récupère le résultat de l'appel de méthode1() et je le passe en paramètre de la méthode methode2
    5. j'ai passé tous mes paramètres, je peux "entrer" dans la méthode methode2, ce que je fais...
    6. et là pendant l'exécution de la méthode methode2, j'ai mon paramètre param, il a la valeur que l'appelant à passé, et on s'en fout qu'elle vienne de methode1, methode25 ou ailleurs...
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

Discussions similaires

  1. Réponses: 8
    Dernier message: 06/05/2009, 08h53
  2. eclipse pdt : autocompletion et lien sur déclaration des méthodes
    Par crazykangourou dans le forum Eclipse PHP
    Réponses: 2
    Dernier message: 11/12/2008, 11h52
  3. question sur gestion des erreurs
    Par deuxmains dans le forum Général VBA
    Réponses: 4
    Dernier message: 03/10/2008, 15h50
  4. Réponses: 2
    Dernier message: 27/06/2007, 14h48
  5. [AWstat] questions sur interpretation des résultats
    Par norac dans le forum Statistiques
    Réponses: 1
    Dernier message: 16/01/2006, 15h24

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