Skip to content

07.1-classes-objets.md

Latest commit

 

History

History
255 lines (196 loc) · 7.48 KB

07.1-classes-objets.md

File metadata and controls

255 lines (196 loc) · 7.48 KB

🔝 Retour au Sommaire

3.7.1 Classes et objets en Object Pascal

Introduction à la programmation orientée objet

La programmation orientée objet (POO) est un paradigme de programmation qui permet d'organiser le code de manière plus structurée et réutilisable. Au lieu de penser uniquement en termes de procédures et de fonctions qui manipulent des données, la POO nous invite à penser en termes d'objets qui combinent données et comportements.

En Delphi, la POO est au cœur du langage Object Pascal. Comprendre les classes et les objets est essentiel pour tirer pleinement parti de Delphi.

Qu'est-ce qu'une classe ?

Une classe est un modèle ou un plan qui décrit la structure et le comportement d'un type d'objet. Pensez à une classe comme à un moule à gâteau : le moule définit la forme, mais ce n'est pas le gâteau lui-même.

Une classe contient :

  • Des champs (ou attributs) : les données que l'objet va stocker
  • Des méthodes : les actions que l'objet peut effectuer

Qu'est-ce qu'un objet ?

Un objet est une instance concrète d'une classe. Si la classe est le moule, l'objet est le gâteau créé à partir de ce moule. Vous pouvez créer autant d'objets que vous le souhaitez à partir d'une même classe.

Définir une classe simple

Voici comment définir une classe en Object Pascal :

type
  TPersonne = class
  private
    FNom: string;
    FAge: Integer;
  public
    procedure SePresenter;
  end;

Décortiquons cette définition

  • type : mot-clé qui introduit une définition de type
  • TPersonne : le nom de la classe (par convention, les classes commencent par T)
  • class : mot-clé indiquant qu'il s'agit d'une classe
  • private : section pour les membres privés (accessibles uniquement à l'intérieur de la classe)
  • FNom, FAge : champs privés (par convention, préfixés par F pour "Field")
  • public : section pour les membres publics (accessibles de l'extérieur)
  • SePresenter : une méthode publique

Implémentation des méthodes

Après avoir déclaré la classe, nous devons implémenter ses méthodes :

procedure TPersonne.SePresenter;  
begin  
  ShowMessage('Bonjour, je m''appelle ' + FNom +
              ' et j''ai ' + IntToStr(FAge) + ' ans.');
end;

La notation TPersonne.SePresenter indique que cette procédure appartient à la classe TPersonne.

Créer et utiliser un objet

Pour utiliser une classe, nous devons créer un objet (une instance) :

var
  UnePersonne: TPersonne;
begin
  // Créer l'objet
  UnePersonne := TPersonne.Create;

  try
    // Utiliser l'objet
    UnePersonne.FNom := 'Marie';
    UnePersonne.FAge := 25;
    UnePersonne.SePresenter;
  finally
    // Détruire l'objet pour libérer la mémoire
    UnePersonne.Free;
  end;
end;

Points importants

  1. Create : méthode héritée qui crée l'instance en mémoire
  2. try...finally : bloc garantissant la libération de la mémoire
  3. Free : méthode qui détruit l'objet et libère la mémoire

Exemple complet d'une classe

Voici un exemple plus complet d'une classe représentant un compte bancaire :

type
  TCompteBancaire = class
  private
    FTitulaire: string;
    FSolde: Double;
  public
    procedure Deposer(Montant: Double);
    procedure Retirer(Montant: Double);
    function ObtenirSolde: Double;
    procedure AfficherInfos;
  end;

// Implémentation des méthodes

procedure TCompteBancaire.Deposer(Montant: Double);  
begin  
  if Montant > 0 then
    FSolde := FSolde + Montant;
end;

procedure TCompteBancaire.Retirer(Montant: Double);  
begin  
  if (Montant > 0) and (FSolde >= Montant) then
    FSolde := FSolde - Montant
  else
    ShowMessage('Solde insuffisant ou montant invalide');
end;

function TCompteBancaire.ObtenirSolde: Double;  
begin  
  Result := FSolde;
end;

procedure TCompteBancaire.AfficherInfos;  
begin  
  ShowMessage('Titulaire: ' + FTitulaire + #13#10 +
              'Solde: ' + FormatFloat('0.00', FSolde) + ' €');
end;

Utilisation de cette classe

var
  MonCompte: TCompteBancaire;
begin
  MonCompte := TCompteBancaire.Create;
  try
    MonCompte.FTitulaire := 'Jean Dupont';
    MonCompte.FSolde := 1000.0; // Initialisation

    MonCompte.Deposer(500);
    MonCompte.Retirer(200);
    MonCompte.AfficherInfos; // Affiche le solde de 1300€
  finally
    MonCompte.Free;
  end;
end;

Les sections de visibilité

En Object Pascal, vous pouvez contrôler l'accès aux membres d'une classe avec différentes sections :

Private

Les membres private ne sont accessibles que depuis l'intérieur de la classe elle-même.

type
  TMaClasse = class
  private
    FDonneeSecrete: string;  // Accessible uniquement dans TMaClasse
  end;

Public

Les membres public sont accessibles de partout.

type
  TMaClasse = class
  public
    DonneePublique: string;  // Accessible partout
    procedure MethodePublique;
  end;

Protected

Les membres protected sont accessibles dans la classe et ses classes dérivées (héritage).

type
  TMaClasse = class
  protected
    FDonneeProtegee: string;  // Accessible dans cette classe et ses descendants
  end;

Published

Les membres published sont publics et visibles dans l'inspecteur d'objets de Delphi (pour les propriétés).

Bonnes pratiques

  1. Toujours libérer les objets : utilisez try...finally avec Free pour éviter les fuites mémoire
  2. Nommage cohérent :
    • Classes : préfixe T (TPersonne, TCompte)
    • Champs privés : préfixe F (FNom, FSolde)
  3. Encapsulation : gardez les champs privés et exposez des méthodes publiques pour y accéder
  4. Une classe, une responsabilité : chaque classe devrait avoir un rôle clair et unique

Différence entre classe et objet - Analogie

Imaginons la construction d'une maison :

  • La classe = les plans de la maison (le blueprint)

    • Définit combien de pièces, où sont les portes, etc.
    • C'est une description abstraite

  • L'objet = la maison réelle construite selon ces plans

    • Une structure concrète que vous pouvez habiter
    • Vous pouvez construire plusieurs maisons identiques à partir des mêmes plans

En code :

type
  TMaison = class  // La classe (les plans)
  private
    FNombrePieces: Integer;
    FCouleur: string;
  end;

var
  MaisonA, MaisonB: TMaison;  // Deux objets (deux maisons)
begin
  MaisonA := TMaison.Create;  // Construire la première maison
  MaisonB := TMaison.Create;  // Construire la deuxième maison

  // Chaque maison peut avoir des caractéristiques différentes
  MaisonA.FNombrePieces := 5;
  MaisonA.FCouleur := 'Bleue';

  MaisonB.FNombrePieces := 3;
  MaisonB.FCouleur := 'Rouge';
end;

Résumé

  • Une classe est un modèle définissant la structure et le comportement d'objets
  • Un objet est une instance concrète d'une classe
  • Les champs stockent les données de l'objet
  • Les méthodes définissent les actions que l'objet peut effectuer
  • La visibilité (private, public, protected) contrôle l'accès aux membres
  • Il faut toujours créer un objet avec Create et le libérer avec Free
  • Le bloc try...finally garantit la libération de la mémoire

Les classes et objets sont la fondation de la programmation orientée objet en Delphi. Une fois ce concept maîtrisé, vous pourrez explorer les propriétés, l'héritage, le polymorphisme et tous les autres aspects puissants de la POO.

⏭️ Propriétés et méthodes