| 
P R O G R A M M A T I O N O R I E N T E E O B J E T S La notion d'objet propose d'écrire du logiciel : + de manière plus fiable (des petites entités sont plus faciles à tester) + plus rapide (réutilisation maximale de code existant) + plus évolutive (des petites entités sont plus faciles à maintenir) Cela induit, en fait, un nouvel état d'esprit. Pour simplifier la programmation et tendre vers plus de qualité, différentes méthodes ont étés implémentées: - programmation structurée Un code plus facile à lire, à maintenir. Mais cela n'empèche pas les programmes d'atteindre une taille critique. |
|
- programmation modulaire des petits éléments de code (correspondant à une action et une seule) Maintenance simplifiée, mais reste le problème du partage des variables En effet, si les variables sont partageables, la modification d'un sous programme peut alterer les variables utilisées par les autres. - règle de visibilité. Avec des langages comme le C ou PASCAL, chaque sous programme possède ses propres variables qui ne sont partageables que si elles sont déclarées en tant que variables GLOBALES ou en tant que paramètres. En pascal on parle de procédure (sous programme exécutant une action à l'aide de paramètres reçus) fonction (sous programme renvoyant une valeur, peut recevoir des paramètres) exemple: (en pascal) |
|
Il est possible de "typer" des variables c'est à dire de déclarer de nouveaux types de variables: TYPE C20 = STRING[20] VAR NOM,VILLE:C20 les sous programmes doivent être définis AVANT le programme principal (* déclaration de la procédure *) PROCEDURE proc1(x:C20 y:INTEGER); (* déclaration de variable interne au sous-prog *) VAR a:INTEGER; (* la variable a n'est connue que du sous-pgm PROC1 *) BEGIN ... END; |
|
FONCTION maxi(x:INTEGER y:INTEGER):INTEGER (* renvoi un entier *)
BEGIN
IF x < y THEN maxi := Y ELSE maxi := x;
END
BEGIN (* pgm principal *)
proc1(nom, 15)
x := maxi(a, b)
END.
En C, la distinction procédure/fonction n'est pas faite.
/*********************************************************************/
/* min - renvoi le nombre le plus petit des 2 (fonction) */
/*********************************************************************/
int min( const int a1, const int a2)
{
if (a1 < a2)
return a1 ;
else
return a2 ;
}
|
|
/*********************************************************************/
/* clear - remplie la variable (cptr) de (len) blancs. */
/* (void = pas de valeur en retour ==> procédure) */
/*********************************************************************/
void clear(char *cptr, const int len)
{
int i;
char *charptr;
charptr = cptr;
for (i = 0; i < len; i++, charptr++) *charptr = ' ';
}
/******************************************************************* */
/* Début du programme principal (argc = nombre de paramètres reçus) */
/* (argv = liste des paramètres) */
/******************************************************************* */
main(argc, argv)
int argc;
char *argv¬|;
{ ...... suite du code ...... }
|
|
il est possible de déclarer des strctures complexes,
cela ce fait en deux phases :
1/ déclaration de la structure théorique, il s'agit d'un "modèle".
Struct enreg
{
int numero ;
int qte ;
float prix ;
}
pour lui donner une existence réelle, il faut déclarer une variable
struct enreg article (article est une variable de "type" enreg)
pour manipuler le prix on écrit article.prix
|
|
Les concepts de la programmation orientée objet utilisent ces principes: Il s'agit de déclarer un nouveau type d'entité (un objet) Qui regoupe la définition de donnée(s) et les procédures associées dans une même structure (on parle d'ENCAPSULATION) Les données gardent le nom de VARIABLES. les procédures associées aux données sont appellées METHODES. les données sont "protégées", le seul moyen d'y acceder (en lecture comme en écriture) est d'utiliser leurs méthodes. | \ Ajouter / | OBJET: | \ / | | Données: | CDECLI | lister N° client article | | date quantité livrer | (commande client | | | / \ | | / Modifier \ | |
|
Les objets dialoguent entre eux par l'intermédiaire de messages un message demande à un objet l'exécution d'une de ces méthodes ex: cdecli.lister Si une méthode à besoin d'informations complémentaires elles seront fournies sous forme de paramètres. ex: cdecli.ajouter(4015, A1, 10/12/94, 132,25) (ici la méthode "ajouter" calcule le n° de commande) Il arrive qu'un type d'objet soit réutilisé plusieurs fois. on va alors définir un type d'objet une fois : on parle de CLASSE. et définir plusieurs entités utilisant cette structure : on parle d'INSTANCES. |
|
Une classe d'objet pouvant être définie par rapport à une classe existante. On parle de HIERARCHIE de classes.(qu'il faudra donc connaître !!!) Une classe définie par rapport à une classe existante, bénéficie automatiquement de toutes ces méthodes. C'est l'HERITAGE. exemple: soit une classe commande (classe générique ou banalisée) soit une classe cdecli instance de la classe commande cdefour instance de la classe commande Si il a été définit au niveau de la classe commande, les méthodes: ajouter, solder, modifier, ces méthodes sont aussi attribuées aux instances cdecli, cdefour. Les instances peuvent avoir des méthodes qui leur soient propres (fonction de liste, par exemple) |
|
Il pourrait paraître plus judicieux de définir une méthode "lister" au
niveau de la classe "PARENTE" (ici commande)
et (tout en héritant de cette méthode) de redéfinir les PARTICULARITES
au niveau de chaque instance.
la méthode portera donc le même nom ("lister") tout en ayant une exécution
propre à la classe cdecli ou cdefour. ON parle de SURCHARGE.
Si vous avez besoin de redéfinir, pour une instance donnée, non pas les
méthodes, mais les variables sur lesquelles ces méthodes vont être
appliquées, on emploie alors le terme de POLYMORPHISME.
les méthodes devant être capables de travailler sur des données de "forme"
différentes.
C'est un concept très utilisé dans le monde scientifique, probablement
moins justifié dans le monde de la gestion.
|
|
Un PEU DE CONCRET: C'est en parties le compilateur qui travaille, (probablement la raison de l'apparition des compilateurs ILE) mais une partie des références est résolue à l'exécution (voir *SRVPGM), ce qui implique des machines puissantes (POWER-PC) Une classe définie les variables, les méthodes. Une instance POSSEDE les valeurs des variables. lors de la demande de l'exécution d'une méthode, le compilateur regarde si la méthode a été définie au niveau de l'instance, s'il ne la trouve pas il va chercher auprès de la classe parente et remonte ainsi la hiérarchie. La programmation orientée objet doit être conçue dans le but de traiter les exceptions: - remonter les méthodes au niveau le plus élevé - ne surcharger que lorsque nécessaire. |
|
ATTENTION: les classes livrées avec un compilateur sont forcéments génériques (généralistes), il faudra surcharger tout le temps. Il faudra un temps d'adaptation 1/ à la philosophie objet 2/ à la hiérarchie de classes livrées et à leurs méthodes probablement non négligeable ! Un petit exemple avec turbo-pascal pour Windows. (TPW) |
|
hiérarchie des objets TPW: TOBJECT ! !--TApplication: Méthodes INIT initialise l'environnement nécessaire ! à l'exécution d'un pgm sous windows ! initialise l'objet MainWindow ! via la méthode InitMainWindow ! RUN exécute l'application, affiche la fenêtre ! DONE détruit l'environnement ! !--TWindowsObject ! !--TDialog (définit les boites de dialogue) ! !--TWindows (définit une fenêtre de l'application) ! MainWindow est une instance de TWindow ! ! méthodes INIT définit les caractéristiques de la fenêtre ! et l'initialise. !-- ... etc ... |
|
PROGRAM P1;
USES Wobjects; (* déclaration de la bibilothèque contenent toutes les
classes TPW *)
VAR
monprog:TApplication (* objet générique[racine] des classes TPW *)
BEGIN
monprog.init('nom-interne') (* initialisation de la fenêtre *)
monprog.run (* affichage: vide,sans titre, taille/dft *)
monprog.done (* fin *)
END.
Nous avons réutilisé la classe TApplication qui dans sa méthode init
à initilisée un objet MainWindow dont la méthode InitMainWindow crée une
fenêtre vide, sans titre avec une taille et des positions standards.
les trois méthodes seront toujours employées dans le programme principal
init: initialise l'application et lui attribut un nom interne
run : exécute (et affiche le cas echéant)
done: libère la mémoire et arret.
|
|
Si nous voulons attribuer à cette fenêtre un titre significatif il faut surcharger la méthode InitMainWindow (la doc est indispensable) en utilisant directement la méthode Init de l'objet TWindow (qui était exécutée implicitement par monprog.init) et qui attend deux paramètres 1/ pointeur de la fenêtre mère 2/ titre de la fenêtre. Si nous voulons attribuer à cette fenêtre une taille spécifique il faut définir notre propre objet fenêtre, en tant qu'instance de TWindow et écrire la procédure init qui va utiliser TWindow.init en attribuant aux différents paramètres les valeurs souhaitées. (positions angle supérieur gauche, largeur, hauteur, en pixels) Comme vous le voyez, utiliser un compilateur orienté objet cela suppose 1/ une parfaite connaissance de la philosophie OBJET 2/ une parfaite connaissance des classes utilisées qu'elles aient été livrées avec le compilateur, achetées, OU BIEN MEME DEVELOPPEES EN INTERNE. |
|
Vous pouvez vous affranchir d'une partie de ces contraintes en utilisant un outil de devellopement évenementiel. Vous pourrez alors définir l'interface de manière graphique et associer à des couples "objet graphique/action utilisateur" un sous programme. (Aujourd'hui DELPHI, le successeur de TPW, est un produit de ce type) ATTENTION : ne pas confondre un produit basé objet : on utilise des objets, mais on ne peut pas créer ces propres objets (L'OS/400 est de cette famille) Visual Basic par exemple (ou CA-Realizer) et un produit orienté objet (on utilise et on créé[ou on achète] ses propres objets) |
|
Les compilateurs orientés objets les plus répandus sont: C++ : considéré comme Hybride par les puristes, la POO étant une couche supplémentaire par rapport au C classique. (le microcode[SLIC] de l'OS/400 V3R60 serait écrit en C++) c'est souvent le compilateur des systèmes ou des produits réseaux. PASCAL : l'exemple le plus convaincant est DELPHI. (là aussi la couche objet est en partie une surcouche, la légende veut que DELPHI aie été écrit en DELPHI) SMALLTALK : langage purement objet (conçu comme tel) d'origine DIGITAL. C'est actuellement le langage utilisé par VISUALAGE. Plus des produits de deuxième génération (L4G de 2ème génération) comme OBSYDIAN de SYNON. |
|
Un certain nombre de constructeurs se sont regroupés pour définir un norme concernant les objets , "CORBA", contenant : S O M = System Object Model et D S O M = Distributed System Object Model (la partie interface publique est normalisée : il s'agit des IDL qui sont les déclarations des méthodes de l'objet au format texte) C++ pour AS/400 fait partie de cette famille ILE/RPG-IV saura un jour ou l'autre manipuler des objets écrits en C++ (pour information, la V3R60 a étée écrite en C++) MicroSoft propose sa propre vision avec OLE et ActiveX. |
|
la langage qui "monte" actuellement, c'est JAVA. JAVA est un langage écrit par SUN (société du monde UNIX) Il es basé sur le langage C, tout en éliminant ses défauts. Il possède les caractéristiques suivantes : Il est stocké sous la forme binaire est est interpréte par un "Run-Time" qu'on appelle Java Virtual Machine. cela a pour effet de le rendre indépendant des plateformes Il est orienté objet (les classes JAVA) et accepte l'héritage il posséde des extensions multimédia marquées il peut être intégré dans une page HTML (le WEB), téléchargé sur le client et exécuter par le programme d'affichage internet (le "browser"), une partie de code ainsi exécutée est appellée un APPLET. |
|
On parle aussi de plus en plus de BASE DE DONNEES ORIENTEES OBJET (SGBDOO) L'encapsulation se faisant non plus au niveau des programmes, mais des données. (on associe aux données des méthodes lors de la création de la table) La plus ancienne est O2. DB2 semble y venir. Intégrité référentielle et Trigger vont dans ce sens. Après le tout client/serveur, on propose des architectures recentralisant de plus en plus de logique sur les serveurs. (vision "ORACLE par opposition à la vision "MICROSOFT") JAVA et INTRANET apportent de l'eau à ce moulin .... |
