Discussion :

[grospatapouf]

bonjour à tous,
Je suis débutant en java et je ne comprends pas très bien les différentes utilisations du mot clé "this". Je sais qu'il sert à désigner l'objet courant mais cela reste vague pour moi. Est-ce que quelqu'un pourrait m'expliquer avec des exemples concrets s'il vous plaît? Voici quelques exemples de l'occurrence de "this" que j'ai piqués dans le livre "thinking in java". Je lis et relis le passage mais j'arrive toujours pas à comprendre.

1.

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
public class Leaf {
   static Test monitor = new Test();
   int i = 0;
   Leaf increment() {
   i++;
  return this;
  }

  void print() {
  System.out.println("i = " + i);
  }

  public static void main(String[] args) {
  Leaf x = new Leaf();
  x.increment().increment().increment().print();
  monitor.expect(new String[] {
 "i = 3"
 });
 }
 }

2.

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
public class Flower {
static Test monitor = new Test();
int petalCount = 0;
String s = new String("null");

Flower(int petals) {
petalCount = petals;
System.out.println(
"Constructor w/ int arg only, petalCount= "
+ petalCount);
}

Flower(String ss) {
System.out.println(
"Constructor w/ String arg only, s=" + ss);
s = ss;
}

Flower(String s, int petals) {
this(petals);
//! this(s); // Can't call two!
this.s = s; // Another use of "this"
System.out.println("String & int args");
}

Flower() {
this("hi", 47);
System.out.println("default constructor (no args)");
}

3. un autre exemple

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class Account
{
   
    private long deposit=0;
    public void despsit_sum(long sum)
    {
       synchronized (this){ 
            deposit+= sum;
   
         }
    }

Merci d'avance et bonnes vacances!

[darkxan]

C'est difficile de dire plus.

Dans le premier cas, la méthode retourne l'objet courant qui est bien de type Leaf.

Dans le deuxième cas : this(petals), il se sert de this pour accéder au constructeur avec un entier en argument : Flower(int petals).
Ensuite, lorsqu'il fait this.s, il accède au membre de l'objet. Dans ce cas, il est obligatoire de l'utiliser car le paramètre s'appelle s et le membre de la classe s'appelle s. Il faut donc un moyen pour différencier les deux.
C'est une bonne pratique d'utiliser pour justement marquer le fait que l'on accède à un membre de la classe, une méthode, etc...
Enfin, le troisième est le même exemple que le premier cas, c'est à dire il fait un appel au constructeur avec deux arguments.

Dans le troisième cas, il sert là aussi de l'instance courante de la classe pour effectuer une synchronisation. Tous les objets, travaillant avec cette instance de cette classe seront donc concerné par cette synchronisation.

[Soutou]

ça m'étonne pas que tu ai du mal à comprendre, ces exemples ne sont pas top. Pourquoi ne pas travailler avec des livres écrits par des Français?

Bon, this désigne l'objet courant (self en C++). Dans l'exemple suivant, tu défini un Avion que tu peux créer de 2 façons, en passant 3 paramètres ou en passant 2. Dans le second constructeur this.immat désigne la variable de classe de l'avion créé pour ne pas la confondre avec le paramètre de même nom (qui vaudrait A1 dans la création suivante).

AvionTest av = new AvionTest ("A1", 120);

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
 
public class AvionTest extends Object
	{String immat;
	 int capacite; 
	 String typeAvion;
 
	public AvionTest (String p1, int p2, String p3)
	{immat=p1;
	capacite=p2; 
	typeAvion=p3;
	}
	public void affiche()
{System.out.println("immat : "+immat+" capacite : "+capacite+" type : "+typeAvion);	}
// Autre constructeur
	public AvionTest (String immat, String p2)
	{this.immat= immat;
	capacite  = 100; 
	typeAvion = p2;
	}		
}

Supposons ensuite que tu écrives d'autres méthode pour cette classe, par exemple changeImmat qui change l'immatriculation. Si tu désire afficher les variable de l'avion modifié, tu coderais this.affiche(); dans ta changeImmat.

[tchize_]

Pour résumé, c'est pas si difficile:


this(xxxxx) : appele le constructeur avec le paramètre xxxxx. Cet appel n'est valide *que* si c'est la prmière ligne d'un constructeur

this.x : référence le champ x de l'objet courant (set à différentier des variables locales qui porteraient le même nom au sein d'une méthode)

this.x() : référence la méthode x de l'objet courant

this; référence l'objet courant (souvent utilisé dans les appel return)


Pour info, tu peux aussi faire super(xxxxx), et super.x(), c'est la même règle sauf qu'on référence le parent


Aussi, chose un peu plus avancée:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class A {
   // .....
   public class B {
       public A getOwner(){
           return A.this;
       }
       // .....
   }
}

Explication: Quand tu es dans la méthode getOwner(), tu as plusieurs objets courant: B mais aussi A (car B est une inner class de A). Par défaut, this retourne B, mais il est possible de référence la class A courant via A.this

[welcome_59]

Essaie d'imaginer this comme le "moi", la manière de désigner la personne propre d'un objet Java.
De la même manière que tu dis moi, je, mon, etc. pour une personne, tu diras this pour un objet Java.
C'est peu être peu subtil de l'expliquer comme cela, mais ça me semble une bonne tentative d'analogie pour comprendre.

[infoelectronique]

Le mot-clé this est utile lorsque tu as besoin de te référer à l'instance
de l'objet dans laquelle tu te trouves. Regarde cet exemple

Code :

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

1
2
3
4
5
6
class Poisson {
int profondeurCourante ;
Poisson(int profondeurCourante) {
this.profondeurCourante = profondeurCourante;
}
}

Le mot-clé this permet d'éviter
les conflits de nom. Par exemple,
this.profondeurCourante fait
référence à la variable membre
profondeurCourante, alors que
profondeurCourante fait
référence à la valeur de
l'argument.
En d'autres termes, l'instance de
l'objet Poisson pointe sur elle même.

[grospatapouf]

bonjours à tous,
Merci de vos réponse, ça m'a beaucoup aidé même si c'est pas encore clair comme de l'eau de roche. Sinon Soutou parlait de bouquins écrits par des Français. Vous pouvez me donnez des liens la dessus SVP? J'ai le bouquin de delannoy "Programmer en java" mais il ne donne pas assez d'explications sur la question. Sinon, j'ai lu aussi "Java tete la premiere" et également "Java pour les enfants, parents et grand-parents" et plein d'autres en anglais mais peu de résultat.
Merci encore de vos messages.