Aller au contenu principal

Le mot-clé this

Notions théoriques​

this : référence à l'objet courant​

Le mot-clé this est une référence vers l'objet sur lequel la méthode (ou le constructeur) est en train de s'exécuter. Il permet de désambiguïser entre un attribut de la classe et un paramètre portant le même nom.

public class Personnage {
    String nom;
    int force;

    public Personnage(String nom, int force) {
        this.nom = nom;     // this.nom = attribut, nom = paramètre
        this.force = force; // this.force = attribut, force = paramètre
    }
}

Sans this, Java ne pourrait pas distinguer nom (le paramètre) de nom (l'attribut). L'attribut ne serait jamais initialisé.

this vs $this en PHP​

Si vous connaissez PHP, voici la correspondance :

PHPJava
$this->nomthis.nom
$this->attaquer()this.attaquer()

En Java, this s'utilise sans $ et avec un point (.) plutôt qu'une flèche (->).

Passer this en paramètre​

On peut passer this en paramètre d'une méthode pour transmettre une référence à l'objet courant :

public class Personnage {
    String nom;

    void rejoindreEquipe(Equipe equipe) {
        equipe.ajouterMembre(this);  // on passe l'objet courant à l'équipe
    }
}

Chaîner les appels avec return this​

Une technique avancée consiste à retourner this depuis une méthode pour permettre l'enchaînement des appels (method chaining) :

public class Personnage {
    String nom;
    int force;
    int defense;

    public Personnage setNom(String nom) {
        this.nom = nom;
        return this;  // retourne l'objet courant
    }

    public Personnage setForce(int force) {
        this.force = force;
        return this;
    }

    public Personnage setDefense(int defense) {
        this.defense = defense;
        return this;
    }
}

// Usage : enchaînement fluide
Personnage p = new Personnage()
    .setNom("Aria")
    .setForce(18)
    .setDefense(10);

this(...) pour chaîner les constructeurs​

Comme vu dans la séance précédente, this(...) permet d'appeler un autre constructeur de la même classe. C'est aussi un usage du mot-clé this.

public Personnage() {
    this("Inconnu", 10, 5, 100);  // appelle le constructeur complet
}

Exemple pratique​

// Fichier : Personnage.java
public class Personnage {
    String nom;
    int force;
    int defense;
    int pointsDeVie;

    public Personnage(String nom, int force, int defense, int pointsDeVie) {
        this.nom = nom;
        this.force = force;
        this.defense = defense;
        this.pointsDeVie = pointsDeVie;
    }

    // Retourne this pour permettre l'enchaînement
    public Personnage augmenterForce(int bonus) {
        this.force += bonus;
        return this;
    }

    public Personnage soigner(int points) {
        this.pointsDeVie += points;
        return this;
    }

    void combattre(Personnage adversaire) {
        System.out.println(this.nom + " affronte " + adversaire.nom + " !");
        int degats = Math.max(0, this.force - adversaire.defense);
        adversaire.pointsDeVie -= degats;
        System.out.println(adversaire.nom + " perd " + degats + " PV.");
    }

    void afficher() {
        System.out.println(nom + " : Force=" + force + ", Def=" + defense + ", PV=" + pointsDeVie);
    }
}

// Fichier : Main.java
public class Main {
    public static void main(String[] args) {
        Personnage guerrier = new Personnage("Aria", 15, 8, 100);

        // Enchaînement d'appels grâce à return this
        guerrier.augmenterForce(5).soigner(20);

        Personnage ennemi = new Personnage("Golem", 12, 6, 80);

        guerrier.afficher();
        ennemi.afficher();

        guerrier.combattre(ennemi);
        ennemi.afficher();
    }
}

Test de mémorisation/compréhension​


Que représente `this` dans une méthode Java ?


Pourquoi utilise-t-on `this.nom = nom` dans un constructeur ?


Que retourne une méthode qui contient `return this;` ?


Quel est l'équivalent de `this.nom` en PHP ?


À quoi sert `this(nom, 10, 5, 100)` dans un constructeur ?


TP pour réfléchir et résoudre des problèmes​

Vous allez modifier la classe Personnage pour utiliser this correctement et implémenter une méthode de combat utilisant l'objet courant.

Étape 1 — Corriger le constructeur avec this​

Dans le constructeur, utilisez this.attribut = parametre pour bien distinguer les attributs des paramètres.


Bonne pratique - this systématique dans les constructeurs

Même si le compilateur peut parfois s'en sortir sans this, prenez l'habitude de toujours écrire this.attribut = parametre dans les constructeurs. Cela évite les bugs subtils et rend le code plus lisible.

Étape 2 — Méthode combattre() avec this​

Implémentez la méthode combattre(Personnage adversaire) qui utilise this.nom et this.force pour décrire le combat.


Bonne pratique - this optionnel dans les méthodes

Dans les méthodes (contrairement aux constructeurs), this.nom et nom sont équivalents s'il n'y a pas de paramètre avec le même nom. Utiliser this dans les méthodes est une question de style : certains l'écrivent systématiquement pour plus de clarté, d'autres l'omettent. L'important est d'être cohérent dans un même projet.

Étape 3 — Enchaînement d'appels avec return this​

Ajoutez une méthode soigner(int points) qui retourne this pour permettre l'enchaînement, puis enchaînez les appels dans Main.


Bonne pratique - Method chaining avec parcimonie

Le retour de this pour enchaîner les appels est pratique, mais à utiliser avec modération. Trop d'enchaînements sur une seule ligne peuvent rendre le code difficile à déboguer (quelle méthode a provoqué l'erreur ?). Préférez le method chaining pour les configurations simples et peu nombreuses.

📌 Une solution