Discussion :

[denebe]

Bonjour,

je débute Java (2 semaines), je me pose pas mal de questions concernant le stockage en mémoire des différentes choses (pour ne pas dire objets) que j'utilise.

Je crois avoir saisi qu'une variable primitive, lorsqu'elle est déclarée au sein d'une classe comme variable de classe (static) ou comme variable d'instance, prend une valeur par défaut (pout le type int, c'est 0).

C'est la même chose pour les variables de type référence (désolé si mes mots sont mal choisis...), un objet en somme. Sauf que dans cette situation, au lieu d'avoir une référence, on a 'null'.

Voici maintenant 6 exemples sur lesquels mes questions vont porter par la suite:

1)

Code Java :

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

1
2
3
4
5
6
7
8
9
10
public class DefaultMain {
 
	static int i;
 
	public static void main(String[] args) {	
 
		System.out.println(i);
	}
 
}

Konsole:
0

2)

Code Java :

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

1
2
3
4
5
6
7
8
9
10
public class DefaultMain {
 
	int i;
 
	public static void main(String[] args) {	
 
		System.out.println(i);
	}
 
}

Konsole:
Ne compile pas

3)

Code Java :

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 class DefaultMain {
 
	public static void main(String[] args) {
 
	DefaultValue obj1 = new DefaultValue();
	System.out.println(obj1.getExemple());	
	}
}
 
public class DefaultValue {
 
        int i;
 
        // Méthode retournant l'entier 'i' non initialisé
        public int getExemple(){
		return i;
	}
}

Konsole:
0

4)

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 DefaultMain {
 
	static Mitarbeiter m1; // Un objet 'm1' de type Mitarbiter est déclaré
 
	public static void main(String[] args) {		
 
		System.out.println(m1);
	}
}
 
public class Mitarbeiter {
 
}

Konsole:
null

5)

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 DefaultMain {
 
	Mitarbeiter m1; // Un objet 'm1' de type Mitarbiter est déclaré
 
	public static void main(String[] args) {		
 
		System.out.println(m1);
	}
}
 
public class Mitarbeiter {
 
}

Konsole:
Ne compile pas

6)

Code Java :

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
public class DefaultMain {
 
		public static void main(String[] args) {
 
                           //  Appel du constructeur par défaut
		          DefaultValue obj1 = new DefaultValue();
 
                          // Est-ce que 'obj1' est créé ?
		          obj1.setInitializierung();
 
                          // Est-ce que 'm1' est créé ?
		          obj1.setInitializierung(obj1.m1);
	      }
}
 
public class Mitarbeiter {
 
}
 
 
public class DefaultValue {
 
	Mitarbeiter m1; // Un objet 'm1' est juste déclaré de Type 'Mitarbeiter'
 
	public void setInitializierung(){
		if(this!=null)
			System.out.println("L'objet " + this + " a été créé");
		else
			System.out.println("L'objet " + this + " n'est pas encore créé");
	}
 
	public void setInitializierung( Mitarbeiter m){
		if(m!=null)
			System.out.println("L'objet " + m + " a été créé");
		else
			System.out.println("L'objet " + m + " n'est pas encore créé");
	}
}

Konsole:
L'objet DefaultValue@6d06d69c a été créé
L'objet null n'est pas encore créé





Questions variable primitive:

** Un variable primitive peut être simplement déclarée et utilisée si elle est - static - ou bien si elle est une variable d'instance. Vrai ? c.f. 1 & 3

** Ceci est faux si la variable primitive se trouve déclarée et (non static) dans la classe comportant la méthode 'main' ? (Est-ce que cette phrase a du sens écrite comme cela ?) c.f. 2

** Pourquoi lorsque qu'une variable primitive est déclarée comme variable d'instance dans une classe (autre que celle contenant le main), je peux utiliser un 'getteur' (accesseur) dans la méthode main et afficher la valeur par défaut ?
En fait j'aimerais comprendre pourquoi 3 compile, rend la valeur par défaut, alors que 2 ne compile pas, sachant que dans les deux cas la variable primitive en question n'est pas static.

============================================================================

Questions objet:

Le début de mes questions concernant les objets sont exactement les mêmes que celle concernant les variables primitives...

** Un objet peut être simplement déclaré et utilisé si il est - static - ou bien si il est une variable d'instance. Vrai ? c.f. 4 & 6

** Ceci est faux si l'objet se trouve déclaré (et non static) dans la classe comportant la méthode 'main' ? (Est-ce que cette phrase a du sens écrite comme cela ?) c.f. 5

** Pourquoi lorsque qu'un objet est déclaré comme variable d'instance dans une classe (autre que celle contenant le main), je peux utiliser un 'getteur' (accesseur) dans la méthode main et afficher la valeur par défaut de cette objet?
En fait j'aimerais comprendre pourquoi 6 compile, rend la valeur par défaut, alors que 5 ne compile pas, sachant que dans les deux cas l'objet en question n'est pas static.

Les deux dernières:

***** Dans l'exemple 6, DefaultValue@6d06d69c est la référence de l'objet 'obj1', vrai ?

***** Dans les exemples 4 et 6, que veut dire 'null' ?
J'ai déclaré un objet, jusque là j'ai bon je crois.
Mais que veut dire 'null' exactement ? C'est un référence particulière ? Si j'ai deux objets simplement déclaré (dans le même cas de figure 4 ou 6), sur chacun des deux objets, 'null' aura le même sens ?

Merci de m'avoir lu et pour votre aide,
Denebe.

[joel.drigo]

Bonjour,

Salut,

je débute Java (2 semaines), je me pose pas mal de questions concernant le stockage en mémoire des différentes choses (pour ne pas dire objets) que j'utilise.

Bon courage :°

Je crois avoir saisi qu'une variable primitive, lorsqu'elle est déclarée au sein d'une classe comme variable de classe (static) ou comme variable d'instance, prend une valeur par défaut (pout le type int, c'est 0).

Exact : une variable primitive prend une valeur par défaut dépendant de son type, 0 pour un int, false pour un boolean, 0d pour un double....

C'est la même chose pour les variables de type référence (désolé si mes mots sont mal choisis...), un objet en somme. Sauf que dans cette situation, au lieu d'avoir une référence, on a 'null'.

Oui. Et référence est bien le mot le plus adapté (mieux que pointeur ou adresse).

2)

Code Java :

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

1
2
3
4
5
6
7
8
9
10
public class DefaultMain {
 
	int i;
 
	public static void main(String[] args) {	
 
		System.out.println(i);
	}
 
}

Konsole:
Ne compile pas

Normal : i n'est pas static, et la méthode main est statique, et n'a donc pas accès à une variable d'instance directement (uniquement indirectement par l'instance justement).

5)

Code :

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

1
2
3
4
5
6
7
8
9
public class DefaultMain {
 
	Mitarbeiter m1; // Un objet 'm1' de type Mitarbiter est déclaré
 
	public static void main(String[] args) {		
 
		System.out.println(m1);
	}
}

Konsole:
Ne compile pas

Même cause, même effet.

Code :

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

1
2
3
4
5
6
	public void setInitializierung(){
		if(this!=null)
			System.out.println("L'objet " + this + " a été créé");
		else
			System.out.println("L'objet " + this + " n'est pas encore créé");
	}

Cela n'a pas d'intérêt de faire ça. This c'est soi-même, l'instance elle-même. Je citerai bien Descartes : "Je pense donc je suis" : si je suis, c'est que j'existe. Et réciproquement.
En d'autre mot : this n'est jamais null. null.this n'a aucun sens. Et si une méthode d'instance d'une instance peut s'exécuter, c'est que l'instance existe, donc que this, l'instance elle-même n'est pas null.
En revanche :

Code :

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

1
2
3
4
5
6
public void setInitializierung( Mitarbeiter m){
		if(m!=null)
			System.out.println("L'objet " + m + " a été créé");
		else
			System.out.println("L'objet " + m + " n'est pas encore créé");
	}

trahit une confusion : la variable n'est pas l'objet (ou l'instance d'objet pour être plus précis). La variable c'est juste un nom qui a un instant t à une valeur, celle d'une référence d'objet, ou pas (donc null dans ce cas, pour répondre prématurément à la question de la fin).

Questions variable primitive:

** Un variable primitive peut être simplement déclarée et utilisée si elle est - static - ou bien si elle est une variable d'instance. Vrai ? c.f. 1 & 3

On peut créer une variable de type primitive, static ou pas, en effet, dans n'importe quelle classe, ou méthode. Quant à pouvoir être utilisée ou pas, ça dépend de sa portée, et de la où on veut l'utilser. Eventuellement, ça peut dépendre d'autres conditions selon de comment on veut l'utiliser également (lire sa valeur ou la modifier).

** Ceci est faux si la variable primitive se trouve déclarée et (non static) dans la classe comportant la méthode 'main' ? (Est-ce que cette phrase a du sens écrite comme cela ?) c.f. 2

J'ai répondu à ça. Ce n'est qu'une question de contexte statique ou pas.

** Pourquoi lorsque qu'une variable primitive est déclarée comme variable d'instance dans une classe (autre que celle contenant le main), je peux utiliser un 'getteur' (accesseur) dans la méthode main et afficher la valeur par défaut ?

En fait j'aimerais comprendre pourquoi 3 compile, rend la valeur par défaut, alors que 2 ne compile pas, sachant que dans les deux cas la variable primitive en question n'est pas static.

Toujours un problème de contexte statique. Une variable statique n'est attachée à aucune instance. Donc en quelque sorte elle est attachée à toutes les instances. De la même manière une méthode statique est également attachée à toutes les instances en même temps : elle ne peut donc pas accèder à une variable d'instance, puisqu'elle ne saurait pas laquelle (instance). On pourrait dire, "ouais mais s'il n'y a qu'une seule instance c'est forcément celle-là". Si on faisait ce genre de truc, on n'aurait pas un comportement global, mais un cas particulier qui ne serait pas évident à repérer : ça compliquerait pas mal la tâche de faire fonctionner un programme (parce que quand ce genre de truc pourri existe, il y a toujours quelqu'un pour trouver malin de l'utiliser, à tord).

Donc pour résumer :

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
public class Exemple {
 
    private int variable;
 
     private static int autreVariable;
 
    public int getVariable() {
           return variable;
    }
 
    public void setVariable(int param) {
         variable=param;
    }
 
    public static int getAutreVariable() {
           return autreVariable;
    }
 
    public static void setAutreVariable(int param) {
         autreVariable=param;
    }
 
 
 
}

Code :

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

1
2
3
4
5
6
7
 
Exemple ex1 = new Exemple();
Exemple ex2 = new Exemple();
ex1.setVariable(1);
ex2.setVariable(2);
ex1.setAutreVariable(3);
ex2.setAutreVariable(4);

ex1.getVariable() retourne 1
ex2.getVariable() retourne 2
ex1.getAutreVariable() retourne 4
ex2.getAutreVariable() retourne 4

Attention, j'ai fait ça juste pour l'exemple. Par convention, pour éviter la confusion justement, on n'appelle jamais une méthode statique sur une variable qui représente une instance, mais sur la classe, comme ça :

Code :

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

Exemple.setAutreVariable(3);

et

Code :

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

Exemple.getAutreVariable();

Questions objet:

** Pourquoi lorsque qu'un objet est déclaré comme variable d'instance dans une classe (autre que celle contenant le main), je peux utiliser un 'getteur' (accesseur) dans la méthode main et afficher la valeur par défaut de cette objet?

Attention,

Code :

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

private UneClasse var;

Ne déclare pas d'objet., mais une variable de type UneClasse, dont la valeur pourra être la référence d'un objet, ou pas (donc la valeur sera null).

Les classes décrivent des objets. Les variables les désignent.

Code :

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

1
2
3
 
Object o1 = new Object();
Object o2 = o1;

On n'a ici qu'une seule instance de classe Object, mais deux variables qui ont pour valeur sa référence (la même donc).

Les deux dernières:

***** Dans l'exemple 6, DefaultValue@6d06d69c est la référence de l'objet 'obj1', vrai ?

Pour être plus juste, il s'agit de la représentation en chaine de caractères par défaut de l'instance (le résultat de la méthode toString() de la classe Object. Cela contient en effet un truc qui pourrait être considéré comme une sorte de référence, mais on n'en sait rien normalement et on n'a pas besoin de le savoir (à la limite avoir un identifiant garanti comme unique suffit lorsqu'on débogue ou on profile, mais pas plus lorsqu'on programme en Java). Mais la méthode toString() de Object pourrait être codée différement, et surtout, on pourrait très bien redéfinir celle de DefaultValue et rendre complètement faux toute interprétatio, genre :

Code :

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

1
2
3
4
5
6
7
8
public class DefaultValue {
 
    public String toString() {
            return "DefaultValue@"+4242+"F00D" ;
    }
 
 
}

et donc rendre fausse toute interpréation de référence.

***** Dans les exemples 4 et 6, que veut dire 'null' ?
J'ai déclaré un objet, jusque là j'ai bon je crois.
Mais que veut dire 'null' exactement ? C'est un référence particulière ? Si j'ai deux objets simplement déclaré (dans le même cas de figure 4 ou 6), sur chacun des deux objets, 'null' aura le même sens ?

Tu l'as compris, une variable de type objet peut référencer un objet. Mais tant qu'elle ne le fait pas, elle ne référence aucun objet. C'est ça que null signifie.

Code :

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

1
2
3
4
5
6
7
// dans une méthode
Object s1= new Object(); // s1 référence un objet
Object s2=null; // s2 n'en référence aucun
 
String vs1 = s1.toString(); // fonctionne sans problème : on récupère la représentation String de l'instance s1 dans la variable vs1
 
String vs2 = s2.toString(); // plante à l'exécution : NullPointerException. On n'a aucune instance référencé par s2, Java ne sait donc pas où appeler cette méthode toString()...

Attention :

Code :

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

1
2
3
4
5
6
// dans une méthode
 
Object s1 = new Object(); // s1 référence un objet
Object s2; // s2 n'a aucune valeur, donc ni une référence d'objet, ni même null
 
String vs2 = s2.toString(); // ne compile pas, le compilateur dit que ça ne sert à rien d'essayer d'exécuter ce truc, s2 n'a aucune valeur.

Code :

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

1
2
3
public class Exemple {
 
     private Object s2;

Ici, on est dans le cas particulier d'une variable d'instance. Sa valeur est null par défaut, sans avoir à le préciser explicitement (contrairement au cas précédent).

[denebe]

Bonjour joel,

je te réponds tardivement (désolé) juste pour te remercier de ta réponse (elle rapide) claire et détaillée.

A+