Module Java.8 – Programmation Orientée Objet

Objectif

Maîtriser la POO complète en Java : classes, constructeurs, encapsulation, héritage, interfaces, abstraction, polymorphisme pour créer des architectures modulaires et maintenables.

Théorie

Classes

Définition

public class Personne {
    // Propriétés (champs)
    private String nom;
    private int age;
    
    // Constructeur
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
    
    // Méthodes
    public String getNom() {
        return nom;
    }
    
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
    
    public void afficher() {
        System.out.println(nom + " a " + age + " ans");
    }
}

Création d'objets

Personne jean = new Personne("Jean", 30);
jean.afficher();

Constructeurs

Constructeur par défaut

Si aucun constructeur n'est défini, Java en crée un par défaut (sans paramètres).

public class Personne {
    private String nom;
    // Constructeur par défaut implicite
}

Personne p = new Personne();  // OK

Constructeurs multiples

public class Personne {
    private String nom;
    private int age;
    
    public Personne(String nom) {
        this.nom = nom;
        this.age = 0;
    }
    
    public Personne(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }
}

this

Référence à l'instance actuelle.

public Personne(String nom, int age) {
    this.nom = nom;      // this.nom = champ de l'instance
    this.age = age;      // nom = paramètre
}

Encapsulation

Cacher les détails d'implémentation et exposer seulement ce qui est nécessaire.

Visibilité

public class Personne {
    public String nom;        // Accessible partout
    private int age;          // Accessible seulement dans la classe
    protected String ville;   // Accessible dans classe et enfants
    String email;             // Package-private (même package)
}

Getters et Setters

public class Personne {
    private int age;
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 0 && age < 150) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("Age invalide");
        }
    }
}

Héritage

Une classe peut hériter d'une autre classe.

Syntaxe

class Etudiant extends Personne {
    private String ecole;
    
    public Etudiant(String nom, int age, String ecole) {
        super(nom, age);  // Appelle le constructeur parent
        this.ecole = ecole;
    }
    
    public String getEcole() {
        return ecole;
    }
}

super

Référence à la classe parente.

class Etudiant extends Personne {
    @Override
    public void afficher() {
        super.afficher();  // Appelle la méthode parente
        System.out.println("École : " + ecole);
    }
}

@Override

Annotation indiquant qu'on redéfinit une méthode parente.

@Override
public void afficher() {
    // Redéfinition
}

Interfaces

Contrat que les classes doivent respecter.

Définition

interface Affichable {
    void afficher();
    
    default void afficherInfo() {  // Méthode par défaut (Java 8+)
        System.out.println("Information");
    }
}

Implémentation

class Personne implements Affichable {
    @Override
    public void afficher() {
        System.out.println("Personne");
    }
}

Plusieurs interfaces

interface Affichable {
    void afficher();
}

interface Sauvegardable {
    void sauvegarder();
}

class Personne implements Affichable, Sauvegardable {
    public void afficher() {
        // Implémentation
    }
    
    public void sauvegarder() {
        // Implémentation
    }
}

Abstraction

Classes abstraites

Ne peut pas être instanciée, sert de base.

abstract class Animal {
    protected String nom;
    
    public Animal(String nom) {
        this.nom = nom;
    }
    
    // Méthode concrète
    public void dormir() {
        System.out.println(nom + " dort");
    }
    
    // Méthode abstraite (doit être implémentée)
    public abstract void faireDuBruit();
}

class Chien extends Animal {
    public Chien(String nom) {
        super(nom);
    }
    
    @Override
    public void faireDuBruit() {
        System.out.println("Wouf !");
    }
}

Interfaces vs Classes abstraites

Classe abstraite :

• Peut avoir des méthodes concrètes
• Peut avoir des champs
• Héritage simple seulement

Interface :

• Méthodes abstraites (avant Java 8)
• Pas de champs (sauf constantes)
• Implémentation multiple possible

Polymorphisme

Traiter différents types de manière uniforme.

Animal[] animaux = {
    new Chien("Rex"),
    new Chat("Mimi")
};

for (Animal animal : animaux) {
    animal.faireDuBruit();  // Polymorphisme
}

Liaison dynamique : La méthode appelée dépend du type réel de l'objet, pas du type de la variable.

Exercice

1. Classes

   • Créez des classes avec constructeurs
   • Testez l'encapsulation
   • Utilisez getters/setters

2. Héritage

   • Créez une hiérarchie de classes
   • Testez super et @Override
   • Comprenez le polymorphisme

3. Interfaces

   • Créez des interfaces
   • Implémentez-les dans des classes
   • Testez l'implémentation multiple

4. Abstraction

   • Créez des classes abstraites
   • Implémentez les méthodes abstraites
   • Comparez avec interfaces

5. Polymorphisme

   • Utilisez le polymorphisme
   • Testez la liaison dynamique
   • Créez des collections polymorphiques

Quiz

1. Que fait super() ?

   • Crée un super objet
   • Appelle le constructeur parent
   • Appelle une méthode parente

2. Quelle est la différence entre interface et classe abstraite ?

   • Aucune différence
   • Interface : implémentation multiple, classe abstraite : héritage simple
   • Classe abstraite est plus rapide

3. Que signifie @Override ?

   • Crée une nouvelle méthode
   • Redéfinit une méthode parente
   • Supprime la méthode parente

4. Qu'est-ce que le polymorphisme ?

   • Plusieurs formes d'un objet
   • Traiter différents types uniformément
   • Créer plusieurs objets

5. Que fait private ?

   • Rend la classe privée
   • Rend le champ/méthode accessible seulement dans la classe
   • Empêche l'héritage

Mini défi

Mission : Créer un système POO complet

Créez un système de gestion de bibliothèque :

Structure :

1. Interface Empruntable (emprunter, retourner, estDisponible)
2. Classe abstraite Document (titre, auteur)
3. Classe Livre (hérite Document, implémente Empruntable)
4. Classe DVD (hérite Document, implémente Empruntable)
5. Classe Bibliotheque (gère collection de Documents)

Critères :

• ✅ POO complète (héritage, interfaces, abstraction)
• ✅ Encapsulation appropriée
• ✅ Polymorphisme utilisé
• ✅ Code bien structuré

Objectif : Maîtriser la POO complète Java et créer une architecture propre.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez classes, héritage, interfaces, abstraction et polymorphisme.