Problème de variable non initialisée et d'initialisation de cette même variable

Version imprimable

13/06/2016, 22h21
Alexandre2019

1 pièce(s) jointe(s)

Problème de variable non initialisée et d'initialisation de cette même variable

Alors voilà j'ai crée mon petit truc pas encore terminé en raison de certains problèmes qui est sensé trié la pop. de quatres villes par ordres croissant et je ne comprend pas pq dans mon System.out.println(t1); la pop. de la ville la plus peuplé n'est pas affiché ... de plus dans mon case h1 : il me dit case expression must be constant expression ce qui m'échappe un peu. En gros je comprend vrmt pas ces deux points et j'espère que vous pourrez m'aider ;) Merci d'avance ;)
13/06/2016, 23h48
joel.drigo
Salut,
1. On est obligé d'initialiser une variable locale pour pouvoir l'utiliser en lecture (seuls les attributs sont initialisés avec une valeur par défaut).
  t4 n'ayant pas de valeur, tu ne peux pas écrire t[0]=t4;.
2. On ne peut pas utiliser une variable comme valeur de case dans un switch. De plus, comme il semble que tes attributs h1, h2, h3 et h4 sont valuées par appel de méthodes, elles doivent avoir toute comme valeur 0, tant qu'on appelle pas la méthode qui leur donne une valeur différente, la valeur d'initialisation par défaut : il est interdit d'avoir plusieurs cas de switch pour une même valeur. Potentiellement, l'appel des méthodes peut leur donner une même valeur en plus. C'est d'ailleurs une des raisons qui interdit l'usage de variable pour les cas d'un switch : la possibilité qu'à un moment on ait plusieurs cas de même valeur.
3. Pour le reste, comme je ne vois pas l'ensemble du code, je ne peux que supposer qu'il y a un gros défaut d'architecture dans ta classe et que, quelque soit ce que tu cherches à faire, ce n'est pas comme ça qu'il faut le faire.
PS : pour nous montrer du code et nous aider à te répondre plus facilement, copie ton code en mode texte dans le message et utilise la balise CODE (le bouton avec un #) pour le présenter.
13/06/2016, 23h54
tchize_

Vu d'ici on dirait que tu as essayé de bourrer du javascript dans un compilateur java :weird:

Code:

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
import java.util.Arrays;
import java.util.Scanner;
 
public class Ville 
	{
	Scanner sc = new Scanner(System.in);
	String nomVille;
	String nomPays;
	int nbreHabitants;
	int h1, h2, h3, h4;
	String v1, v2, v3, v4;
 
	public Ville()
		{
		nomVille = "Inconnu";
		nomPays = "Inconnu";
		nbreHabitants = 0;
		}
 
	public Ville(String pNom, int pNbre, String pPays)
		{
		nomVille = pNom;
		nomPays = pPays;
		nbreHabitants = pNbre;
		}
 
	public void VillePrint()
		{
		System.out.println(nomVille + ", " + nomPays + ", " + nbreHabitants + " habitants ");
		}
 
	public void VilleCreation()
		{
		System.out.print("nom : ");
		nomVille = sc.nextLine();
		System.out.print("pays : ");
		nomPays = sc.nextLine();
		System.out.print("nombre d'habitants : ");
		nbreHabitants = sc.nextInt();
		}
 
	public void Ville1Hab()
		{h1 = nbreHabitants; v1 = nomVille; System.out.print(h1);}
	public void Ville2Hab()
		{h2 = nbreHabitants; v2 = nomVille;}
	public void Ville3Hab()
		{h3 = nbreHabitants; v3 = nomVille;}
	public void Ville4Hab()
		{h4 = nbreHabitants; v4 = nomVille;}
 
	public void VilleTop()
		{
		int t1, t2, t3, t4;
		String tt1, tt2, tt3, tt4;
		System.out.println("Classement de la population des quatres villes :");
		System.out.print(h1);
		int t[] = {h1, h2, h3, h4};
		System.out.print(h1);
		System.out.print(" y " + h1 + h2 + h3 + h4);
		Arrays.sort(t);
		t4 = t[0];
		t3 = t[1];
		t2 = t[2];
		t1 = t[3] ;
		System.out.println(t1);
		System.out.println(t4);
		}
 
 
 
	}

Code:

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
public class TestVille 
	{
	public static void main(String[] args) 
		{
		Ville ville1 = new Ville("Paris", 2244000, "France");
		Ville ville2 = new Ville("Moscou", 12325000, "Russie");
		ville1.VillePrint();
		ville2.VillePrint();
 
 
 
		System.out.println("Création d'une troisième ville !");
		Ville ville3 = new Ville();
	//  ville3.VilleCreation();
		ville3.VillePrint();
 
		System.out.println("Création d'une quatrième ville !");
		Ville ville4 = new Ville();
	//	ville4.VilleCreation();
		ville4.VillePrint();
 
		ville1.Ville1Hab();
		ville2.Ville2Hab();
		ville3.Ville3Hab();
		ville4.Ville4Hab();
 
		Ville A = new Ville();
		A.VilleTop();
		}
	}

Code:

1
2
3
4
5
6
7
8
9
Paris, France, 2244000 habitants 
Moscou, Russie, 12325000 habitants 
Création d'une troisième ville !
Inconnu, Inconnu, 0 habitants 
Création d'une quatrième ville !
Inconnu, Inconnu, 0 habitants 
2244000Classement de la population des quatres villes :
00 y 00000
0

Bon voila alors j'ai un peu mieux compris le problème en gros j'ai mes variables h1 h2 h3 h4 que j'actualise dans public void Ville1Hab() mais j'ai besoin des ces variables dans public void VilleTop() comment est ce que je peux les actualiser (sinon en l'occurence elles valent 0) ?? (et merci deja de m'avoir aider, c sympa ;) )

En ne respectant pas les principes de base de la programmation objet, tu fais des trucs tordus, et tu n'arrives pas à les faire fonctionner. Bref, tu te compliques la vie.

Une classe définie une entité qui se suffit à elle-même, et est indépendante de la façon dont on va fournir les données (saisie au clavier par exemple, mais aussi lecture depuis un fichier, une base de données, etc.) et les restituer (à l'écran par exemple, en console, mais aussi dans une interface graphique, sur papier, dans un pdf, un mail, etc.)

Ceci suffit à définir une ville :
Code:

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 public class Ville { String nomVille; String nomPays; int nbreHabitants; public Ville() { nomVille = "Inconnu"; nomPays = "Inconnu"; nbreHabitants = 0; } public Ville(String pNom, int pNbre, String pPays) { nomVille = pNom; nomPays = pPays; nbreHabitants = pNbre; } public String toString() { return nomVille + ", " + nomPays + ", " + nbreHabitants + " habitants"; } public String getNom() { return nomVille; } public String getPays() { return nomPays; } public int getNbreHabitants() { return nbreHabitants; } }
Et encore, le constructeur sans argument est superflu.

Pour ce qui est du reste, on va faire des méthodes utilitaires sous forme de méthodes static pour simplifier. On peut les mettre dans une classe dédiée, par exemple VilleUtils, dans la classe de test, ou même dans la classe Ville pour simplifier (limiter à tes deux classes).

Pour ce qui est de la saisie, pour simplifier, on va limiter à une saisie au clavier :
Code:

1 2 3 4 5 6 7 8 9 10 11 public static Ville creation() { Scanner sc = new Scanner(System.in); System.out.print("nom : "); String nomVille = sc.nextLine(); System.out.print("pays : "); String nomPays = sc.nextLine(); System.out.print("nombre d'habitants : "); int nbreHabitants = sc.nextInt(); sc.nextLine(); // on vide le tampon pour les autres saisies, sinon tout ce qui sera derrière le nombre y compris le retour chariot sera encore dans le tampon return new Ville(nomVille, nbreHabitants, nomPays); // on créé la ville }
Tu vois qu'il est inutile d'avoir un constructeur sans argument, pour construire d'abord une instance avec des valeurs bidons et appeler une autre méthode (inutile elle aussi) pour saisir et mettre à jour.

A ce stade, ton programme de test devient simplement :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 public class TestVille { public static void main(String[] args) { Ville ville1 = new Ville("Paris", 2244000, "France"); Ville ville2 = new Ville("Moscou", 12325000, "Russie"); System.out.println("Ville 1 : "+ ville1); System.out.println("Ville 2 : "+ ville2); System.out.println("Création d'une troisième ville !"); Ville ville3 = Ville.creation(); System.out.println("Ville 3 : "+ ville3); System.out.println("Création d'une quatrième ville !"); Ville ville4 = Ville.creation(); System.out.println("Ville 4 : "+ ville4); } }
Maintenant le tri. On veut trier un tableau de villes. Faisons donc un tableau de villes : [c]Ville[] villes = {ville1, ville2, ville3, ville4};[/code]

Et on va faire une méthode pour trier les villes par population, dans la classe Ville, par exemple, comme on a fait la méthode de création. Une méthode static donc, qui prend un tableau en paramètre et va trier ce tableau.
Code:

1 2 3 public static void trierParPopulation(Ville[] villes) { /*...là on va mettre le code de tri */ }
Et le programme deviendra simplement :
Code:

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 public class TestVille { public static void main(String[] args) { Ville ville1 = new Ville("Paris", 2244000, "France"); Ville ville2 = new Ville("Moscou", 12325000, "Russie"); System.out.println("Ville 1 : "+ ville1); System.out.println("Ville 2 : "+ ville2); System.out.println("Création d'une troisième ville !"); Ville ville3 = Ville.creation(); System.out.println("Ville 3 : "+ ville3); System.out.println("Création d'une quatrième ville !"); Ville ville4 = Ville.creation(); System.out.println("Ville 4 : "+ ville4); Ville[] villes = {ville1, ville2, ville3, ville4}; Ville.trierParPopulation(villes); System.out.println("Les villes par ordre de population de la plus petite à la plus grande"); for(Ville ville : villes) { System.out.println(ville); } } }
Venons-en au tri proprement dit. Alors là se pose le problème de savoir dans quel cadre tu dois réaliser ce tri. Est-ce un exercice imposé, avec des choses que tu as le droit d'utiliser ou pas.

Déjà, dans le code que tu as montré, tu utilises la méthode Arrays.sort(tableau). Cette méthode ne peut trier que des Comparable, ce qui veut dire qu'il faut rendre la classe Ville comparable pour pourvoir faire
Code:

1 2 3 public static void trierParPopulation(Ville[] villes) { Arrays.sort(villes); }
La rendre comparable signifie implémenter l'interface Comparable, et, donc, en conséquence sa méthode compareTo(). Ceci impose aux villes d'être triables selon un ordre unique défini. Elles seront comparables par population, et ne pourront l'être par nom par exemple, ou autre.

On peut également utiliser la méthode Arrays.sort(villes, comparator). C'est quasiment la même chose, sauf que l'ordre de tri est en dehors de la classe Ville, dans une autre classe, ce qui permet d'en avoir plusieurs possibles. En plus, on le verra plus tard, ça évite d'avoir à s'embetter à programmer la comparaison. Si tu n'as pas de contrainte sur l'utilisation ou non de ce genre de chose, autant ne pas s'embetter à le faire, mais ça peut être intéressant pour toi de le faire ensuite, juste pour apprendre.

Donc, pour résumer, il suffit de faire :
Code:

1 2 3 public static void trierParPopulation(Ville[] villes) { Arrays.sort(villes, Comparator.comparing(Ville::getNbreHabitants)); }
Et hop, le tableau sera trié par nombre d'habitants.

Bon, si tu veux le faire toi-même (et je ne saurais que trop te le conseiller), voici de quoi commencer :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public static void trierParPopulation(Ville[] villes) { Arrays.sort(villes, new Comparator<Ville>() { @Override public int compare(Ville ville1, Ville ville2) { int nbHabVille1 = ville1.getNbreHabitants(); int nbHabVille2 = ville2.getNbreHabitants(); /* ici il faut retourner * 0: si le nombre est le même * -1: si le nombre de ville1 est inférieure à celui de ville2 * 1: si le nombre de ville1 est supérieure à celui de ville2 */ } }); }
A noter que la première méthode ne fonctionne qu'en Java 8. En Java 7, tu seras obligé de faire un Comparateur.
Tu peux essayer ensuite si tu veux d'implémenter Comparable dans la classe Ville.

Il y a d'autres façons de procéder, mais tu auras l'occasion de les voir plus tard.