• Pile (Stack) : stocke les variables locales et les valeurs primitives (ex. int, boolean) durant l’exécution d’une méthode.
• Tas (Heap) : alloue dynamiquement la mémoire pour les instances d’objets et les tableaux ; géré automatiquement par le ramasse-miettes.
• Zone des méthodes (Method Area) : contient les métadonnées de classe, les constantes (dont le pool de constantes), les informations sur les champs et les méthodes.

2. Cycle de vie d’un objet Java

1. Le bytecode de la classe est chargé une seule fois via le class loader.
2. Un espace mémoire est réservé dans le tas, avec initialisation par défaut (0, false, null, etc.).
3. L’adresse mémoire de l’objet est affectée à une référence locale (ex. Cat myCat).
4. Le constructeur s’exécute, appliquant l’initialisation explicite définie par le développeur.

3. Modélisation d’animaux avec la POO

Imaginons deux instances de chat : « Nivéa » (3 ans, blanc, 10 kg) et « Soleil » (2 ans, jaune, 15 kg). Voici une implémentation robuste :

public class AnimalDemo {
    public static void main(String[] args) {
        // Instanciation avec initialisation directe
        Feline nivea = new Feline("Nivéa", 3, "blanc", 10.0);
        Feline soleil = new Feline("Soleil", 2, "jaune", 15.0);

        // Affichage structuré
        System.out.printf("Chat 1 → Nom: %s, Âge: %d, Couleur: %s, Poids: %.1f kg%n",
            nivea.getNom(), nivea.getAge(), nivea.getCouleur(), nivea.getPoids());
        System.out.printf("Chat 2 → Nom: %s, Âge: %d, Couleur: %s, Poids: %.1f kg%n",
            soleil.getNom(), soleil.getAge(), soleil.getCouleur(), soleil.getPoids());
    }
}

class Feline {
    private String nom;
    private int age;
    private String couleur;
    private double poids;

    // Constructeur paramétré
    public Feline(String nom, int age, String couleur, double poids) {
        this.nom = nom;
        this.age = age;
        this.couleur = couleur;
        this.poids = poids;
    }

    // Accesseurs (getters)
    public String getNom() { return nom; }
    public int getAge() { return age; }
    public String getCouleur() { return couleur; }
    public double getPoids() { return poids; }
}

4. Déclaration et signature des méthodes

Une méthode suit cette structure :

modificateurAccès typeRetour identifiant(paramètres) {
    // corps de la méthode
    return valeur; // si typeRetour ≠ void
}

5. Mécanisme d’appel de méthode

Lorsqu’une méthode est invoquée, un nouveau cadre de pile est créé. Les paramètres sont copiés, puis le flux exécute le corps. À la fin, le cadre est détruit et le contrôle revient à l’appelant.

6. Règles relatives au type de retour

• Une méthode ne peut renvoyer qu’une seule valeur (même si celle-ci est un tableau ou un objet complexe).
• Le type de retour doit être compatible avec le type spécifié — y compris les conversions implicites (ex. int → long).
• Pour un type void, return; est optionnel, mais autorisé comme instruction de sortie anticipée.

7. Appel entre classes

Pour accéder à une méthode d’une autre classe, instanciez-la localement ou passez une référence valide :

class ModulePrincipal {
    void lancer() {
        System.out.println("Démarrage du module...");
        ServiceUtilitaire service = new ServiceUtilitaire();
        service.executerTache();
    }
}

class ServiceUtilitaire {
    void executerTache() {
        System.out.println("Tâche exécutée depuis ServiceUtilitaire");
    }
}

8. Passage de paramètres

• Types primitifs : copie de la valeur → aucune modification visible à l’extérieur.
• Types référence : copie de la référence (adresse) → modificatinos sur l’objet partagé sont visibles.

9. Surcharge de méthodes (Overloading)

Plusieurs méthodes portant le même nom peuvent coexister dans une même classe si leurs signatures diffèrent :

• Nom identique.
• Liste de paramètres différente (type, nombre ou ordre).
• Le type de retour n’affecte pas la surcharge.

10. Paramètres variables (varargs)

Syntaxe : type... nom. Exemple :

void afficherNombres(int... valeurs) {
    for (int v : valeurs) System.out.print(v + " ");
}
// Appels valides : afficherNombres(), afficherNombres(1), afficherNombres(1,2,3)

Contraintes : varargs doit être le dernier paramètre ; une méthode ne peut en contenir qu’un seul.

11. Portée des variables

• Champ (attribut d’instance) : accessible dans toute la classe (et éventuellement hors classe selon modificateur d’accès).
• Variable locale : limitée au bloc où elle est déclarée (méthode, boucle, condition), sans modificateur d’accès autorisé.

12. Constructeurs

Méthodes spéciales appelées automatiquement lors de la création d’un objet. Caractéristiques clés :

• Nom identique à celui de la classe.
• Aucun type de retour (pas même void).
• Si aucun constructeur n’est défini, le compilateur fournit un constructeur par défaut sans paramètre.
• Définir un constructeur annule ce constructeur par défaut implicite.

13. Mot-clé this

Il désigne l’instance courante dans une méthode ou un constructeur :

• Résout les conflits entre paramètres et champs (this.nom = nom).
• Permet d’appeler un autre constructeur de la même classe avec this(...), uniquement en première instruction.
• Ne peut être utilisé que dans le corps d’une méthode ou d’un constructeur — jamais en dehors d’une classe.