Exercices Fondamentaux (Classes, Objets, Héritage, Polymorphisme)
1. Classe Simple
Créez une classe `Personne` avec `nom`, `âge` et une méthode `sePresenter()` qui affiche
"Je m'appelle [nom] et j'ai [âge] ans."
2. Constructeurs et Surcharge
Dans la classe `Voiture`, définissez plusieurs constructeurs (un par défaut, un avec
`marque`, un avec `marque` et `année`).
3. Encapsulation (Getters/Setters)
Créez une classe `CompteBancaire` avec un attribut privé `solde`. Ajoutez des méthodes
pour déposer/retirer de l’argent avec validation.
4. Héritage Simple
Une classe `Animal` (avec `nom` et `son`) et deux sous-classes `Chien` et `Chat` qui
redéfinissent le `son`.
5. Polymorphisme
Utilisez un tableau d’`Animal` contenant des `Chien` et `Chat`, puis appelez leur méthode
`emettreSon()`.
6. Classe Abstraite
Une classe abstraite `Forme` avec une méthode abstraite `calculerAire()`. Implémentez-la
dans `Cercle` et `Rectangle`.
7. Interface
Créez une interface `Volant` avec une méthode `voler()`, puis implémentez-la dans `Avion`
et `Oiseau`.
### Exercices Intermédiaires (Composition, Exceptions, Collections, Design Patterns)
8. Composition
Une classe `Moteur` et une classe `Voiture` où une `Voiture` "a un" `Moteur`.
9. Exceptions Personnalisées
Une classe `Calculatrice` avec une méthode `diviser()` qui lève une exception
`DivisionParZeroException`.
10. Collections + POO
Une classe `Bibliotheque` qui gère une liste de `Livre` (ajout, suppression, recherche par
titre).
11. Singleton
Implémentez une classe `Configuration` avec une seule instance possible (pour stocker des
paramètres globaux).
12. Fabrique (Factory)
Une classe `AnimalFactory` qui crée des instances de `Chien` ou `Chat` selon un
paramètre.
13. Méthode Statique
Ajoutez une méthode statique `compterAnimaux()` dans la classe `Animal` pour suivre le
nombre total d’animaux créés.
14. Classe Immutable
Créez une classe `Adresse` immuable (attributs `final`, pas de setters).
---
### Exercices Avancés (Design Patterns, Génériques, Flux, etc.)
15. Pattern Observateur
Un sujet (`Subject`) notifie des observateurs (`Observer`) quand son état change (ex:
système de notifications).
16. Génériques
Une classe `Boite<T>` pouvant stocker n’importe quel type d’objet, avec une méthode
`getContenu()`.
17. Comparable/Comparator
Triez une liste de `Personne` par âge en utilisant `Comparable` ou `Comparator`.
18. Sérialisation
Sauvegardez un objet `Voiture` dans un fichier `.ser` et désérialisez-le.
19. Pattern Stratégie
Une classe `TriContext` qui utilise une interface `StrategieTri` pour trier un tableau avec
différents algorithmes (ex: `TriBulle`, `TriRapide`).
20. Reflexion
Utilisez la réflexion pour lister toutes les méthodes d’une classe `Personne` et les afficher.
---
### Bonus : Mini-Projet POO
- Gestion d’une Université
Modélisez des classes `Etudiant`, `Professeur`, `Cours` avec des relations (ex: un `Cours` a
un `Professeur` et une liste d’`Etudiant`).
---
### Conseils
- Commencez par les exercices de base avant de passer aux design patterns.
- Testez chaque classe avec une méthode `main`.
- Utilisez des diagrammes UML pour visualiser les relations entre classes.
Besoin de détails sur un exercice ? 😊
Voici 10 exercices sur la programmation orientée objet (POO) en Java, couvrant les concepts
fondamentaux comme les classes, l'héritage, le polymorphisme, les interfaces, etc.
---
### Exercice 1 : Création d'une classe simple
Énoncé : Créez une classe `Livre` avec les attributs `titre`, `auteur` et `annéePublication`.
Ajoutez un constructeur, des getters/setters et une méthode `afficherDetails()` qui imprime les
informations du livre.
Objectif : Maîtriser la création de classes et d'objets.
---
### Exercice 2 : Héritage et méthode override
Énoncé : Créez une classe `Vehicule` avec `marque` et `vitesseMax`, puis une sous-classe
`Voiture` qui ajoute l'attribut `nombrePortes`. Redéfinissez une méthode `afficherInfos()`
dans `Voiture`.
Objectif : Comprendre l'héritage et l'override de méthodes.
---
### Exercice 3 : Polymorphisme
Énoncé : Créez une classe `Animal` avec une méthode `faireSon()`, puis des sous-classes
`Chien` et `Chat` qui override cette méthode. Utilisez un tableau d'`Animal` pour démontrer le
polymorphisme.
Objectif : Appliquer le polymorphisme.
---
### Exercice 4 : Interface et implémentation
Énoncé : Définissez une interface `Calculable` avec des méthodes `additionner()` et
`soustraire()`. Implémentez-la dans une classe `Calculatrice`.
Objectif : Utiliser des interfaces.
---
### Exercice 5 : Classe abstraite
Énoncé : Créez une classe abstraite `Forme` avec une méthode abstraite `calculerAire()`, puis
des sous-classes `Cercle` et `Rectangle` qui l'implémentent.
Objectif : Comprendre les classes abstraites.
---
### Exercice 6 : Encapsulation et validation
Énoncé : Dans une classe `CompteBancaire`, assurez-vous que le `solde` ne puisse pas être
négatif en utilisant des getters/setters avec validation.
Objectif : Maîtriser l'encapsulation.
---
### Exercice 7 : Composition de classes
Énoncé : Créez une classe `Moteur` et une classe `Voiture` où une `Voiture` contient un
`Moteur` (composition).
Objectif : Comprendre la composition.
---
### Exercice 8 : Singleton
Énoncé : Implémentez une classe `BaseDeDonnees` en suivant le patron Singleton pour
garantir une seule instance.
Objectif : Appliquer le design pattern Singleton.
---
### Exercice 9 : Gestion des exceptions
Énoncé : Dans une classe `Division`, créez une méthode `diviser()` qui lève une exception si
le dénominateur est zéro.
Objectif : Gérer les exceptions en POO.
---
### Exercice 10 : Collections et POO
Énoncé : Créez une classe `Bibliotheque` qui gère une liste de `Livre` (ArrayList) avec des
méthodes pour ajouter, supprimer et rechercher un livre par titre.
Objectif : Combiner collections et POO.
---
Chaque exercice peut être approfondi en ajoutant des fonctionnalités supplémentaires. Bonne
programmation ! 🚀
Besoin de corrections ou d'indices pour un exercice en particulier ? 😊
