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

Jean Luc Baptiste

La P.O.O. : Les classes composées de tableaux d'objets. Création de classes. Instanciation dynamique d'objets. Utilisation des tableaux. Un peu d'UML. ♪

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

- Auteur : Jean Luc Baptiste

- Parution : 27 novembre 2008

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2008 Jean Luc Baptiste. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction:

- II. Voyons un peu du côté d'UML

I - Introduction:

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.

II - Voyons un peu du côté d'UML

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.

Relation de composition

Objet liv1Objet agt1 Tableau d'Objets Tableau d'Objets.Objets instances de CompteObjets instances de Page

Les objets du tableau n'existent pas en dehors de l'objet liv1. Les objets du tableau sont inclus dans l'objet liv1.

Relation d'association ou d'agrégation

Les objets comptes et l'objet agt1 ont une existence indépendante.Mais ils sont liés.

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