Dans cette section, vous allez apprendre à déclarer et utiliser les attributs (variables d'instance) et les méthodes dans vos classes Java. Les attributs stockent les données de l'objet, tandis que les méthodes définissent son comportement. Vous découvrirez également la différence entre les méthodes d'instance et les méthodes statiques.

4.2Attributs et méthodes

4.2.1 – Déclaration et utilisation

Les attributs et les méthodes sont les deux composants principaux d'une classe. Les attributs (aussi appelés variables d'instance) stockent les données de chaque objet, tandis que les méthodes définissent le comportement et les actions que l'objet peut effectuer.

📦 Attributs (variables d'instance)

Les attributs sont des variables déclarées dans une classe. Chaque objet (instance) de la classe possède ses propres copies de ces attributs avec des valeurs indépendantes.

Exemple : Déclaration d'attributs

public class Personne {
    // Attributs (variables d'instance)
    String nom;      // Chaque objet a son propre nom
    int age;         // Chaque objet a son propre âge
    double taille;   // Chaque objet a sa propre taille
}

Exemple : Utilisation des attributs

// Créer deux objets différents
Personne personne1 = new Personne();
personne1.nom = "Jean";
personne1.age = 25;

Personne personne2 = new Personne();
personne2.nom = "Marie";
personne2.age = 30;

// Chaque objet a ses propres valeurs
System.out.println(personne1.nom);  // Affiche : Jean
System.out.println(personne2.nom);  // Affiche : Marie

⚙️ Méthodes

Les méthodes sont des fonctions qui définissent le comportement de l'objet. Elles peuvent utiliser les attributs de l'objet et effectuer des actions.

Exemple : Différents types de méthodes

public class Personne {
    String nom;
    int age;
    
    // Méthode sans paramètres et sans retour (void)
    public void sePresenter() {
        System.out.println("Je m'appelle " + nom + ", j'ai " + age + " ans.");
    }
    
    // Méthode avec paramètres
    public void changerAge(int nouvelAge) {
        age = nouvelAge;
    }
    
    // Méthode qui retourne une valeur
    public int getAge() {
        return age;
    }
    
    // Méthode avec paramètres et retour
    public String creerMessage(String prefixe) {
        return prefixe + " " + nom + " a " + age + " ans.";
    }
}

📝 Structure d'une méthode

Une méthode en Java suit cette structure :

[modificateur] typeRetour nomMethode([paramètres]) {
    // Corps de la méthode
    return valeur;  // Si la méthode retourne une valeur
}

Exemples :

// Méthode sans retour
public void afficher() {
    System.out.println("Hello");
}

// Méthode qui retourne un int
public int calculer() {
    return 10 + 5;
}

// Méthode avec paramètres
public void saluer(String nom) {
    System.out.println("Bonjour " + nom);
}

// Méthode avec plusieurs paramètres
public int additionner(int a, int b) {
    return a + b;
}

💡 Points clés

Attributs : Stockent les données de l'objet (une copie par objet)
Méthodes : Définissent le comportement et les actions
Paramètres : Les méthodes peuvent recevoir des données via des paramètres
Valeur de retour : Les méthodes peuvent retourner une valeur avec return
void : Indique qu'une méthode ne retourne rien

4.2.2 – Méthodes d'instance et statiques

Il existe deux types de méthodes en Java : les méthodes d'instance (appelées sur un objet) et les méthodes statiques (appelées sur la classe). La différence principale est que les méthodes d'instance ont accès aux attributs de l'objet, tandis que les méthodes statiques n'ont pas besoin d'objet pour être appelées.

🔹 Méthodes d'instance

Les méthodes d'instance sont appelées sur un objet spécifique. Elles ont accès aux attributs de cet objet et peuvent les modifier.

Exemple : Méthode d'instance

public class Personne {
    String nom;
    int age;
    
    // Méthode d'instance : appelée sur un objet
    public void sePresenter() {
        System.out.println("Je suis " + nom + ", j'ai " + age + " ans.");
        // Accède aux attributs de l'objet (nom et age)
    }
    
    public void vieillir() {
        age++;  // Modifie l'attribut de l'objet
    }
}

// Utilisation
Personne p1 = new Personne();
p1.nom = "Jean";
p1.age = 25;
p1.sePresenter();  // Appel sur l'objet p1
p1.vieillir();     // Modifie l'âge de p1

Personne p2 = new Personne();
p2.nom = "Marie";
p2.age = 30;
p2.sePresenter();  // Appel sur l'objet p2 (différent de p1)

🔹 Méthodes statiques

Les méthodes statiques appartiennent à la classe elle-même, pas à une instance. Elles sont appelées directement sur la classe et n'ont pas accès aux attributs d'instance (sauf s'ils sont aussi statiques).

Exemple : Méthode statique

public class Calculatrice {
    // Méthode statique : appelée sur la classe
    public static int additionner(int a, int b) {
        return a + b;
    }
    
    public static double calculerMoyenne(double[] nombres) {
        double somme = 0;
        for (double n : nombres) {
            somme += n;
        }
        return somme / nombres.length;
    }
}

// Utilisation : appel sur la classe, pas besoin de créer un objet
int resultat = Calculatrice.additionner(5, 3);
double moyenne = Calculatrice.calculerMoyenne(new double[]{10, 20, 30});

Important : Les méthodes statiques ne peuvent pas accéder aux attributs d'instance (non statiques) car elles n'ont pas de référence à un objet spécifique.

📊 Tableau de comparaison

Caractéristique	Méthode d'instance	Méthode statique
Mot-clé	Pas de static	static
Appel	objet.methode()	Classe.methode()
Nécessite un objet	Oui	Non
Accès aux attributs d'instance	✅ Oui	❌ Non
Accès aux attributs statiques	✅ Oui	✅ Oui
Utilisation de this	✅ Oui	❌ Non
Cas d'usage	Comportement spécifique à un objet	Fonctions utilitaires, calculs

💡 Points clés à retenir

Méthode d'instance : Appelée sur un objet, a accès aux attributs de l'objet
Méthode statique : Appelée sur la classe, pas besoin d'objet
static : Mot-clé qui indique qu'une méthode appartient à la classe
this : Utilisable uniquement dans les méthodes d'instance
Choix : Utilisez des méthodes d'instance pour le comportement de l'objet, statiques pour les fonctions utilitaires