Discussion :

[asallou]

Bonjours

J'ai un petit soucis. J'aimerai, avec différentes classes, faire varier une variable int.
Lorsque je le compile, le message "Exception in thread "main" java.lang.StackOverflowError" apparait. Je sais que ça veut dire qu'il y a une boucle infinie, mais je ne voit pas comment le résoudre...

Voici le code source de mes 2 classes :

1er classe

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class Maclasse {
	public int variable;
	public Maclasse(){
		variable = variable +32;
		Mafille1 mafille = new Mafille1();
		System.out.println(mafille.variable);
	}
	public static void main (String [] arg){
		new Maclasse();
	}
}

2eme classe

Code :

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

1
2
3
4
5
6
public class Mafille1 extends Maclasse {
	public int methode(){
		variable = variable + 54;
		return variable;
	}
}

[rg77140]

Bonjour,

Oui tu as bien une boucle infinie...

Comme tu n'as pas redéfinit de constructeur dans la classe Mafille1, "new Mafille1()" appel le constructeur de la classe dont il hérite, soit le constructeur de Maclasse, qui lui même fait un "new Mafille1()", et ainsi de suite.

en gros ton code fait

Code :

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

1
2
3
4
5
6
7
8
new Maclasse();
 -> variable = variable +32;
 -> Mafille1 mafille = new Mafille1(); // appel au constructeur de Maclasse à cause de l'héritage
      -> variable = variable +32;
      -> Mafille1 mafille = new Mafille1();
          -> variable = variable +32;
          -> Mafille1 mafille = new Mafille1();
          ...

Je n'ai pas bien compris ce que tu veux faire mais tu dois casser ce cycle entre Maclasse et Mafille1...

ROmain.

[ced00]

pis c'est surtout inutile, pourquoi vouloir accéder dans "maclasse" à variable en passant par "mafille" vu que variable est un attribut de maclasse.

autant accéder directement à variable.

L’accès à des variables entre classe est surtout intéressant lorsque les classe n'héritent pas l'une de l'autre. pour ça il suffit d'implémenter un accesseur à la variable et de passer une référence à la classe subalterne via un "this" dans le constructeur

[ced00]

ça, ça marche, mafille1 n'hérite pas de Maclasse mais accede bien à variable.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Maclasse {
	private int variable=0; // on initialise quand meme ça coute rien
	public Maclasse(){
		variable = variable +32;
		Mafille1 mafille = new Mafille1(this);
 
	}
 
public int getVariable(){return variable;}
	public static void main (String [] arg){
		new Maclasse();
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class Mafille1  {
 
Maclasse mere;
 
public Mafille1(Maclasse vMere){
 
mere=vMere;
System.out.println(mere.getVariable());
}
 
 
}

[asallou]

tout d'abord, merci beaucoup d'avoir répondu aussi vite.
Mais la cause de mon message est enfaîte, de faire varier une variable entre plusieurs classes, en non la faire varier avec l'une et l'afficher avec l'autre.
Ce serait, en gros, une variable "globale" , ou commune à tout les classes de mon projet. Cette variable pourra être lue et/ou modifiée par toutes les classes de mon projet (enfin plusieures)
S'il est possible de le faire avec ton code, ced00, peux-tu me le dire ?
Pour ce qu'il en est de l'utilisation, cet exemple me servira à créer un projet de code plus gros.

Antoine

[ced00]

Oui bien sur c'est possible, je te fais un exemple plus commenté.

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
 
public class Maclasse {
// on déclare variable private c'est mieux de procéder ainsi
	private int variable=0; // on initialise quand meme ça coute rien
	public Maclasse(){
		variable = variable +32;
 
                /* on passe à ma fille une référence à Maclasse 
                 pour qu'elle puisse avoir acces au getter et  setter de variable
                */
		Mafille1 mafille = new Mafille1(this);
 
	}
// un getter pour acceder à la variable 
public int getVariable(){return variable;}
 
// un setter pour pouvoir modifier la variable
public void setVariable(int vInt){variable=vInt;}
 
	public static void main (String [] arg){
		new Maclasse();
	}
}

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
 
public class Mafille1  {
 
/* je déclare un attribut  de Mafille1 comme Maclasse pour avoir acces à ses méthodes et ses variables, de cette manière toute les méthodes de mafille1 auront une référence vers Maclasse
*/
Maclasse mere;
 
public Mafille1(Maclasse vMere){
 
// j'identifie mere à vMere (donc le "this" passé plus haut 
 
mere=vMere;
 
// j'accede à variable
System.out.println(mere.getVariable());
 
si je veux je la stocke en copie
int a= mere.getVariable();
 
// je modifie a
a=a+45;
 
// et boum je change la valeur de variable dans la classe de départ
mere.setVariable(a);
 
 
//je peux même condenser le code plus haut en 
 
mere.setVariable(mere.getVariable()+45);
 
System.out.println(mere.getVariable());
 
}
 
 
}

Sur le même principe en passant une simple référence Mafille1 peut avoir accès à toutes les méthodes de MaClasse.

[Sharcoux]

Une méthode moins recommandée, mais plus facile si tu fais juste un petit projet perso, c'est de faire une variable static :

Code :

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

1
2
3
4
5
6
7
8
class Truc {
    static int variable = 10;//par exemple
    ...
}
class Muche {
   //modification de la variable
   Truc.variable = 11;
}

Je te dis pas de le faire trop dans tes projets, mais je t'encourage à essayer pour savoir que ça existe.

[professeur shadoko]

t
Ce serait, en gros, une variable "globale" , ou commune à tout les classes de mon projet. Cette variable pourra être lue et/ou modifiée par toutes les classes de mon projet (enfin plusieures)

pas très recommandable :
- dans 90% des cas essayer d'avoir comme ça une variable partagée est un défaut de conception

pour les puristes amateurs de poils sur les oeufs:
- aussi bizarre que ça puisse paraître il n'existe pas vraiment de "variable globale" en Java (je sens que ça va hurler et qu'on va me dire qu'une variable static est une variable "globale"... et bien ce n'est pas exact! -pour les amateurs de challenges: votre mission, si vous l'acceptez, créer une variable public static final qui ait deux valeurs différentes dans une application java! -c'est parfaitement possible! - )

[rg77140]

Faut quand même le vouloir...

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
public class Test {
 
	private static String privateStaticChar = "valeur initiale";
	public static final String MonChampStaticFinal = privateStaticChar;
 
	public static void main(String[] args) throws Exception {
		System.out.println(Test.MonChampStaticFinal); // print "valeur initiale"
		setFinalStatic(Test.class.getField("MonChampStaticFinal"), "valeur modifiée");
		System.out.println(Test.MonChampStaticFinal); // print "valeur modifiée"
    }
 
	static void setFinalStatic(Field field, Object newValue) throws Exception {
		field.setAccessible(true);
		Field modifiersField = Field.class.getDeclaredField("modifiers");
		modifiersField.setAccessible(true);
		modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
		field.set(null, newValue);
	}
}

D'ailleurs si la variable est déclarée de cette façon

Code :

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

public static final String MonChampStaticFinal = "valeur initiale";

J'ai pas réussi, je ne sais pas si c'est possible.

Romain.

[professeur shadoko]

ah ... le challenge c'est d'avoir DEUX valeurs en même temps!
tu fais tes initialisations "public static final"
par exemple:

Code :

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

1
2
 
public static final long START_TIME = System.currentTimeMillis() ;

tu ne touches pas à ce code!

et maintenant deux codes différents dans la même application lisent deux valeurs différentes!
(ceci pour montrer qu'il n'y a pas de "variable globale " en Java)

[tchize_]

Challenge accepté

La matériel de travail, très simple:

Code :

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

1
2
3
4
5
package dvp.deux;
import java.util.Random;
public class Holder {
	public static final long valeur = new Random().nextLong(); // ça change plus vite que System.currentTimeMillis()
}

Code :

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

1
2
3
4
package dvp;
 
// Juste plus facile de travailler avec une interface
public interface Test {	public void lireHolder(); }

Code :

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

1
2
3
4
5
6
package dvp.deux;
import dvp.Test;
 
public class TestImpl implements Test {
	@Override	public void lireHolder() {System.out.println("Holder vaut "+Holder.valeur);} //Lit une variable statique
}

Et le static final qui change sans vraiment changer mais qui change quand même

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
package dvp;
 
import java.net.URL;
import java.net.URLClassLoader;
import dvp.deux.TestImpl;
 
public class Main {
 
	private static URLClassLoader cl = (URLClassLoader)Main.class.getClassLoader();
	public static Test creerTest() throws Exception{
		return (Test) new URLClassLoader(cl.getURLs(),new URLClassLoader(new URL[0],cl){
			@Override
			protected synchronized Class<?> loadClass(String name,
					boolean resolve) throws ClassNotFoundException {
				return name.startsWith("dvp.deux")? null : super.loadClass(name, resolve);
			}
		}).loadClass("dvp.deux.TestImpl").newInstance();
	}
	public static void main(String[] args) throws Exception{
		creerTest().lireHolder();
		creerTest().lireHolder();
		creerTest().lireHolder();
		// Bizarre :-) Holder changerais de valeur? Il est final pourtant
		new TestImpl().lireHolder();
		new TestImpl().lireHolder();
		new TestImpl().lireHolder();
		// Ha ben là ça marche pourtant :-)
		Test test = creerTest();
		test.lireHolder();
		test.lireHolder();
		test.lireHolder();
		// Et là aussi. 
	}
}

La sortie pour ceux qu'on pas envie de lancer

Code :

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

1
2
3
4
5
6
7
8
9
Holder vaut -4197133622780583216
Holder vaut -5834188176133006645
Holder vaut 4987447259933688193
Holder vaut -5169454914521687391
Holder vaut -5169454914521687391
Holder vaut -5169454914521687391
Holder vaut -9041518560090199994
Holder vaut -9041518560090199994
Holder vaut -9041518560090199994

Bonne migraine les débutants

[Catsoumoto]

Cette variable pourra être lue et/ou modifiée par toutes les classes de mon projet (enfin plusieures)
Antoine

Pour cela il y a le singleton, qui est une instance unique d'une classe que tu peu récupérer dans toute les autres classes toute les valeurs modifie par une sera modifie dans la seul instance possible de cette class.

http://fr.wikipedia.org/wiki/Singlet...de_conception)

[ced00]

à Tchize

Ben non ça ne vaut pas

Code :

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

return (Test) new URLClassLoader(cl.getURLs(),new URLClassLoader(new URL[0],cl)

à chaque fois tu retournes une nouvelle instance de ta classe, ce n'est donc pas la même variable que tu lis.

ça à l'air de changer mais tu n'accèdes jamais à la même.

[tchize_]

Holder n'est jamais instancié. JE peux te faire le même sans l'interface Test, en accédant par introspection à la valeur dans Holder, mais j'aivais envie de garder le code lisible

L'important, c'est que tu peux avoir plusieurs fois Holder.class en mémoire, avec chacune une champ statique valeur différent, un singleton ou une donnée statique ,n'est unique que au sein d'un classloader. Il n'y a pas d'absolu dans la jvm

[professeur shadoko]

ben oui effectivement une variable partagée (static final) ne l'est que dans le contexte d'un ClassLoader.
ça à l'air d'une hypothèse d'école mais la première fois que je me suis fait avoir (avec JINI) j'ai été plutôt défrisé.