Que signifie null comme valeur par defaut d'un Objet simplement déclaré ?
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:
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:
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:
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:
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:
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:
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.
