4.4.1 – Méthode toString()

La méthode toString() est une méthode spéciale héritée de la classe Object (la classe mère de toutes les classes en Java). Elle permet de représenter un objet sous forme de chaîne de caractères. Cette méthode est automatiquement appelée dans plusieurs situations, notamment lors de l'affichage d'un objet. Redéfinir toString() est une bonne pratique qui améliore considérablement la lisibilité et le débogage de votre code.

🔍 Comportement par défaut

Si vous ne redéfinissez pas toString(), Java utilise la version héritée de Object, qui retourne une chaîne peu informative composée du nom de la classe, du symbole @ et du code de hachage hexadécimal de l'objet (adresse mémoire).

Exemple : Sans redéfinition de toString()

public class Personne {
    String nom;
    int age;
    String ville;
}

// Utilisation
Personne p = new Personne();
p.nom = "Jean";
p.age = 25;
p.ville = "Paris";

System.out.println(p);  
// Affiche : Personne@15db9742 (peu utile !)
// Format : NomClasse@codeHashHexadécimal

📝 Redéfinir toString()

Pour avoir une représentation claire et utile de vos objets, vous devez redéfinir la méthode toString() dans votre classe. Utilisez l'annotation @Override pour indiquer que vous redéfinissez une méthode héritée. Cette annotation aide le compilateur à détecter les erreurs si vous faites une faute de frappe dans le nom de la méthode.

Structure de base

La signature de la méthode doit être exactement :

@Override
public String toString() {
    // Retourner une String représentant l'objet
    return "...";
}

Exemple : Redéfinition de toString()

public class Personne {
    String nom;
    int age;
    String ville;
    
    @Override
    public String toString() {
        return "Personne{nom='" + nom + "', age=" + age + ", ville='" + ville + "'}";
    }
}

// Utilisation
Personne p = new Personne();
p.nom = "Jean";
p.age = 25;
p.ville = "Paris";

System.out.println(p);  
// Affiche : Personne{nom='Jean', age=25, ville='Paris'}
// Beaucoup plus informatif que Personne@15db9742 !

🎨 Formats de toString()

Vous pouvez formater votre toString() de différentes manières selon vos besoins. Le choix du format dépend du contexte d'utilisation : débogage, logs, affichage utilisateur, etc. Voici plusieurs styles courants :

Format 1 : Style simple et concis

Idéal pour un affichage rapide et lisible :

public class Personne {
    String nom;
    int age;
    
    @Override
    public String toString() {
        return nom + " (" + age + " ans)";
    }
}

// Utilisation
Personne p = new Personne();
p.nom = "Jean";
p.age = 25;
System.out.println(p);  
// Affiche : Jean (25 ans)

Format 2 : Style avec accolades (style JSON)

Très courant en Java, ressemble à du JSON. Idéal pour le débogage :

public class Personne {
    String nom;
    int age;
    String ville;
    
    @Override
    public String toString() {
        return "Personne{nom='" + nom + "', age=" + age + ", ville='" + ville + "'}";
    }
}

// Utilisation
Personne p = new Personne();
p.nom = "Jean";
p.age = 25;
p.ville = "Paris";
System.out.println(p);  
// Affiche : Personne{nom='Jean', age=25, ville='Paris'}

Format 3 : Style multi-lignes

Utile pour des objets complexes avec beaucoup d'attributs :

public class Personne {
    String nom;
    int age;
    String ville;
    String email;
    
    @Override
    public String toString() {
        return "Personne:\n" +
               "  Nom: " + nom + "\n" +
               "  Âge: " + age + " ans\n" +
               "  Ville: " + ville + "\n" +
               "  Email: " + email;
    }
}

// Utilisation
Personne p = new Personne();
p.nom = "Jean";
p.age = 25;
p.ville = "Paris";
p.email = "jean@example.com";
System.out.println(p);  
// Affiche :
// Personne:
//   Nom: Jean
//   Âge: 25 ans
//   Ville: Paris
//   Email: jean@example.com

Format 4 : Style avec StringBuilder (pour performances)

Pour les objets avec beaucoup d'attributs, utiliser StringBuilder est plus efficace :

public class Personne {
    String nom;
    int age;
    String ville;
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Personne{");
        sb.append("nom='").append(nom).append('\'');
        sb.append(", age=").append(age);
        sb.append(", ville='").append(ville).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

🔄 Quand toString() est appelée automatiquement

La méthode toString() est appelée automatiquement dans plusieurs situations. Java convertit implicitement l'objet en String en appelant toString(). Voici les principales situations :

1. Avec System.out.println() et System.out.print()

Personne p = new Personne();
p.nom = "Jean";
p.age = 25;

System.out.println(p);  // Appelle toString() automatiquement
// Équivalent à : System.out.println(p.toString());

2. Avec la concaténation de chaînes

Personne p = new Personne();
p.nom = "Jean";

String message = "Personne : " + p;  
// Appelle toString() automatiquement sur p
// Équivalent à : "Personne : " + p.toString()
System.out.println(message);  // Affiche : Personne : Personne{nom='Jean', ...}

3. Avec String.format() et printf

Personne p = new Personne();
p.nom = "Jean";

System.out.printf("Info : %s%n", p);  
// Appelle toString() automatiquement pour le %s
String.format("Personne : %s", p);  
// Appelle aussi toString() automatiquement

4. Dans les collections (List, Set, Map, etc.)

List<Personne> personnes = new ArrayList<>();
Personne p1 = new Personne();
p1.nom = "Jean";
Personne p2 = new Personne();
p2.nom = "Marie";

personnes.add(p1);
personnes.add(p2);

System.out.println(personnes);  
// Appelle toString() pour chaque élément de la liste
// Affiche : [Personne{nom='Jean', ...}, Personne{nom='Marie', ...}]

5. Dans les expressions de débogage

Personne p = new Personne();
p.nom = "Jean";

// Dans les logs
System.out.println("État de l'objet : " + p);  
// Appelle toString() automatiquement

// Dans les assertions (si activées)
assert p != null : "L'objet est null : " + p;  
// Appelle toString() si l'assertion échoue

💡 Avantages de toString()

Redéfinir toString() apporte de nombreux avantages à votre code :

• Débogage facilité : Vous pouvez rapidement voir l'état d'un objet en l'affichant, sans avoir à inspecter chaque attribut individuellement
• Lisibilité améliorée : Les logs et messages d'erreur deviennent beaucoup plus compréhensibles
• Développement plus rapide : Pas besoin d'écrire des méthodes d'affichage personnalisées pour chaque classe
• Collections : L'affichage des listes, sets et maps devient automatiquement lisible
• Documentation informelle : La méthode toString() sert de documentation sur la structure et les attributs importants de la classe
• Tests unitaires : Facilite la comparaison et l'affichage des objets dans les tests

📊 Exemple complet : Classe Voiture avec toString()

Voici un exemple complet d'une classe avec une méthode toString() bien implémentée :

public class Voiture {
    private String marque;
    private String modele;
    private int annee;
    private double prix;
    private boolean estDisponible;
    
    public Voiture(String marque, String modele, int annee, double prix) {
        this.marque = marque;
        this.modele = modele;
        this.annee = annee;
        this.prix = prix;
        this.estDisponible = true;
    }
    
    // Getters
    public String getMarque() { return marque; }
    public String getModele() { return modele; }
    public int getAnnee() { return annee; }
    public double getPrix() { return prix; }
    public boolean isEstDisponible() { return estDisponible; }
    
    // Méthode toString() redéfinie
    @Override
    public String toString() {
        return "Voiture{" +
               "marque='" + marque + '\'' +
               ", modele='" + modele + '\'' +
               ", annee=" + annee +
               ", prix=" + prix + " €" +
               ", estDisponible=" + estDisponible +
               '}';
    }
}

// Utilisation
public class Garage {
    public static void main(String[] args) {
        Voiture v1 = new Voiture("Peugeot", "208", 2023, 25000.0);
        Voiture v2 = new Voiture("Renault", "Clio", 2022, 22000.0);
        
        // Affichage automatique avec toString()
        System.out.println("Voiture 1 : " + v1);
        // Affiche : Voiture 1 : Voiture{marque='Peugeot', modele='208', annee=2023, prix=25000.0 €, estDisponible=true}
        
        System.out.println("Voiture 2 : " + v2);
        // Affiche : Voiture 2 : Voiture{marque='Renault', modele='Clio', annee=2022, prix=22000.0 €, estDisponible=true}
        
        // Dans une liste
        List<Voiture> voitures = new ArrayList<>();
        voitures.add(v1);
        voitures.add(v2);
        System.out.println("Liste des voitures : " + voitures);
        // Affiche : Liste des voitures : [Voiture{marque='Peugeot', ...}, Voiture{marque='Renault', ...}]
    }
}

❌ Erreurs communes à éviter

Erreur 1 : Oublier de retourner une String

// ❌ INCORRECT - Erreur de compilation
@Override
public String toString() {
    System.out.println("Personne : " + nom);  // Ne retourne rien !
}

// ✅ CORRECT
@Override
public String toString() {
    return "Personne{nom='" + nom + "'}";
}

Erreur 2 : Inclure des informations sensibles

// ❌ DANGEREUX - Ne jamais faire ça !
@Override
public String toString() {
    return "Utilisateur{nom='" + nom + "', motDePasse='" + motDePasse + "'}";
    // Le mot de passe pourrait être affiché dans les logs !
}

// ✅ CORRECT - Exclure les informations sensibles
@Override
public String toString() {
    return "Utilisateur{nom='" + nom + "', email='" + email + "'}";
}

Erreur 3 : Opérations coûteuses dans toString()

// ❌ MAUVAIS - Opération coûteuse
@Override
public String toString() {
    // Ne faites pas d'appels réseau, de calculs complexes, etc.
    String resultat = appelerAPIExterne();  // Très lent !
    return "Personne{resultat='" + resultat + "'}";
}

// ✅ CORRECT - Simple et rapide
@Override
public String toString() {
    return "Personne{nom='" + nom + "', age=" + age + "}";
}

💡 Points clés à retenir

• Héritage : toString() est héritée de Object, toutes les classes l'ont
• Redéfinition : Utilisez @Override pour redéfinir la méthode (bonne pratique)
• Signature : public String toString() - pas de paramètres, retourne String
• Appel automatique : Appelée automatiquement par System.out.println(), concaténation, formatage, collections
• Format : Choisissez un format clair et cohérent (style JSON recommandé)
• Utilité : Essentielle pour le débogage, les logs et l'affichage
• Sécurité : N'incluez jamais d'informations sensibles
• Performance : Gardez la méthode simple et rapide