Aller au menu - Aller au contenu

Icône TP n°1 : un tableau de conversion Celsius - Fahrenheit !

Mise à jour : 12/02/2010
Difficulté : Facile Facile Creative Commons BY-NC-SA
96 702 visites depuis 7 jours, dont 1 236 sur ce chapitre classé 4/786
Voilà un très bon petit TP qui va mettre en oeuvre tout ce que vous avez vu jusqu'ici. Mais vraiment tout !
Accrochez-vous, car là je vais vous demander de penser à des tonnes de choses, et vous serez tout seuls. Lâchés dans la nature... non, je plaisante. Oui, je sais, je déconne beaucoup, tout de même !
Mais je pense que nous apprendrons mieux dans la bonne humeur.

Bon : trêve de bavardage, au boulot. :soleil:
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant

Élaboration

Euh... Avant de foncer têtes baissées sur Eclipse, et commencer à coder, nous allons d'abord essayer de structurer notre futur programme. En plus, je ne vous ai même pas dit ce que j'attendais de vous... :-°

Cahier des charges



Alors je veux :
  • un code qui puisse se répéter autant de fois que nous le souhaitons
  • que le code demande à quelle température nous commençons la conversion
  • la température de fin de conversion
  • le pas de conversion => c'est-à-dire par degré, ou tous les 2 degrés, ou les x degrés
  • qu'on vérifie les cas impossibles : comme un pas plus grand que l'intervalle de température, ou une température d'arrivée plus petite que la température de départ
  • qu'on demande à l'utilisateur s'il est prêt, ou si son imprimante est prête... enfin ce que vous voulez, ici
  • s'il est prêt, que l'on affiche les conversions sous forme de tableau visuel
  • qu'il n'y ait pas de décalage pour les différentes valeurs => tout doit être parfaitement aligné
  • enfin, que l'on demande à l'utilisateur s'il veut faire une nouvelle conversion, donc revenir au début, s'il le souhaite !

Je vous avais prévenus que je serais exigeant ! Mais croyez-moi, vous êtes capables de le faire.
Je sais que vous y arriverez !

Élaboration



Comme je vous l'ai dit, essayez de réfléchir sur papier avant... Ce qu'il vous faut comme nombre de variables, les types de variables, comment va se dérouler le programme, les conditions et les boucles utilisées...

Pour info, voici la formule de conversion pour passer des degrés Celsius en degrés Fahrenheit :
F = 9/5 * C + 32

Je vais vous aiguiller un peu :

  • pour ce genre de calcul, utilisez des variables de type double
  • faites attention à la priorité des opérations
  • de simples if... else suffisent ici : pas besoin d'un switch.


Voici un aperçu de ce que je vous demande :

Image utilisateur


Vous voyez bien que tous mes chiffres sont alignés, malgré leur taille. Lors de l'affichage, il faudra donc utiliser une condition en fonction de la taille des chiffres (if Celsius < 100){.........} else{.........}).
Je vais également vous donner une fonction toute faite, qui vous permettra d'arrondir vos résultats. Je vous expliquerai le fonctionnement des fonctions exactement 2 chapitres plus loin. Mais en attendant, c'est facultatif. Vous pouvez très bien ne pas vous en servir. Pour ceux qui souhaitent tout de même l'utiliser, la voici :
Code : Java
1
2
3
public static double arrondi(double A, int B) {
     return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}

Elle est à placer entre les deux accolades fermantes de votre classe, comme ceci :

Image utilisateur


Vous pouvez l'utiliser de cette manière : imaginez que vous avez la variable fahren à arrondir, et que le résultat obtenu soit enregistré dans une variable arrondFahren, vous procéderez comme suit :
Code : Java
1
2
arrondFahren = arrondi(fahren, 1); // pour un chiffre après la virgule
arrondFahren = arrondi(fahren, 2);// pour 2 chiffres après la virgule... etc.


Bon : Je vous ai déjà assez aidés ! Place à la conception.

Conception

Dernière recommandation



Essayez de bien INDENTER votre code ! Prenez votre temps. Essayez de penser à tous les cas de figures...

Maintenant à vos papiers, crayons, neurones et claviers, ...et bon courage !

Correction

STOP !!! C'est fini ! Passons maintenant à la correction de ce premier TP.
Ça va ? Pas trop mal à la tête ? Je me doute qu'il a dû y avoir quelques tubes d'aspirine d'utilisés...
Mais vous allez voir qu'en définitive, ce TP n'était pas si compliqué.
Surtout, n'allez pas croire que ma correction est parole d'évangile... Il y avait différentes manières d'obtenir le même résultat. Voici tout de même une des corrections possibles.

Code : Java
 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
class Sdz1 {
    public static void main(String[] args) {
       //Notre objet Scanner
Scanner sc = new Scanner(System.in);
 
//initialisation des variables
        double c, f=0;
int i,j=0;
char reponse=' ';
 
System.out.println(" ------------------------------------------------------------------------");
System.out.println("|             CONVERSION DEGRES CELSIUS ET DEGRES FAHRENHEIT                |");
System.out.println(" ------------------------------------------------------------------------");
 
do{//tant que reponse = O//boucle principale
        
    do{//tant que l'imprimante n'est pas prête//boucle de test pour savoir si l'utilisateur est prêt
        
        do {// tant que valeur impossible rentrée
 
//saisie des valeurs
            System.out.println("A partir de :");//affichage des directives et récupération des données
            c = sc.nextDouble();
 
            System.out.println("jusqu' à:");
            i = sc.nextInt();
 
            System.out.println("Par pas de :");
            j = sc.nextInt();
 
            if (c > i || j > i || j == 0)
                System.out.println("Traitement impossible");
 
        }while(c > i || j > i || j == 0);
 
        do {//tant que la reponse n'est pas O ou N
                
            System.out.println("Assurez-vous que l'imprimante est prête");
            System.out.println("Si vous êtes prêt, tapez O, sinon tapez N");
            //sc.reset();
            reponse = sc.next().charAt(0);
            
        }while (reponse != 'O' && reponse != 'N');
        
    }while (reponse == 'N');
 
//                                                                    Traitement des valeurs
    System.out.println("TABLE DE CONVERSION CELSIUS / FAHRENHEIT");
    System.out.println("---------------------------------------------");
    System.out.println("       Celsius      |       Fahrenheit       ");
    System.out.println("---------------------------------------------");
    
    do{//tant que l'affichage n'est pas fini, on boucle les données et les calculs
        
        f = ((9.0/5.0) * c) + 32.0;
        if (c < 10)//si le Celsius n'a qu'un chiffre, on affiche un certain nombre d'espaces
            System.out.println("         "+c+"        |         "+arrondi(f,1));
        
        else
        {
            if(c < 100)//S'il y a un chiffre en plus, on enlève un espace blanc...
                System.out.println("        "+c+"        |         "+arrondi(f,1));
            else
                System.out.println("        "+c+"       |         "+arrondi(f,1));
        }
 
        c = c + j;//On incrémente le degré Celsius avec le pas
        
    }while (c <= i);
 
    do{
        
        System.out.println("Souhaitez-vous éditer une autre table ?(O/N)");
        reponse = sc.next().charAt(0);
        
    }while(reponse != 'O' && reponse != 'N');
    
}while(reponse == 'O');
 
System.out.println("Au revoir !");
 
//Fin de programme
}
        
public static double arrondi(double A, int B) {
        return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}
 
 
 
}


Expliquons un peu ce code



  • Tout programme commence par une phase de déclaration de variable.
  • Nous affichons le titre de notre programme.
  • Ensuite, vous voyez 3 do{ consécutifs, correspondant chacun à une condition à vérifier : le choix de l'utilisateur pour faire une nouvelle conversion, vérification si l'utilisateur est prêt, vérification si les nombres sont cohérents.
  • Nous affichons les renseignements à l'écran, et nous récupérons les saisies clavier dans une variable.
  • Si les chiffres sont incohérents, on affiche une erreur, et on boucle sur le début.
  • Une boucle pour s'assurer que l'utilisateur rentre bien O ou N.
  • À partir d'ici, les nombres sont cohérents, et l'utilisateur est prêt. Donc on lance la conversion.
  • On affiche le squelette du tableau.
  • Une boucle pour afficher les différents résultats.
  • Calcul de la conversion.
  • Selon la taille du chiffre Celsius, on enlève (ou non) un espace à l'affichage.
  • Cette boucle sera répétée tant que le degré de départ est plus petit que le degré de fin que vous avez choisi.
  • FIN DU PROGRAMME !


Ce programme n'est pas parfait, loin de là... La vocation de celui-ci était de vous faire utiliser ce que vous avez appris et je pense qu'il remplit bien sa fonction. ^^

J'espère que vous avez apprécié ce TP.
Je sais qu'il n'était pas facile, mais avouez-le : il vous a bien fait utiliser tout ce que vous avez vu jusqu'ici ! :D
Voilà : votre premier TP est fait, et bien fait !!
Je vous conseille de vous reposer un peu, parce que ça a dû fumer dans votre boite crânienne...
Je viens de vous faire afficher un tableau (rudimentaire à l'affichage), mais maintenant nous allons travailler avec des tableaux en Java ! C'est parti...
Chapitre précédent Sommaire Chapitre suivant

Partager

97 commentaires pour "TP n°1 : un tableau de conversion Celsius - Fahrenheit !"
Note moyenne : 3.57 / 4 (1025 votes)
Pseudo Commentaire
Hors ligne hekatoncheir # Posté le 14/04/2012 à 14:31:41

Avis : Très bon

voici ce que j'ai reussit a faire



import java.util.Scanner;


public class Euu {

public static void main(String[] args) {
System.out.println("-----------------------------------------------------------------");
System.out.println("| Convertion de Clecius en Fahrenheit |");
System.out.println("-----------------------------------------------------------------");
Scanner celcius = new Scanner(System.in);
Scanner fahrenheit = new Scanner(System.in);
Scanner pas = new Scanner(System.in);
Scanner reponse = new Scanner(System.in);
char rep;
char repi;
///*
do{
//*/
double far;
double cel;
double pa;
double diff;
do{//on fait toutes les demandes avant de faire les conversions

do{//on verifie les cas impossibles

do{// on demande les valeurs de debut, de fin et le pas
System.out.println("A partir de :");
cel = celcius.nextInt();
System.out.println("jusqu'a :");
far = fahrenheit.nextInt();
System.out.println("par pas de :");
pa = pas.nextInt();
double max = (cel < far) ? far : cel;
double min = (cel > far) ? far : cel;
diff = (double)(max - min);
}while ((cel > far) || (pa <= 0));// si la valeur de debut est supperieure a celle de fin, ou si le pas est inferieur ou egale a 0, on recommence

}while (diff < pa); //on test si le pas est supperieur à l'interval

do{// on demande si on commence la conversion ou pas
System.out.println("assurez vous que l'imprimante est prête");
System.out.println("si vous êtes pres, appuyez sur O, sinon appuyez sur N");
String repo = reponse.nextLine();
rep = repo.charAt(0);
}while(rep != 'O' && rep != 'N');// si la reponse c'est ni N ni O on repose la question

}while(rep == 'N');//si la reponse est N on recommence, sinon on passe a la suite
//on fait les premieres lignes du tableau
System.out.println("----------------------------------------------------------------------");
System.out.println(" Celcius | Fahrenheit ");
System.out.println("----------------------------------------------------------------------");
//on affiche le tableau avec les calculs de fait
double max = (cel < far) ? far : cel;
///*
do{//on ecrit une nouvelle ligne sur le tableau
far = (( 9.0 / 5.0 ) * cel) + 32;
System.out.println(" " + cel + " " + "|" + " " + far + " ");
cel = (cel + pa);
}while(cel < max);
//*/
///*
do{// on demande si on veut recommencer la conversion
System.out.println("si vous voulez recommencer, appuyez sur O, sinon appuyez sur N");
repi = reponse.nextLine().charAt(0);
}while(repi != 'O' && repi != 'N');// si la reponse c'est ni N ni O on repose la question

}while(repi == 'O');
//*/
}


}
Hors ligne EinsteinOO7 # Posté le 16/04/2012 à 00:18:48
Avatar

Avis : Bon

Études : ESGI

J'ai fait un qui est plus simple

import java.util.Scanner;


public class test {
public static void main(String[] argvs) {
char choix = 'p';
do
{
System.out.println("------------------------------------------------------------");
System.out.println("| Conversion degres Celisus et degres Fahrenheit |");
System.out.println("------------------------------------------------------------");
Scanner scan = new Scanner(System.in);
double pd,jq,p ;
System.out.println("A partir de :");
pd=scan.nextDouble();
System.out.println("Jusqu'a :");
jq=scan.nextDouble();
System.out.println("Par pas de :");
p=scan.nextDouble();
if (jq<=pd)
System.out.println("Traitement Impossible");
else
{
System.out.println("Assurez-vous que l'imprimante est prete :");
System.out.println("Si vous etes pret, tapez o, sinon tapez n :");
char pre;
scan.nextLine();
pre = scan.nextLine().charAt(0);
if (pre == 'n')
choix='n';
else
{
System.out.println("--------------------------------------");
System.out.println("| Celesius | Fahrenheit |");
System.out.println("--------------------------------------");
double frah;
do
{
System.out.println(" " + pd +" | " + (9/5 * pd + 32) +" ");
pd += p;
}while(pd<=jq);
System.out.println("Souhaitez-vous editez une autre table :");
choix = scan.nextLine().charAt(0);
}

}

}while(choix=='o');
System.out.println("Au revoir ...");
}
}
Hors ligne samir84 # Posté le 20/04/2012 à 18:29:59

Moi j'ai plutôt fait la conversion Euro -> Francs et Franc -> Euro(habitude du tuto de m@teo), voilà mon code :

Code : Java
 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
import java.util.Scanner;


public class SDZ {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Scanner sc = new Scanner(System.in);
		int mode = 0;
		char choix = 'F', choix2 = 'R' ;
		double franc = 6.55957, euro = 0.1524490172374104;
		
	 do
	 {
		  System.out.println("Vous Voulez convertir en : 1. Euros -> Francs\n\t\t\t   2. Francs -> Euros");
		  mode = sc.nextInt();
		
	  if(mode == 1 || mode == 2)
	  {  
		if(mode == 1)
		    System.out.println("\t\t\tConversion Euros -> Francs\n\n");
		
		else
			System.out.println("\t\t\tConversion Francs -> Euros\n\n");
		
		
			System.out.println("A partir de :");
			double min = sc.nextDouble();
			System.out.println("Jusqu'à : ");
			double max = sc.nextDouble();
			System.out.println("Par pas de : ");
			double pas = sc.nextDouble();
			
			
			if(min > max || max < pas)
			{
				System.out.println("Traitement Impossible");
			}
			
			
			else
			{
			
			  int limiteBoucle = ((int)(max)-(int)(min))/(int)(pas);
			
			  do
			  {
			    System.out.println("Assurez-vous que l'imprimante soit prête\nSi vous êtes prêt, tapez O, sinon tapez N");
			  	sc.nextLine();
			    choix2 = sc.nextLine().charAt(0);
			  }while(choix2 != 'O' && choix2 != 'N');
			  
			
			  if(choix2 == 'O')
			  {
			    for(int i = 0 ; i < limiteBoucle + 1 ; i++)
			    {
			    	
			      if(mode == 1)
			      {
				    franc = min * 6.55957;
				    System.out.println("Euros = " + min + "     --->      Francs = " + franc );
			      }
			      
			      else
			      {
			    	  euro = min * 0.1524490172374104;
			    	  System.out.println("Francs = " + min + "     --->      Euros = " + euro);
			      }
			      
			      min += pas;
			    }
			  
			  }
		
			  do	
			  {
				 System.out.println("Souhaitez-vous éditer une autre table ? (O/N)");
				 sc.nextLine();
				 choix = sc.nextLine().charAt(0);
			  }while(choix != 'O' && choix != 'N');
			
			}
			
		}
	  }while(choix == 'O');
	}
}
Hors ligne titi15 # Posté le 04/05/2012 à 14:33:47

Bonjour,

Voici ma production pour ce TP.
Merci pour cet excellent tutoriel.
Une chose m'étonne : quand je veux rentrer un pas décimal, je dois utiliser la virgule française : 5,5 par exemple. Alors qu'à l'affichage, j'obtiens, en sortie dans le tableau, des points décimaux : 123.6 par exemple.
Si, en entrée, je tape 5.5, ça me fait une erreur. Étrange, non ?
Code : Java
 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
import java.util.Scanner;

public class ConvDeg {
	/**
	 * @param args
	 */
    
    	public static double arrondi(double x, int n){
    	    return (double) ((int)(x*Math.pow(10,n)))/Math.pow(10, n);
    	}
    
	public static void main(String[] args) {
		// Déclaration des variables
		Scanner sc = new Scanner(System.in);
		char rep1='O', rep2;
		double valDep, valFin, pas, valCel, valFah;
		//Boucle principale (répétition du programme)
		while (rep1=='O')
		{
			System.out.println("----------------------------------------------------");
			System.out.println("| Conversion de degrés Celsius en degré Fahrenheit |");
			System.out.println("----------------------------------------------------");
			System.out.print("Valeur de départ en degrés Celsius : ");
			valDep=sc.nextDouble();
			System.out.print("Valeur de fin en degrés Celsius : ");
			valFin=sc.nextDouble();
			// Gestion de l'erreur si valFin<valDep
			while (valFin<=valDep)
			{
				System.out.println("Erreur : La valeur de fin doit être supérieure à la valeur de début !");
				System.out.print("Entrer une autre valeur de fin en degrés Celsius : ");
				valFin=sc.nextDouble();
			}
			System.out.print("Entrer le pas : ");
			pas=sc.nextDouble();
			// Gestion de l'erreur si pas supérieur à l'intervalle ou pas <0
			while ((pas>(valFin-valDep)) || (pas<=0))
			{
				System.out.println("Erreur : pas invalide !");
				System.out.print("Entrer une autre valeur du pas : ");
				pas=sc.nextDouble();
			}
			System.out.print("Etes-vous prêt à commencer ? (O/N) : ");
			rep2=sc.next().charAt(0);
			// Gestion des entrées claviers autres que O ou N
			while (rep2!='O' && rep2!='N')
			{
				System.out.print("Répondre par O (oui) ou N (non) : ");
				rep2=sc.next().charAt(0);
			}
			// Arrêt du programme si réponse N
			if (rep2=='N') break;
			// Début du tableau
			System.out.println("Table de conversion Celsius/Fahrenheit");
			System.out.println("------------------------------------------------------------");
			System.out.println("|          Celsius          |          Fahrenheit          |");
			System.out.println("------------------------------------------------------------");
			valCel=valDep;
			valFah=arrondi((9/5)*valCel+32,1);
			while (valCel<=valFin) // Plusieurs cas pour assurer l'alignement
			{
				if (valCel<100)
				{
					if (valFah<100)
					{
						System.out.println("|            "+valCel+"           |            "+valFah+"              |");
					}
					else
					{
						System.out.println("|            "+valCel+"           |            "+valFah+"             |");
					}
				}
				else
				{
					System.out.println("|            "+valCel+"          |            "+valFah+"             |");
				}
				valCel=arrondi(valCel+pas,1);
				valFah=arrondi((9/5)*valCel+32,1);
			}
			System.out.println("------------------------------------------------------------");
			System.out.print("Souhaitez-vous éditer une autre table ? (O/N) : ");
			rep1=sc.next().charAt(0);
			// Gestion des réponses autres que O et N²
			while (rep1!='O' && rep1!='N')
			{
				System.out.print("Répondre par O (oui) ou N (non) : ");
				rep1=sc.next().charAt(0);
			}
		}
	}
}
Hors ligne Tony60 # Posté le 18/05/2012 à 04:21:44
Avatar

Avis : Très bon

Études : IUT Lens

Très bon TP, il m'a bien fait chauffer les neurones !

Voici mon code :

Code : Java
  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
import java.util.Scanner;

class Conv {
	
   
	public static void main(String[] args) { 
		
		
		char restart = ' ';
		
     
	do {
		
				System.out.println("---------------------------------------");
				System.out.println("|   Convertion Celsius / Fahrenheit   |");
				System.out.println("---------------------------------------");
				System.out.println(" ");
				
				
				//--------------------- VARIABLES ---------------------
				double nombre1 = 0;									   // A partir de...
				double nombre2 = nombre1;							   // Jusqu'à...
				double pas = 0.1;									   // On convertit tous les...
				char rep = ' ';										   // Accord de l'utilisateur.
				Scanner sc = new Scanner(System.in);                   // Pour lire les données entrées par l'utilisateur.
				//-----------------------------------------------------
				
				
				
				while ( rep != 'o') { 
					
					
					
						System.out.print("[Celsius] - Convertir à partir de : ");
					
						nombre1 = sc.nextDouble();
						
						
						
						//----------------------------------------------------------------------------------------
						nombre2 = nombre1;
						
						do {	
								if ( nombre2 < nombre1 ) { System.out.println("Le nombre d'arrivée est plus grand que le nombre de départ !"); }
							
								System.out.print("[Celsius] - Convertir jusqu'à : ");
									nombre2 = sc.nextDouble();
							
						}while(nombre2 < nombre1);
						
						
							
						//----------------------------------------------------------------------------------------		
						do { 
								if ( pas > (nombre2 - nombre1)) { System.out.println("--> Le pas est trop grand ! "); }
								else if ( pas <= 0 ) { System.out.println("--> Le pas doit être supérieur à 0 ! "); }
								
								System.out.print("[Celsius] - Avec un pas de : ");
									pas = sc.nextDouble(); 
									
						}while( pas > (nombre2 - nombre1) || pas <= 0);
				
						
						
						//----------------------------------------------------------------------------------------
						System.out.print("--> Lancer la convertion [Celsius->Fahrenheit] ? ( o / n ) : ");
							rep = sc.next().charAt(0);
							
						
				}
				


				
				
				// ------------------------------- Ici on commence la convertion --------------------------------
				
		
				int valeurs = 0;
				double fahren = ((9.0/5.0) * nombre1) + 32;
				
		
				
				
				
				System.out.println(" ");
				System.out.println(" ");
				System.out.println("------------------------------------------------------------");
				System.out.println("|        Celsius           |           Fahrenheit          |");
				System.out.println("------------------------------------------------------------");
		
				
				while ( nombre1 <= nombre2 && nombre1 < 100 ) {
					
					if ( nombre1 < 10 ) { System.out.println("           "+(arrondi(nombre1, 1))+"°C           |             "+(arrondi(fahren, 1))+"°F              "); }
					else if ( nombre1 >= 10 && nombre1 < 100 ) { System.out.println("          "+(arrondi(nombre1, 1))+"°C           |             "+(arrondi(fahren, 1))+"°F             "); }
					
					
					nombre1 = nombre1 + pas;
					fahren = ((9.0/5.0) * nombre1) + 32;
					valeurs++;
					
				}
				
				
				System.out.println("------------------------------------------------------------");
				if ( valeurs < 10 ) System.out.println("|  --> "+valeurs+" résultats affichés                                |");
				else if ( valeurs >= 10 ) System.out.println("|  --> "+valeurs+" résultats affichés                               |");
				System.out.println("------------------------------------------------------------");
				System.out.println(" ");
				System.out.println(" ");
				System.out.print("Voulez-vous effectuer une nouvelle convertion ? ( o / n ) : ");
				restart = sc.next().charAt(0);
		
		
		}while( restart == 'o');
		
	System.out.print("Merci d'avoir utilisé le programme ! ");
	
	
	} 
	
	
	public static double arrondi(double A, int B) {
        return (double) ( (int) (A * Math.pow(10, B) + .5)) / Math.pow(10, B);
}
	
 
}

Etudiant en DUT Services et Réseaux de Communication - 1ère année
 

Voir tous les commentaires