La programmation orientée objet repose sur quatre grands principes fondamentaux : l’héritage, le polymorphisme, l’encapsulation et l’abstraction. Ces concepts permettent de structurer le code de manière modulaire, réutilisable et évolutive.

L’héritage permet à une classe de hériter des propriétés et des comportements d’une autre classe.
La classe dérivée bénéficie ainsi de tout ce que la classe parente possède, tout en pouvant ajouter ou modifier certains éléments.
Ce mécanisme favorise la réutilisation du code et une meilleure organisation hiérarchique des objets.

Exemple : Une classe Voiture peut hériter d’une classe Véhicule.

Le polymorphisme permet à plusieurs objets de réagir différemment à une même action.
On peut utiliser une même interface ou méthode avec des comportements qui varient selon l’objet concerné.
C’est un outil essentiel pour rendre le code plus flexible et évolutif.

Exemple : Une méthode afficher() peut produire une sortie différente selon qu’elle est appelée sur un Document ou une Image.

L’encapsulation consiste à protéger les données d’un objet en restreignant leur accès direct.
Les attributs sont généralement rendus privés et manipulés uniquement via des méthodes publiques.
Cela permet de garantir l’intégrité des données et d’éviter les comportements imprévus.

Exemple : On accède à une variable solde via getSolde() plutôt qu’en y accédant directement.

L’abstraction permet de cacher les détails d’implémentation et de ne montrer que les fonctionnalités essentielles.
Elle permet de modéliser des entités complexes par des concepts simples, en mettant l’accent sur le "quoi" plutôt que le "comment".
On utilise souvent des interfaces ou des classes abstraites pour cela.

Exemple : Une interface Paiement définit une méthode effectuer(), sans préciser comment le paiement est traité.

La décomposition d’un problème en classes est une étape fondamentale quand on conçoit un programme orienté objet. Elle consiste à analyser un problème, identifier les entités principales, et les modéliser sous forme de classes.

Décomposer un problème en classes, c’est transformer une description du monde réel (ou d’un besoin logiciel) en une structure de code composée d’objets.
Chaque objet représente une entité ayant un état (attributs) et des comportements (méthodes).

L’objectif est de représenter le plus fidèlement possible la réalité du système à développer.

Lire et analyser l'énoncé. Identifier les acteurs, les objets manipulés, les règles, et les actions.

Exemple : Dans un système de gestion de bibliothèque, on gère des livres, des lecteurs, des emprunts...

Repérer les noms d'entités importantes → ce sont souvent des noms communs ou concepts métiers.

Classes possibles : Livre, Lecteur, Bibliothèque, Emprunt

Chaque classe doit contenir des données caractéristiques de l’entité.

Livre → titre, auteur, ISBN
Lecteur → nom, numéro d’abonné

Quels sont les comportements ou les actions que chaque classe peut faire ou subir ?

Livre → être emprunté, être retourné
Lecteur → emprunter un livre, rendre un livre

• Association : une classe "utilise" une autre
• Agrégation : une classe "contient" une autre
• Composition : la "survie" d'une classe dépent d'une autre
• Héritage : une classe "est un type de" (relation hiérarchique)

Un Lecteur emprunte un Livre → association
Une Bibliothèque contient des Livres → composition

Créer un diagramme de classes (optionnel mais recommandé) pour visualiser les relations.
Réfléchir à la visibilité des attributs (private, public), aux constructeurs, et à la cohérence du modèle.

✔ A un nom clair
✔ Représente une seule responsabilité
✔ Est cohérente et autonome
✔ Ne dépend pas inutilement d’autres classes

Problème : Gérer les réservations d’une salle de cinéma.

→ Classes identifiées :

• Film
• Salle
• Représentation
• Client
• Réservation

→ Exemple d’une classe :

class Film {
    private String titre;
    private String genre;
    private int duree;

    public void afficherInfos() { ... }
}

Ce principe vise à éviter la duplication de code.
Chaque morceau de logique doit être écrit une seule fois dans le programme, puis réutilisé.

✅ Cela rend le code :

• Plus lisible
• Plus facile à maintenir
• Moins sujet aux erreurs

Si tu as plusieurs fois le même bloc de code pour calculer une remise, place-le dans une méthode réutilisable.

Ce principe encourage à rester simple dans la conception du code et à éviter la complexité inutile.
Un code simple est plus facile à :

• Lire
• Comprendre
• Déboguer
• Tester

✅ On privilégie la clarté et l'efficacité au lieu d'essayer d'être trop "intelligent" ou "créatif".

🛠 Exemple :
Inutile d’utiliser une structure complexe quand une boucle simple suffit.

Ce principe rappelle qu’il ne faut pas coder des fonctionnalités "au cas où".
On ne développe que ce qui est nécessaire maintenant, pas ce qu’on pense être utile plus tard.

✅ Cela permet de :

• Éviter la surcharge inutile
• Réduire la complexité
• Gagner du temps

🛠 Exemple :
Ne crée pas de classe "Manager" générique si ton application n’en a pas encore besoin.

J’ai des billets d’avion pour des vols qui peuvent être nationaux (à l’intérieur du pays) ou internationaux (vers un autre pays).

Chaque billet contient les informations suivantes :

• un numéro d’identification,
• le nom du passager,
• le prix du billet,
• et s’il a été envoyé électroniquement ou imprimé en personne.

• Si le billet est électronique et que le vol est international vers la France, alors il faut ajouter la TPS (taxe fédérale) et la TVQ (taxe du Québec).
• Si le billet est électronique et que le vol est international vers un autre pays, alors il faut ajouter seulement la TPS.
• Si le billet est électronique et que le vol est national, il faut ajouter seulement la TVA.

• Voir la somme des prix réel de tous les billets,
• Filtrer et afficher les billets selon les vols nationaux ou internationaux,

• Billet
• Avion
• Vol
• Nationaux
• Internationaux
• TypeVol
• Taxe
• Gestionnaire
• OutilsGestion

• Billet

  • idBillet : int
  • nom : String
  • prix : float
  • estElectronique : boolean

• Vol

  • idVol : int
  • estInternational : Boolean
  • billets : ArrayList<Billet>

• OutilsGestion

  • TPS : float
  • TVQ : float
  • TVA : float

• TypeVol

  • INTERNATIONAL
  • NATIONAL

Billet.setter/getter&constructeur

Vol.setter/getter&constructeur

OutilsGestion.calculPrixReelBillet(billet:Billet, vol:Vol)

OutilsGEstion.afficherInfoVolFiltre(vols:Vol[], typeVol:TypeVol)

Agrégation

• vol -> Typevol

Composition

• Vol -> Billet

Association

• OutilsGestion -> Vol
• OutilsGestion -> Billet

✔ A un nom clair
✔ Représente une seule responsabilité
✔ Est cohérente et autonome
✔ Ne dépend pas inutilement d’autres classes

Donnée :

Billet 101 avec un prix de base de 200$ (Papier)

Billet 102 avec un prix de base de 150$ (électronique)

Billet 201 avec un prix de base de 300$ (électronique)

Billet 301 avec un prix de base de 500$ (électronique)

Vol1 est à destination du Canada

Vol2 est à destination de la France

Vol3 est à destination du Mexique

💰 Prix total des billets : 1235.50$

✈️ Billets internationaux :
Vol : 2
                      201         348.00$
Vol : 3
                      301         530.00$

🏠 Billets nationaux :
Vol : 1
                      101         200.00$
                      102         157.50$

Vous devez développer un système complet permettant de gérer différents types de contacts.

Un contact, quel qu’il soit, doit au minimum comporter un nom et une adresse électronique. Ces informations doivent être accessibles dès la création et pouvoir être affichées à tout moment.

Les individus possèdent, en plus des données communes, un âge et un numéro de téléphone. De leur côté, les entreprises ont un secteur d’activité ainsi qu’une adresse postale. L’affichage d’un contact doit toujours restituer l’ensemble des informations pertinentes à son type.

Le système doit permettre de centraliser la gestion de tous les contacts via un outil dédié. Cet outil doit :

Démarrer avec aucun contact enregistré.

Permettre l’ajout de nouveaux contacts, qu’ils soient des individus ou des entreprises. Il doit vérifier que le nom du contact est unique avant l'ajout et s'il ne l'est pas, il doit refuser l'ajout.

Afficher, à la demande, tous les contacts enregistrés dans leur intégralité.

Permettre la recherche d’un contact à partir de son nom exact, et en restituer les informations si trouvé.

Offrir la possibilité de retirer un contact en se basant sur son nom, et indiquer clairement si l’opération a abouti.

La structure de votre programme doit être modulaire, claire et cohérente avec une approche orientée objet. Assurez-vous d’exploiter les mécanismes de généralisation, de spécialisation, de redéfinition comportementale, et de polymorphisme lorsqu’ils sont pertinents.

Dans votre code principal, réalisez les opérations suivantes :

Ajoutez plusieurs contacts, représentant différents cas.

Affichez tous les contacts pour vérifier la bonne intégration.

Lancez une recherche ciblée par nom et affichez le résultat.

Supprimez un contact et affichez un message de confirmation ou d’échec.

----------------------------------------------------------------------

1. Ajouter un contact
2. Afficher tous les contact
3. Afficher les infos d'un contact
4. Retirer un contact
q. Quitter le programme

Votre choix :2

----------------------------------------------------------------------
1. Ajouter un contact
2. Afficher tous les contact
3. Afficher les infos d'un contact
4. Retirer un contact
q. Quitter le programme

Votre choix :1

Voulez-vous ajouter une entreprise(e) ou un individu(i)?e

Entrez le nom : FrisbeeInc
Entrez le courriel : discgolf@wouhou
Entrez le secteur d'activité : Sport
Entrez l'adressePostale : 213

-----------------------------------------------------------------------

1. Ajouter un contact
2. Afficher tous les contact
3. Afficher les infos d'un contact
4. Retirer un contact
q. Quitter le programme

Votre choix :2

Nom : FrisbeeInc
Secteur d'activié : Sport
Adresse postale : 213
Courriel : discgolf@wouhou

----------------------------------------------------------------------

1. Ajouter un contact
2. Afficher tous les contact
3. Afficher les infos d'un contact
4. Retirer un contact
q. Quitter le programme

Votre choix :q


Fin du programme