Discussion :

[Dark_TeToN]

Bonjour à tous !

Mon titre n'est peut-être pas très évocateur mais je vais vous faire comprendre exactement ma question.
Au cours de mon cursus scolaire mes profs m'ont répété qu'en JAVA, TOUT est un pointeur. De ce fait, si je passe en argument d'une méthode un objet, qui est modifié dans celle-ci, il restera modifié par la suite.

(Si je me trompe dites-le moi car c'est un point crucial que je souhaite éclaircir et qui me bloque !!!)

De ce fait j'ai récolté une jolie NullPointerException (qu'est-ce qu'on l'aime beaucoup celle là bizarrement ) qui m'a fait cherché un peu plus sur internet et là, peu de réponse précises.

Soit le code suivant :

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
package testpointeur;
 
public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        int a = 3;
 
        test(a);
 
        System.out.println("a vaut " + a);
    }
 
    public static void test (int a) {
        a++; 
    }
}

A votre avis ? Que va afficher la console ?
Et bien elle va afficher 3 ! Bon... OK vous allez me dire, c'est un int c'est normal ! Et bien testez la même chose avec la classe Integer vous aurez le même résultat !

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
package testpointeur;
 
public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        Integer a =  new Integer(3);
 
        test(a);
 
        System.out.println("a vaut " + a);
    }
 
    public static void test (Integer a) {
        a++; 
    }
}

Bon par contre si maintenant on travaille avec un int[] cela donne :

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
package testpointeur;
 
public class Main {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        int [] a = new int[1];
 
        a[0] = 3;
 
        test(a);
 
        System.out.println("a vaut " + a[0]);
    }
 
    public static void test (int[] a) {
        a[0]++; 
    }
}

Qu'obtient-on ? Je vous le donne en mille : "a vaut 4"

Ce qui m'amène à ma question :
Quand est-ce qu'une variable / instance d'un objet est-elle considérée comme un pointeur ? Car là j'ai créé une classe héritant d'un JPanel que j'initialise à 'null' et qui va être instancié dans une méthode d'une autre classe... Problème c'est qu'après cette méthode j'ai toujours ma variable qui vaut 'null' et donc j'obtiens une belle exception de type NullPointer.

Quelqu'un saurait-il m'éclairer à ce sujet ?

Merci d'avance pour votre aide.

[bruno_nono]

Salut,

J'ai rencontré ce problème, il y a quelques jours.Tu peux consulter les réponses ici:
http://www.developpez.net/forums/d98...gument-entier/

En faite, pour te résumer :
int est un type primitif, et Integer est immuable => il faut donc renvoyer la valeur

tu peux donc faire a = test(a) et théoriquement cela devrait marcher.

int[] n'étant ni primitif ni immuable, cela incrémente bien la valeur de a !

J'espère ne pas dire de bêtises

[thelvin]

Ce qui m'amène à ma question : Quand une variable / instance d'un objet est-elle considérée comme un pointeur ?

Quand il s'agit bel et bien d'objet, et non pas d'un type primitif tel que int.

En résumé, non, en Java PAS TOUT n'est pointeur.
Toutes les variables de type objet en sont. Mais il y a aussi les types primitifs, et eux n'en sont jamais.

Accessoirement, on pourrait débattre que a++ n'est pas un opérateur de mutation mais d'affectation. Après tout c'est un raccourci pour :

Code :

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

a = a + 1;

Muter un objet change bien évidemment cet objet, mais affecter un nouvel objet à une variable, ne change ni l'ancien objet vers lequel la variable pointait, ni le nouvel objet vers lequel elle pointe à présent.

[Dark_TeToN]

Pour les types primitifs OK
Pour les types "Immuables" OK...

Cependant si j'ai une classe héritant d'un JPanel qui est un attribut privé déclaré comme suit :

Code :

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

1
2
 
private EcheancierPanel panel;

ou encore

Code :

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

1
2
 
private EcheancierPanel panel = null;

Et que je le passe en argument d'un constructeur d'un objet et que dans ce constructeur j'y écrit :

Code :

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

1
2
3
4
 
public Constructeur (EcheancierPanel panel) {
panel = new EcheancierPanel();
}

Une fois mon instance créée, est-ce que ma variable panel sera initialisée ?
Voilà ma réelle question ! Cependant merci pour la précision concernant les types primitifs et immuables ^^
C'est une information précieuse ! D'ailleurs String est-il immuable ?

[thelvin]

Une fois mon instance créée, est-ce que ma variable panel sera initialisée ?

Non. Aucun objet n'a été modifié par cette opération. Tu as juste fait qu'une variable, dont le scope ne dépasse pas ta méthode, pointe vers un nouvel objet. À la fin de son scope, l'objet vers lequel cette variable pointait n'est plus accessible.

[Eusebius]

Il n'y a pas de pointeurs en java, ce sont des références. Ce n'est pas qu'une question de vocabulaire : on ne peut pas manipuler directement la valeur d'une référence, donc on ne peut pas la faire pointer vers un espace mémoire arbitraire, et on ne peut pas faire d'arithmétique dessus.

[thelvin]

Il n'y a pas de pointeurs en java, ce sont des références. Ce n'est pas qu'une question de vocabulaire : on ne peut pas manipuler directement la valeur d'une référence, donc on ne peut pas la faire pointer vers un espace mémoire arbitraire, et on ne peut pas faire d'arithmétique dessus.

Parler de références n'est bon qu'à ajouter à la confusion. Dans la plupart des langages une référence sert justement à faire ce qui est décrit plus haut, chose que les pointeurs, eux, ne permettent pas sans une syntaxe additionnelle.

En réalité, en Java, les variables de type objet ne sont ni pointeur, ni référence, mais une sorte d'hybride.
Il faut simplement comprendre que les objets ne sont pas passés par copie. C'est la variable qui pointe vers eux, qui est passée par copie.

[Dark_TeToN]

Merci beaucoup ! Ce sont des principes de base que tout le monde devrait connaître ^^ Merci ! Je clôture !

[Ivelios]

Il faut simplement comprendre que les objets ne sont pas passés par copie. C'est la variable qui pointe vers eux, qui est passée par copie.

Pour compléter, quand tu passe une variable en paramètre d'une méthode
-> Soit une copie de la variable si c'est un type primitif.
-> Soit une copie de la référence pointant sur l'objet passé en paramètres. tu te retrouve avec 2 pointeurs sur le même objet. (l'un avec lequel tu appeler la méthodes et l'autre dans la méthode). Sachant que le deuxième serra "tué" à la fin de la méthode.