La P.O.O : Les classes composées de tableaux d'objets

On souhaite gérer les comptes bancaires des agences d'une banque.

Une agence gère plusieurs comptes et un compte est géré par une seule agence.

Réalisons le diagramme de classes relatif à cet exemple :

Nous avons vu lors du cours précédent comment gérer dans une classe les multiplicités 1 ( = 1..1) et 0..1, c'est-à-dire comment gérer une référence à la classe Agence dans la classe Compte.

Nous allons voir dans ce cours comment prendre en compte les autres multiplicités (n, m..n, * ou 0..* et 1..*) dans une classe.

Comment représenter dans la classe Agence le fait qu'une agence gère plusieurs comptes ?

La classe agence va contenir un ensemble de références d'objet. Nous allons choisir de représenter cet ensemble par un tableau de références d'objets dans un premier temps puis nous verrons qu'il est possible d'utiliser une collection de références d'objets.

La relation peut être une relation d'association comme la relation Agence-Compte , une relation d'agrégation ou de composition. La multiplicité « plusieurs » sera gérée de manière presque identique.

L'association représente des relations structurelles entre classes : elle possède un nom qui symbolise l'association.

L'agrégation est une relation particulière où une classe joue un rôle prépondérant. Elle traduit une relation d'appartenance. C'est-à-dire le fait qu'un objet de la classe est composé d'un ou plusieurs objets d'une autre classe.

La composition est une agrégation particulière : la vie du composant est liée à celle du composé. L'objet composant a la même durée de vie que le composé.

Exemple d'agrégation : un PC est composé de plusieurs disques durs.

Exemple de composition : un livre est composé de plusieurs pages.

N.B. : seul le ^2e cas sera étudié dans ce cours.

Rappel sur la navigabilité

Dans une relation, on peut en général naviguer d'une classe à l'autre. Il est parfois nécessaire à une étape de la conception d'indiquer que la navigabilité n'est plus bidirectionnelle. Dans notre exemple, il est nécessaire que l'agence connaisse les comptes qu'elle gère, mais il n'est pas nécessaire que le compte connaisse l'agence qui le gère. Ce choix est représenté par une navigabilité restreinte.

Voyons comment définir et utiliser les classes décrites dans ce diagramme de classe.

Soit la classe Compte suivante :

classe Compte
privé 
    numéro : entier
    solde : réel
public
    procédure Init(entrée numéroSai : entier )//initialise les données du compte
    procédure Créditer(entrée montantSai : réel)//crédite le compte du  montant  
    procédure Débiter(entrée montantSai : réel)//débite le compte du  montant  
    fonction GetNum() : entier       //retourne le numéro du compte
    fonction GetSolde() : réel        //retourne le solde du compte
fin classe

La classe Agence :

classe Agence
privé 
    nom : chaîne
    lesComptes : tableau [1..100] de Compte 
    nbCpt : entier
public
    procédure Init(nom : chaîne)//initialise les données de l'agence
    fonction GetNom() : chaîne//retourne le nom de l'agence
    fonction GetNbCpt () : entier//retourne le nombre de comptes gérés par l'agence
    fonction ExisteNumCpt (numCpt : entier) : booléen//retourne vrai si le numéro 
    //de compte existe, faux sinon
    fonction ExisteCpt (cpt : Compte) : booléen //retourne vrai si le compte existe,
    //  faux sinon
    fonction AjoutCpt(cpt: Compte) : booléen // ajoute le compte si le compte 
    // n'existe pas déjà dans le tableau et s'il 
    // reste de la place dans le tableau.
    // retourne vrai si le compte a pu être ajouté,
    // retourne faux sinon.
    Procédure Listecompte()// Donne des information sur les comptes.
fin classe

Voilà, la théorie est posée, maintenant vous allez passer à la pratique.

Créez un nouveau projet nommé Tpobjet8-3, il ne comporte aucune analyse. Ensuite définissez les classes Compte et Agence. Créez les attributs et méthodes de chaque classe (vous écrirez le code des méthodes plus tard).

Voici la seule fenêtre du projet (nommée départ) :

La zone « Agence » contient :

un champ de saisie nommé : NomAgence ;

un champ de saisie nommé : NbComptes ;

un bouton nommé : BcréerAgence.

La zone « Création de comptes » contient :

un champ de saisie nommé : Numducompte1 ;

un champ de saisie nommé : Numducompte2 ;

un bouton nommé : BcréerCompte1 ;

un bouton nommé : BcréerCompte2.

La zone Opération sur compte1 contient :

un champ de saisie nommé : CréditCompte1 ;

un champ de saisie nommé : DébitCompte1 ;

un champ de saisie nommé : Vsolde1 ;

un bouton nommé : BcréditerCompte1 ;

un bouton nommé : BdébiterCompte1.

La zone Opération sur compte2 contient :

un champ de saisie nommé : CréditCompte2 ;

un champ de saisie nommé : DébitCompte2 ;

un champ de saisie nommé : Vsolde2 ;

un bouton nommé : BcréditerCompte2 ;

un bouton nommé : BdébiterCompte2 ;

et enfin un Bouton nommé : BvérifCompte.

Vous arriverez à vous y retrouver ? Je pense quoi vous avez compris le rôle de cette fenêtre, nous allons créer un objet agence et deux objets compte qui vont êtres manipulés par certaines méthodes de la classe agence et contenus dans un tableau d'objet compte dynamique.

Passons au code de la classe agence 

La classe Agence contient trois attributs.

Nom a qui nous passerons le nom de l'agence

LesComptes est un tableau d'objets Compte, il est déclaré dynamique pour que ce soit la référence des objets compte qui soit inscrite dans le tableau et non une recopie des valeurs. Le gros avantage c'est que si l'objet est modifié hors tableau ses valeurs dans le tableau seront à jour. Le tableau contient l'adresse de l'objet et non une copie de l'objet.

Plutôt que d'utiliser le constructeur, une méthode Init a été créée. Elle récupère le nom de l'agence et l'affecte à l'attribut privé Nom, elle initialise NbCpt ( le compteur de compte) à zéro.

On trouve ensuite deux accesseurs GetNom et GetNbCpt, je pense que vous comprenez leur usage !

Cette méthode ExisteNumCpt recherche dans le tableau d'objet « LesComptes » si un numéro de compte existe déjà. Remarquez ceci « :LesComptes[ind]:GetNum()=Numcpt ».

La méthode GetNum() de l'objet à l'indice [ind] du tableau d'objet est activée. C'est hyper élégant la programmation objet, vous ne trouvez pas ?

La méthode ExisteCpt a un fonctionnement différent de la méthode ExisteNumCpt pour un résultat identique. Je vous laisse la comprendre.

La méthode Ajoutecpt ajoute un objet compte dans le tableau d'objet compte.

La méthode Listecompte scanne le tableau et affiche le détail de chaque compte.

Voilà pour la classe Agence, voici la classe Compte.

Rien de particulier pour la déclaration de la classe. Ni pour les deux accesseurs ci-dessous.

Ces trois méthodes permettent :

l'initialisation des attributs numéro et solde ;

créditer le compte d'un montant passé en paramètre ;

débiter le compte d'un montant passé en paramètre.

Les classes sont maintenant définies voyons dans le code de la fenêtre comment les mettre en ouvre.

Il faut déclarer les objets de façon globale à la fenêtre :

Comme vous le voyez les deux objets compte sont dynamiques, donc on travaille dessus par référence et non par valeur.

Voici maintenant, tous les codes de la fenêtre. Je vous laisse coder.

Maintenant vous pouvez lancer le projet.

Saisissez un nom d'agence par exemple : « Agence Oncle Picsou » et cliquez sur le bouton Créer l'Agence.

Saisissez un numéro de compte pour le premier et un autre pour le second, puis cliquez sur les deux boutons de création des comptes.

Je vous laisse débiter ou créditer les comptes selon vos préférences. N'oubliez pas la vérification des comptes.

Pour tester la différence entre le passage par référence ou par valeur enlevez "dynamique" à la définition du tableau dans la classe agence. Relancer le projet, mettez les valeurs vérifiez les comptes et oupssss !!

Note pour les puristes, j'aurais pu faire différemment, n'avoir qu'un seul objet compte et le copier par valeur dans le tableau.

Merci à ceux sur le forum « fr.comp.developpement.agl.windev » qui m'ont donné des éclairages sur certains points objets théoriques