Exercice 1 : Résolution d'Équations du Second Degré
On souhaite développer un programme pour résoudre les équations du second degré à coefficients réels, de la forme Ax² + Bx + C = 0.
- Écrire une classe `Equation` avec les propriétés publiques suivantes : les coefficients (a, b, c), le discriminant (delta) et les racines (r1 et r2).
- Créer un constructeur pour initialiser les coefficients de l'équation.
- Ajouter une méthode `void calculRacines()` aux instances de la classe `Equation`. Cette méthode doit calculer le discriminant, puis les racines de l'équation, et affecter leurs valeurs aux attributs `delta`, `r1` et `r2`.
- Écrire une méthode `String ToString()` qui retourne les solutions de l'équation (r1 et r2). Si le discriminant est strictement négatif, la méthode `ToString()` devra renvoyer le message "Pas de racine réelle".
- Écrire une classe `Probleme` contenant la méthode `Main()`. Dans cette méthode, créer une instance `monEquation` de la classe `Equation`, puis, en utilisant les méthodes de cette instance, afficher l'équation, calculer ses racines et les afficher.
- Modifier l'accès aux attributs de la classe `Equation` en `private`. Ajouter des propriétés (accesseurs/mutateurs) qui permettent un accès en lecture/écriture à ces attributs. Dans les mutateurs (setters), traiter le cas où le coefficient 'a' est égal à 0 en affichant le message d'erreur suivant : "Le programme ne traite pas le cas où a=0".
Exercice 2 : Gestion de Personnes avec Constructeurs, Propriétés et Énumérations
Créer une classe `Personne` comportant les champs suivants : `nom` (privé), `prenom` (privé), `age` (public) et `numeroDeTelephone` (public). Le champ `nom` doit être en lecture seule, initialisé uniquement via les constructeurs.
- La classe `Personne` doit disposer des constructeurs suivants :
- `Personne()` : Un constructeur par défaut qui affiche simplement le message "Construction de classe Personne".
- `Personne(nom, prenom, age, telephone)` : Ce constructeur doit appeler le constructeur par défaut au début, puis initialiser les champs avec les valeurs passées en paramètres.
- `Personne(Personne p)` : Un constructeur de copie qui initialise l'objet courant avec les caractéristiques de l'objet `Personne p` passé en paramètre.
- Implémenter la méthode `changePersonne(int nouvel_age)` qui remplace l'âge d'une personne par un nouvel âge saisi par l'utilisateur (ou passé en paramètre).
- Ajouter à la classe `Personne` une énumération `Ville` avec les possibilités : Marrakech, Rabat, Casablanca. Ajouter ensuite un champ `Origine` de type `Ville` à la classe `Personne` et effectuer les modifications nécessaires dans les constructeurs pour l'initialiser.
- Créer une méthode `SavoirOrigine()` qui affiche un message indiquant l'origine d'une personne (utilisez l'instruction `switch` pour cela).
- Afficher le message "Démarrage du programme" dès que le premier objet `Personne` est instancié.
Exercice 3 : Héritage et Polymorphisme avec Classes Personne, Employé, Chef, Directeur
Ajouter à votre projet quatre fichiers de classes distincts, illustrant l'héritage et le polymorphisme :
- Classe `Personne` : comportant les champs privés `_Nom`, `_Prénom` et `_Age`, avec les propriétés correspondantes (accesseurs/mutateurs), deux constructeurs, une surcharge de la méthode `ToString()` et une méthode polymorphe `Afficher()`.
- Classe `Employé` : dérive de la classe `Personne`, avec en plus un champ privé `_Salaire` accompagné de sa propriété, un constructeur et une surcharge des méthodes `ToString()` et `Afficher()`.
- Classe `Chef` : dérive de la classe `Employé`, avec en plus un champ privé `_Service` accompagné de sa propriété, un constructeur et une surcharge des méthodes `ToString()` et `Afficher()`.
- Classe `Directeur` : dérive de la classe `Chef`, avec en plus un champ privé `_Société` accompagné de sa propriété, un constructeur et une surcharge des méthodes `ToString()` et `Afficher()`.
Ensuite, réalisez les opérations suivantes :
- Créez un tableau de huit personnes, composé de cinq employés, deux chefs et un directeur (vous aurez donc 8 références de la classe `Personne` dans lesquelles ranger 5 instances de la classe `Employé`, 2 de la classe `Chef` et 1 de la classe `Directeur`).
- Affichez l'ensemble des éléments du tableau à l'aide d'une boucle `for`.
- Incrémentez l'âge d'un employé de 10 ans, modifiez un salaire et l'intitulé du service d'un chef.
- Affichez l'ensemble des éléments du tableau à l'aide d'une boucle `foreach`.
Exercice 4 : Classes Abstraites et Héritage pour la Gestion de Véhicules
Concevez un système pour un parc automobile composé de voitures et de camions, partageant des caractéristiques communes regroupées dans une classe `Véhicule`.
- Chaque véhicule est caractérisé par son matricule, l'année de son modèle et son prix.
- Lors de la création d'un véhicule, son matricule est incrémenté automatiquement (par exemple, à l'aide d'un compteur statique).
- Tous les attributs de la classe `Véhicule` sont supposés privés, ce qui nécessite la création de propriétés (accesseurs/mutateurs) pour y accéder.
- La classe `Véhicule` possède également deux méthodes abstraites : `démarrer()` et `accélérer()`. Ces méthodes devront être implémentées dans les classes dérivées et afficheront des messages personnalisés.
- La méthode `ToString()` de la classe `Véhicule` doit retourner une chaîne de caractères formatée contenant les valeurs du matricule, de l'année du modèle et du prix.
- Les classes `Voiture` et `Camion` étendent la classe `Véhicule` en implémentant concrètement les méthodes `accélérer()` et `démarrer()`, chacune affichant des messages personnalisés.
Implémentez ce système comme suit :
- Créer la classe abstraite `Véhicule`.
- Créer les classes `Camion` et `Voiture`.
- Créer une classe `Test` qui permet de tester la classe `Voiture` et la classe `Camion`.
Exercice 5 : Interfaces et Polymorphisme pour les Cris d'Animaux
Certains animaux peuvent crier, d'autres sont muets. Le fait de crier sera représenté par une méthode affichant le cri de l'animal à l'écran.
- Écrire une interface contenant la méthode permettant de crier (par exemple, `ICriant` avec la méthode `crier()`).
- Écrire les classes des chats, des chiens et des lapins. Les lapins sont muets. Les chats et les chiens devront implémenter l'interface `ICriant`.
- Écrire un programme avec un tableau pour les animaux qui savent crier. Remplissez ce tableau avec des instances de chiens et de chats, puis faites crier tous ces animaux. Décrivez ce qui s'affiche à l'écran lors de l'exécution de ce programme.
Exercice 6 : Gestion de Clients et de Comptes Bancaires
Développez un système de gestion pour des clients et leurs comptes bancaires.
- Définir une classe `Client` avec les attributs privés suivants : `CIN`, `Nom`, `Prénom`, `Téléphone`.
- Définir, à l'aide de propriétés (accesseurs/mutateurs), les méthodes d'accès aux différents attributs de la classe `Client`.
- Définir un constructeur permettant d'initialiser tous les attributs d'un client.
- Définir un second constructeur permettant d'initialiser uniquement le `CIN`, le `Nom` et le `Prénom`.
- Définir la méthode `Afficher()` permettant d'afficher les informations du Client actuel.
- Créer une classe `Compte` caractérisée par son `solde` et un `code` (numéro de compte) qui est incrémenté lors de sa création (par un compteur statique), ainsi que son `propriétaire` qui représente une instance de la classe `Client`.
- Définir, à l'aide de propriétés, les méthodes d'accès aux différents attributs de la classe `Compte`. Le numéro de compte (`code`) et le `solde` doivent être en lecture seule (read-only).
- Définir un constructeur permettant de créer un compte en indiquant son propriétaire.
- Ajouter à la classe `Compte` les méthodes suivantes :
- Une méthode `Crediter()` le compte, prenant une somme en paramètre.
- Une méthode `Crediter()` le compte, prenant une somme et un compte source en paramètres, créditant le compte courant et débitant le compte source.
- Une méthode `Debiter()` le compte, prenant une somme en paramètre.
- Une méthode `Debiter()` le compte, prenant une somme et un compte cible en paramètres, débitant le compte courant et créditant le compte cible.
- Une méthode qui permet d'afficher le résumé d'un compte.
- Une méthode qui permet d'afficher le nombre total de comptes créés (en utilisant un attribut statique).
- Créer un programme de test pour la classe `Compte`, illustrant toutes ses fonctionnalités.
Foire Aux Questions (FAQ) sur la Programmation Orientée Objet
- Qu'est-ce qu'une classe et un objet en programmation orientée objet ?
- Une classe est un modèle ou un plan qui décrit la structure (attributs) et le comportement (méthodes) d'un type d'entité. Un objet est une instance concrète de cette classe, possédant ses propres données et pouvant exécuter les actions définies par la classe. Par exemple, "Voiture" est une classe, tandis que "maVoitureRouge" est un objet de cette classe.
- Quelle est la différence entre l'héritage et l'implémentation d'une interface ?
- L'héritage permet à une classe (classe dérivée) d'acquérir les propriétés et les méthodes d'une autre classe (classe de base), favorisant la réutilisation du code et établissant une relation "est un" (ex: "Employé est une Personne"). L'implémentation d'une interface, quant à elle, oblige une classe à respecter un contrat en fournissant des implémentations pour toutes les méthodes définies dans l'interface, définissant ainsi une capacité ou un comportement sans partager d'implémentation de base (ex: un "Chien" implémente l'interface "ICriant").
- À quoi servent les propriétés (getters/setters) dans une classe ?
- Les propriétés, souvent implémentées via des accesseurs (getters) et des mutateurs (setters), permettent de contrôler l'accès aux attributs privés d'une classe. Elles encapsulent la logique d'accès et de modification des données, offrant ainsi une couche de validation, de calcul ou de formatage avant que la donnée ne soit lue ou écrite, protégeant l'intégrité et la cohérence de l'objet.