(Partie 3 de "Mettre des pensées orientées objet partout - Parler du développement Delphi")
Les deux premiers articles traitaient de sujets liés à l'encapsulation. Ici, je veux vous parler d'héritage et de polymorphisme.
L'héritage et le polymorphisme sont étroitement liés. Object Pascal introduit un mécanisme polymorphe appelé surcharge. Son idée n'a pas grand-chose à voir avec l'orientation objet et ne sera pas abordée ici. Le polymorphisme, qui est étroitement lié à la pensée orientée objet, est ce sur quoi nous nous concentrons.
Le polymorphisme s'appuie sur les concepts de méthodes abstraites et de méthodes virtuelles et est également étroitement lié à l'héritage. On pense que nous définissons souvent certains objets sous-jacents, puis définissons certaines de leurs implémentations comme abstraites, ce qui signifie que nous définissons uniquement l'interface sans définir de détails d'implémentation spécifiques. Suivant cette idée, nous définirons également plusieurs objets dérivés (hérités), dans lesquels les détails qui n'ont pas été implémentés dans la classe ancêtre sont réellement implémentés. Cela rend la classe sous-jacente que nous avons définie précédemment polymorphe. L’avantage de ce mécanisme est que lorsque nous utilisons ces classes, nous n’avons besoin que d’un seul ensemble de code pour remplir plusieurs fonctions. La seule chose qui doit changer est la partie qui crée une instance de l'objet.
Observez une classe comme celle-ci :
TStream = classe (TObject)
…
publique
fonction Read(var Buffer; Count: Longint) : Longint ; virtuel ;
fonction Write(const Buffer; Count: Longint) : Longint virtuel ;
…
fin;
Les mots réservés virtuels et abstraits indiquent que les méthodes Read et Write sont de pures fonctions virtuelles. Cela montre que la classe TStream ne peut pas vraiment être utilisée (les instances de cette classe ne peuvent pas être créées). Il s'agit simplement d'une classe similaire à une interface, qui définit les fonctions de base que la classe TStream devrait avoir et qu'elle doit gérer. Et il stipule également que d'autres classes dérivées de la classe TStream doivent implémenter des fonctions (telles que Read et Write, etc.).
Par exemple, TFileStream implémente la classe TStream sous la forme d'applications de fichiers disque ; tandis que TMemoryStream implémente la classe TStream sous la forme d'applications mémoire. Supposons maintenant qu'il existe une classe TMyClass qui fournit une méthode SaveToStream :
TMyClass = Classe (TObject)
PROcédure SaveToStream(Stream : TStream);
fin;
En appliquant ensuite l'idée du polymorphisme, vous pouvez avoir un code comme celui-ci :
var
strm : TStream ;
MaClasse : TMaClasse ;
commencer
strm := TFileStream.Create('abc.txt'); // ß Le véritable type d'instance de Stream ici est TFileStream
MaClasse := TMyClass.Create;
MaClasse.SaveToStream(strm);
…..
fin;
Pour stocker le contenu de MyClass en mémoire, changez simplement
strm := TFileStream.Create('abc.txt');
pour:
strm := TMemoryStream.Create;
C'est ça.
L'utilisation du polymorphisme nécessite deux aspects de travail : l'un est bien sûr que le polymorphisme soit pris en compte dans la structure des classes et puisse fournir des classes intermédiaires (classes abstraites) qui implémentent certaines fonctions ; classes. Ce travail se reflète dans la définition de certaines procédures et paramètres de fonctions.
Autre point très important, je voudrais rappeler à tous que la planification des classes est très importante à l'ère de la programmation orientée objet, le cadre de classe détermine dans une large mesure le cadre du programme et détermine le succès ou l'échec du développement logiciel. Une architecture de classes claire et hiérarchique facilite non seulement la division et l'expansion fonctionnelles, mais facilite également la maintenance du code. Parmi celles-ci, l'application des idées d'héritage et de polymorphisme, l'introduction de classes abstraites et l'introduction de classes intermédiaires sont une méthode plus préférable.
Ce qui suit répertorie certaines des classes abstraites et des classes concrètes fournies dans Delphi :
classe concrète dérivée d'une classe abstraite
TStream TFileStream, TMemoryStream ;
TCustomIniFile TIniFile, TMemIniFile, TRegistryIniFile ;
TStrings TStringList, TMemoStrings, TListBoxStrings ;
Il y en a bien d’autres qui attendent que vous et moi les découvrions. Le plus couramment utilisé ici est TStream, et ce qui me surprend le plus est TCustomIniFile. Son TRegistryIniFile permet d'accéder au registre de la même manière qu'IniFile ! Cela me permet d'utiliser un ensemble de codes pour implémenter les fonctions d'écriture du registre et d'écriture des fichiers Ini. Bien que la technologie impliquée soit simple, son importance est extraordinaire !
(Inachevé, à suivre)
Plus d'articles