La programmation orientée objet (POO) est un paradigme fondamental en Java. Ce guide explore ses concepts clés.

1. Classes et Objets

1.1 Définition et utilisation d'une classe

Une classe est un modèle qui définit les propriétés (attributs) et les comportements (méthodes) d'un type d'objet. Un objet est une instance concrète de cette classe.

// Définition de la classe
public class Vehicule {
    String marque;
    int vitesseMax;

    public void demarrer() {
        System.out.println("Le véhicule démarre.");
    }
}

// Création d'une instance (objet) et utilisation
Vehicule maVoiture = new Vehicule();
maVoiture.marque = "Renault";
maVoiture.demarrer();

1.2 Le constructeur

Un constructeur est une méthode spéciale, portant le nom de la classe, appelée automatiquement lors de la création d'un objet. Son rôle est d'initialiser l'état de l'objet.

public class Livre {
    String titre;
    String auteur;

    // Constructeur par défaut (sans paramètres)
    public Livre() {
        this.titre = "Inconnu";
        this.auteur = "Anonyme";
    }

    // Constructeur avec paramètres (surcharge)
    public Livre(String titre, String auteur) {
        this.titre = titre;
        this.auteur = auteur;
    }
}

Livre livre1 = new Livre(); // Utilise le constructeur par défaut
Livre livre2 = new Livre("Le Petit Prince", "Saint-Exupéry");

Points importants : Un constructeur peut être surchargé. Si vous définissez un constructeur avec paramètres, le compilateur ne génère plus automatiquement le constructeur par défaut. Vous devez alors le définir explicitement si nécessaire.

1.3 Mémoire et références

L'opérateur new alloue de la mémoire sur le tas (heap) pour l'objet et retourne une référence vers cet objet. La variable d'objet (ex: maVoiture) stocke cette référence, pas l'objet lui-même.

2. Les Trois Piliers de la POO

2.1 Encaspulation

Principe consistant à cacher les détails internes d'un objet et à n'exposer qu'une interfaec publique contrôlée pour interagir avec ses données. On utilise les modificateurs d'accès (private, protected, public).

public class CompteBancaire {
    // Attributs privés (encapsulés)
    private double solde;
    private String proprietaire;

    // Accesseur (getter)
    public double getSolde() {
        return solde;
    }

    // Mutateur (setter) avec validation
    public void effectuerDepot(double montant) {
        if (montant > 0) {
            this.solde += montant;
        }
    }
}

2.2 Héritage

Permet à une classe enfant de réutiliser les attributs et méthodes d'une classe parente, favorisant la réutilisabilité du code. Utilise le mot-clé extends.

public class Animal {
    public void manger() {
        System.out.println("L'animal mange.");
    }
}

public class Chien extends Animal {
    // Hérite de la méthode manger()
    public void aboyer() {
        System.out.println("Le chien aboie.");
    }
}

Chien rex = new Chien();
rex.manger(); // Méthode héritée
rex.aboyer();  // Méthode spécifique

Redéfinition de méthode : Une classe enfant peut redéfinir (override) une méthode de son parent pour changer son comportement.

2.3 Polymorphisme

Capacité d'un objet à prendre plusieurs formes. En pratique, une référence d'un type parent peut pointer vers un objet d'un type enfant. L'appel de méthode redéfinitie se fait de manière dynamique au moment de l'exécution.

Animal monAnimal = new Chien(); // Polymorphisme
monAnimal.manger(); // Appelle la version de Animal ou de Chien si redéfinie
// monAnimal.aboyer(); // Erreur de compilation, la référence est de type Animal

// Vérification de type avec instanceof
if (monAnimal instanceof Chien) {
    ((Chien) monAnimal).aboyer(); // Cast vers Chien
}

3. Les Exceptions

Les exceptions sont des événements qui perturbent le flux normal d'exécution d'un programme. Java fournit un mécanisme robuste pour les gérer.

3.1 Hiérarchie des exceptions

Toutes les exceptions héritent de Throwable. Les deux branches principales sont Error (erreurs système graves, ingérables) et Exception (exceptions applicatives).

3.2 Mécanisme de gestion

On utilise les blocs try, catch, finally et les mots-clés throw, throws.

import java.io.*;

public class LectureFichier {
    public static void main(String[] args) {
        BufferedReader lecteur = null;
        try {
            lecteur = new BufferedReader(new FileReader("donnees.txt"));
            String ligne = lecteur.readLine();
            System.out.println(ligne);
        } catch (FileNotFoundException e) {
            System.err.println("Fichier non trouvé: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("Erreur d'E/S: " + e.getMessage());
        } finally {
            // Nettoyage des ressources
            if (lecteur != null) {
                try {
                    lecteur.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Exception personnalisée : On peut créer ses propres exceptions en étendant la classe Exception.

// Définition d'une exception personnalisée
public class AgeInvalideException extends Exception {
    public AgeInvalideException(String message) {
        super(message);
    }
}

// Utilisation dans une méthode
public void setAge(int age) throws AgeInvalideException {
    if (age < 0) {
        throw new AgeInvalideException("L'âge ne peut pas être négatif.");
    }
    this.age = age;
}