Pascal - Orienté objet

Nous pouvons imaginer notre univers fait de différents objets comme le soleil, la terre, la lune, etc. De même, nous pouvons imaginer notre voiture faite de différents objets comme le volant, la direction, les engins, etc. assumer tout comme objet et implémenter un logiciel en utilisant différents objets. Dans Pascal, il existe deux types de données structurelles utilisées pour implémenter un objet du monde réel -

  • Types d'objets
  • Types de cours

Concepts orientés objet

Avant d'entrer dans les détails, définissons les termes Pascal importants liés au Pascal orienté objet.

  • Object- Un objet est un type spécial d'enregistrement qui contient des champs comme un enregistrement; cependant, contrairement aux enregistrements, les objets contiennent des procédures et des fonctions faisant partie de l'objet. Ces procédures et fonctions sont conservées comme des pointeurs vers les méthodes associées au type de l'objet.

  • Class- Une classe est définie presque de la même manière qu'un objet, mais il y a une différence dans la manière dont elles sont créées. La classe est allouée sur le tas d'un programme, tandis que l'objet est alloué sur la pile. C'est un pointeur vers l'objet, pas l'objet lui-même.

  • Instantiation of a class- L'instanciation consiste à créer une variable de ce type de classe. Puisqu'une classe n'est qu'un pointeur, lorsqu'une variable d'un type de classe est déclarée, il y a de la mémoire allouée uniquement pour le pointeur, pas pour l'objet entier. Uniquement lorsqu'il est instancié à l'aide de l'un de ses constructeurs, la mémoire est allouée à l'objet. Les instances d'une classe sont également appelées «objets», mais ne les confondez pas avec les objets Object Pascal. Dans ce tutoriel, nous écrirons "Object" pour les objets Pascal et "object" pour l'objet conceptuel ou l'instance de classe.

  • Member Variables - Ce sont les variables définies à l'intérieur d'une classe ou d'un objet.

  • Member Functions - Ce sont les fonctions ou procédures définies à l'intérieur d'une classe ou d'un objet et sont utilisées pour accéder aux données d'objet.

  • Visibility of Members- Les membres d'un objet ou d'une classe sont également appelés les champs. Ces domaines ont des visibilités différentes. La visibilité fait référence à l'accessibilité des membres, c'est-à-dire exactement là où ces membres seront accessibles. Les objets ont trois niveaux de visibilité: public, privé et protégé. Les classes ont cinq types de visibilité: publique, privée, strictement privée, protégée et publiée. Nous discuterons de la visibilité en détail.

  • Inheritance- Lorsqu'une classe est définie en héritant des fonctionnalités existantes d'une classe parent, on dit qu'elle est héritée. Ici, la classe enfant héritera de toutes ou de quelques fonctions membres et variables d'une classe parent. Les objets peuvent également être hérités.

  • Parent Class- Une classe héritée par une autre classe. Ceci est également appelé une classe de base ou une super classe.

  • Child Class- Une classe qui hérite d'une autre classe. Ceci est également appelé une sous-classe ou une classe dérivée.

  • Polymorphism- Il s'agit d'un concept orienté objet où la même fonction peut être utilisée à des fins différentes. Par exemple, le nom de la fonction restera le même, mais il peut prendre un nombre d'arguments différent et effectuer différentes tâches. Les classes Pascal implémentent le polymorphisme. Les objets n'implémentent pas le polymorphisme.

  • Overloading- C'est un type de polymorphisme dans lequel certains ou tous les opérateurs ont des implémentations différentes selon les types de leurs arguments. De même, les fonctions peuvent également être surchargées avec une implémentation différente. Les classes Pascal implémentent la surcharge, mais pas les objets.

  • Data Abstraction - Toute représentation de données dans laquelle les détails d'implémentation sont masqués (abstraits).

  • Encapsulation - Fait référence à un concept où nous encapsulons toutes les données et les fonctions membres ensemble pour former un objet.

  • Constructor - Fait référence à un type spécial de fonction qui sera appelée automatiquement chaque fois qu'il y a une formation d'objet à partir d'une classe ou d'un objet.

  • Destructor - Fait référence à un type spécial de fonction qui sera appelée automatiquement chaque fois qu'un objet ou une classe est supprimé ou hors de portée.

Définir des objets Pascal

Un objet est déclaré à l'aide de la déclaration de type. La forme générale d'une déclaration d'objet est la suivante -

type object-identifier = object  
   private
   field1 : field-type;  
   field2 : field-type;  
   ...
   public
   procedure proc1;  
   function f1(): function-type;
   end;  
var objectvar : object-identifier;

Définissons un objet Rectangle qui a deux membres de données de type entier - length et width et certaines fonctions membres pour manipuler ces données membres et une procédure pour dessiner le rectangle.

type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      constructor init;  
      destructor done;  
      
      procedure setlength(l: inteter);  
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

Après avoir créé vos objets, vous pourrez appeler des fonctions membres liées à cet objet. Une fonction membre pourra traiter la variable membre de l'objet associé uniquement.

L'exemple suivant montre comment définir des longueurs et des largeurs pour deux objets rectangle et les dessiner en appelant les fonctions membres.

r1.setlength(3);
r1.setwidth(7);

writeln(' Draw a rectangle: ', r1.getlength(), ' by ' , r1.getwidth());
r1.draw;
new(pr1);
pr1^.setlength(5);
pr1^.setwidth(4);

writeln(' Draw a rectangle: ', pr1^.getlength(), ' by ' ,pr1^.getwidth());
pr1^.draw;
dispose(pr1);

Voici un exemple complet pour montrer comment utiliser des objets en Pascal -

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   
   public  
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;
var
   r1: Rectangle;
   pr1: ^Rectangle;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
     for j:= 1 to width do
        write(' * ');
     writeln;
   end;
end;

begin
   r1.setlength(3);
   r1.setwidth(7);
   
   writeln('Draw a rectangle:', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   new(pr1);
   pr1^.setlength(5);
   pr1^.setwidth(4);
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
end.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *

Visibilité des membres de l'objet

La visibilité indique l'accessibilité des membres de l'objet. Les membres d'objet Pascal ont trois types de visibilité -

Sr. Non Visibilité et accessibilité
1

Public

Les membres peuvent être utilisés par d'autres unités en dehors de l'unité de programme
2

Private

Les membres ne sont accessibles que dans l'unité courante.
3

Protected

Les membres ne sont disponibles que pour les objets descendants de l'objet parent.

Par défaut, les champs et méthodes d'un objet sont publics et sont exportés en dehors de l'unité courante.

Constructeurs et destructeurs pour les objets Pascal -

Constructorssont des méthodes de type spécial, qui sont appelées automatiquement chaque fois qu'un objet est créé. Vous créez un constructeur en Pascal simplement en déclarant une méthode avec un constructeur de mot-clé. Par convention, le nom de la méthode est Init, cependant, vous pouvez fournir n'importe quel identifiant valide de votre choix. Vous pouvez passer autant d'arguments que vous le souhaitez dans la fonction constructeur.

Destructorssont des méthodes appelées lors de la destruction de l'objet. Les méthodes destructrices détruisent toute allocation de mémoire créée par les constructeurs.

L'exemple suivant fournira un constructeur et un destructeur pour la classe Rectangle qui initialisera la longueur et la largeur du rectangle au moment de la création de l'objet et le détruira lorsqu'il sortira de la portée.

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      constructor init(l, w: integer);
      destructor done;
      
      procedure setlength(l: integer);
      function getlength(): integer;  
      
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      
      procedure draw;
end;

var
   r1: Rectangle;
   pr1: ^Rectangle;

constructor Rectangle.init(l, w: integer);
begin
   length := l;
   width := w;
end;

destructor Rectangle.done;
begin
   writeln(' Desctructor Called');
end; 

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth(): integer;  
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
   end;
end;

begin
   r1.init(3, 7);
   writeln('Draw a rectangle:', r1.getlength(), ' by ' , r1.getwidth());
   r1.draw;
   new(pr1, init(5, 4));
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ',pr1^.getwidth());
   pr1^.draw;
   pr1^.init(7, 9);
   
   writeln('Draw a rectangle:', pr1^.getlength(), ' by ' ,pr1^.getwidth());
   pr1^.draw;
   dispose(pr1);
   r1.done;
end.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Draw a rectangle: 3 by 7
* * * * * * *
* * * * * * *
* * * * * * *
Draw a rectangle: 5 by 4
* * * *
* * * *
* * * *
* * * *
* * * *
Draw a rectangle: 7 by 9
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
* * * * * * * * *
Destructor Called

Héritage des objets Pascal

Les objets Pascal peuvent éventuellement hériter d'un objet parent. Le programme suivant illustre l'héritage dans les objets Pascal. Créons un autre objet nomméTableTop, qui hérite de l'objet Rectangle.

program exObjects;
type 
   Rectangle = object  
   private  
      length, width: integer; 
   public  
      procedure setlength(l: integer);  
      function getlength(): integer;  
      procedure setwidth(w: integer);  
      function getwidth(): integer;  
      procedure draw;
end;

TableTop = object (Rectangle)
   private
     material: string;
   public
      function getmaterial(): string;
      procedure setmaterial( m: string);
      procedure displaydetails;
      procedure draw;
end;

var
   tt1: TableTop;

procedure Rectangle.setlength(l: integer);
begin
   length := l;
end;

procedure Rectangle.setwidth(w: integer);
begin
   width :=w;
end;

function Rectangle.getlength(): integer;  
begin
   getlength := length;
end;

function Rectangle.getwidth():integer;
begin
   getwidth := width;
end;

procedure Rectangle.draw;
var 
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
      writeln;
  end;
end;

function TableTop.getmaterial(): string;
begin
   getmaterial := material;
end;

procedure TableTop.setmaterial( m: string);
begin
   material := m;
end;

procedure TableTop.displaydetails;
begin
   writeln('Table Top: ', self.getlength(), ' by ' , self.getwidth());
   writeln('Material: ', self.getmaterial());
end;

procedure TableTop.draw();
var
   i, j: integer;
begin
   for i:= 1 to length do
   begin
      for j:= 1 to width do
         write(' * ');
   writeln;
   end;
   writeln('Material: ', material);
end;

begin
   tt1.setlength(3);
   tt1.setwidth(7);
   tt1.setmaterial('Wood');
   tt1.displaydetails();
   writeln;
   writeln('Calling the Draw method');
   tt1.draw();
end.

Voici les points importants à noter -

  • L'objet Tabletop a hérité de tous les membres de l'objet Rectangle.

  • Il existe également une méthode de dessin dans TableTop . Lorsque le tirage méthode est appelée à l' aide d' un TableTop objet, le tirage au sort de TableTop s'invoqué.

  • Il existe une instance implicite nommée self qui fait référence à l'instance actuelle de l'objet.

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Table Top: 3 by 7
Material: Wood

Calling the Draw Method 
* * * * * * *
* * * * * * *
* * * * * * *
Material: Wood