Discussion :

[pedro2163]

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

[joel.drigo]

Salut,

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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fois2(15);

ou sur une variable, n par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fois2(n);

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) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fois2(n + 5);

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).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fois2( plus(n,5) );

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
}

[joel.drigo]

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).

[pedro2163]

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$

[joel.drigo]

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.

-----

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.

---

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.

----

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.

-----

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.

[pedro2163]

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!

[joel.drigo]

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...