Introduction à Objecteering 6 Enterprise Edition

Ensuite, nous ajoutons les attributs de classe de notre classe Client en cliquant sur l'icône et en nous positionnant sur notre classe.

Concernant un attribut, nous pouvons lui spécifier un nom, un type (les types UML 2.0 à savoir String, Integer, Boolean, etc.), une taille, sa visibilité et son mode d'accès. Le mode d'accès étant utile par la suite lorsque l'on souhaite que des accesseurs soient générés automatiquement dans le code. Nous retrouvons de même les onglets décrits auparavant avec les mêmes fonctions.

De cette manière, nous passons de la classe Client ci-dessus, à la classe Client identique ci-dessous, mais avec les visibilités de classe et attributs (et méthodes pas encore réalisées) affichées :

Passons à l'ajout de méthode pour notre classe Client. Pour cela, faire comme l'ajout d'attribut en utilisant l'icône .

La première opération que nous allons ajouter est le constructeur de classe. Après avoir cliqué sur l'icône d'ajout d'opération, une fenêtre nous propose de nommer l'opération. Dans ce cas, celle-ci porte le nom de la classe. Enfin, pour spécifier que cette opération est un constructeur, il nous faut cocher la spécificité « create » comme suit :

Il est possible de distinguer une fois créés les constructeurs par une icône verte présentant un « C() » dans notre explorateur à gauche.

Pour l'ajout de paramètres d'entrée, il nous faut cliquer sur l'icône et pour les paramètres de retour l'icône . Nous ajoutons donc les paramètres d'entrée à notre constructeur :

Exemple de paramètres de retour (afin de voir la syntaxe sur notre diagramme de classe) :

Pour afficher sur votre diagramme les spécificités de certaines opérations comme les constructeurs, comme pour l'affichage des visibilités, nous effectuons un clic droit>Representation options>Stereotype representation>Text comme suit :

Il s'affiche alors sur chaque constructeur « create ».

Pour une opération « classique », c'est le même principe, mis à part qu'il ne faut pas cocher la case « create ». Nous ajoutons donc de cette manière les opérations ajouterArticle(integer prixArticle) et supprimerArticle(integer prixArticle).

Dernière remarque concernant les opérations et passage de paramètres, pour passer un paramètre de type object de classe, il nous suffit d'ajouter un paramètre d'entrée comme décrit précédemment, mais cette fois de sélectionner la classe qui nous intéresse :

Ce qui donne ceci dans notre diagramme de classe :

Concernant les relations, Objecteering propose le panel suivant, sachant que certaines se déclinent en d'autres relations :

Notre petit projet ne comporte que des associations, mais cela reste le même principe pour tous les autres types de relations. Nous construisons donc une association entre notre classe Client et notre classe HistoriqueMouvement du panier. Pour cela, nous utilisons l'icône . Nous lions donc les deux classes de Client vers HistoriqueMouvement, car c'est le client qui a besoin des services de cette classe et non l'inverse (de plus nous verrons qu'une fois le code généré, le sens a une réelle importance). Enfin, nous spécifions les multiplicités, les rôles ainsi que le nom de l'association en double cliquant sur le lien créé :

Notre relation une fois créée correspond à ceci :

Voici donc notre diagramme de classe complet après modélisation :

Notre génération de code se fera dans le langage JAVA. Pour cela, nous devons déployer comme précédemment le module nécessaire : Tools> Deploy an MDAC>Generators>JavaDeveloper_v4.1.35.mdac. Une fois déployé, ce module nous donne accès à une nouvelle icône dans notre barre d'outils de l'explorer UML . Nous cliquons sur cette icône afin de spécifier le chemin de destination des fichiers java générés :

Ensuite nous lançons la génération de code java de cette manière :

Voici en guise d'exemple, le fichier Client.java qui a été généré automatiquement :

import com.softeam.objecteering.javadeveloper.annotations.objingid;
import java.util.List;
import java.util.ArrayList;
 
@objingid ("862453768:9")
public class Client 
{
    @objingid ("862453768:12")
    private int numClient;
    public int getNumClient () {
        return this.numClient;
    }
    public void setNumClient (int value) {
        this.numClient = value; 
    }
 
    @objingid ("862453768:17")
    private String nomClient;
    public String getNomClient () {
        return this.nomClient;
    }
    public void setNomClient (String value) {
        this.nomClient = value; 
    }
 
    @objingid ("862453768:20")
    private String adresseClient;
    public String getAdresseClient () {
        return this.adresseClient;
    }
    public void setAdresseClient (String value) {
        this.adresseClient = value; 
    }
 
    @objingid ("862453768:22")
    private String prenomClient;
    public String getPrenomClient () {
        return this.prenomClient;
    }
    public void setPrenomClient (String value) {
        this.prenomClient = value; 
    }
 
    @objingid ("862453768:26")
    private int soldePanier = 0;
    public int getSoldePanier () {
        return this.soldePanier;
    }
    public void setSoldePanier (int value) {
        this.soldePanier = value; 
    }
 
    @objingid ("862453768:67")
    public List<HistoriqueMouvement> historiqueMouvement = new ArrayList<HistoriqueMouvement> ();
    public List<HistoriqueMouvement> getHistoriqueMouvement () {
        return this.historiqueMouvement;
    }
 
 
    @objingid ("862453768:28")
    public Client(
        int numClient,
        String nomClient,
        String prenomClient,
        String adresse,
        int solde)
    {
    }
 
    @objingid ("862453768:35")
    public void ajouterArticle(
        int prixArticle)
    {
    }
 
    @objingid ("862453768:37")
    public void supprimerArticle(
        int prixArticle)
    {
    }
}

Regardons de plus près ce code généré. Nous pouvons y voir des balises de type @objingid (« 862453768:9 »), celles-ci sont utiles sous Eclipse avec l'ajout d'une librairie bien spécifique. Mais pour compiler et exécuter ce code (sachant que personnellement je ne les utilise pas), je n'ai rien trouvé d'autre que toutes les supprimer.

Ensuite, nous pouvons voir que tous nos attributs spécifiés dans notre diagramme de classe sont déclarés ainsi que nos méthodes. Les accesseurs générés diffèrent selon le mode d'accès choisi lors de la création d'un attribut (Read, Write, ReadWrite).

Enfin, regardons de plus près cette ligne de code :

public List<HistoriqueMouvement> historiqueMouvement = new ArrayList<HistoriqueMouvement> ();

Cette ligne a été générée, car nous avions mis une relation d'association de Client vers HistoriqueMouvement. De cette manière, une ArrayList du type HistoriqueMouvement a été créée dans notre classe Client afin de disposer des services de la classe HistoriqueMouvement. Enfin, nous pouvons voir que les méthodes de classe que nous avions créées dans notre diagramme de classe sont déclarées, mais vides de code. Nous allons donc voir comment remédier à cela et compléter notre génération afin que celle-ci soit complète.

Nous allons voir dans un même temps l'ajout d'exception et les imports Java. À cette étape, tout se passe dans la fenêtre auxiliaire. Tous les affichages peuvent générer des exceptions de type IOException, c'est pourquoi nous allons ajouter cette exception pour chaque méthode de la classe AffichagePanier ainsi que l'import java.io.* à cette même classe. En ce qui concerne les exceptions, il nous faut sélectionner une méthode, puis nous rendre dans l'onglet java de notre fenêtre auxiliaire. Nous pouvons y voir un champ Throws exception. C'est la que nous allons saisir toutes les exceptions que nous souhaitons ajouter à notre méthode (cette action est à réaliser pour chaque méthode) :

Ensuite, nous allons ajouter un import à notre classe Affichage Panier comme suit.

Il nous suffit de remplir le champ import. Voyons un petit extrait de code généré de la classe AffichagePanier afin de voir les modifications apportées :

import com.softeam.objecteering.javadeveloper.annotations.objingid;
import java.util.List;
import java.util.ArrayList;
import java.io.*;
 
@objingid ("862453768:11")
public class AffichagePanier 
{
    @objingid ("862453768:70")
    public List<Client> client = new ArrayList<Client> ();
    public List<Client> getClient () {
        return this.client;
    }
 
 
    @objingid ("862453768:40")
    public AffichagePanier()
    {
    }
 
    @objingid ("862453768:41")
    public int choixAction()
        throws IOException
    {
    }
 
    @objingid ("862453768:43")
    public int choixArticle()
        throws IOException
    {
    }

Passons au corps de nos méthodes. Le moyen n'est pas du plus adéquat, car il n'y a pas de coloration syntaxique ni une quelconque aide pour le développeur. En effet, pour implémenter le corps d'une méthode, par exemple le constructeur de la classe Client, nous cliquons sur celle-ci puis nous utiliserons l'onglet implémentation puis le bouton add. Nous spécifions le type JavaCode et nous pouvons saisir le corps de notre méthode dans la fenêtre suivante avant de le valider :

Une fois l'implémentation de la méthode effectuée, nous pouvons voir que celle-ci reste visible dans notre onglet implémentation :

Il est possible de saisir le code d'une méthode d'une autre manière, mais beaucoup moins pratique. Pour cela il faut se rendre dans la fenêtre auxiliaire, onglet java, nous disposons d'un champ spécifique comme suit (personnellement je ne m'en sers jamais à part pour avoir un bref aperçu) :

Enfin, dans notre cas, afin de tester notre petit programme, nous avons ajouter une méthode main. Pour cela, nous avons sélectionné la classe AffichagePanier puis dans la fenêtre auxiliaire, onglet java, il nous suffit de cocher la case « main » :

Regardons notre classe AffichagePanier dans son intégralité après avoir ajouté chaque corps de méthode, un main, les exceptions et import souhaités et bien entendu régénérés le code java.

import com.softeam.objecteering.javadeveloper.annotations.objingid;
import java.util.List;
import java.util.ArrayList;
import java.io.*;
 
@objingid ("862453768:11")
public class AffichagePanier 
{
    @objingid ("862453768:70")
    public List<Client> client = new ArrayList<Client> ();
 
    public List<Client> getClient () {
        return this.client;
    }
 
 
    @objingid ("862453768:40")
    public AffichagePanier()
    {
    }
 
    @objingid ("862453768:41")
    public int choixAction()
        throws IOException
    {
        int op;
 
        System.out.println("Entrez le type d'opération,Ajouter article: 1 sinon Supprimer Article:2");
        String read = null ;
        boolean ok = false ;
        do{
            try{
                    InputStreamReader lec = new InputStreamReader (System.in) ;
                BufferedReader entree = new BufferedReader (lec) ;
                read = entree.readLine() ;
                ok = true;
                }
            catch (IOException err){
                ok = false ;
            }
        }
        while(!ok);
        op=Integer.parseInt(read) ;
        return op;
    }
 
    @objingid ("862453768:43")
    public int choixArticle()
        throws IOException
    {
        int mt;
 
        String read = null ;
        boolean ok = false ;
        do{
            try{
                InputStreamReader lec = new InputStreamReader (System.in) ;
                 BufferedReader entree = new BufferedReader (lec) ;
              read = entree.readLine() ;
              ok = true;
                  }
            catch (IOException err){
                ok = false ;
            }
          }
          while(!ok);
         mt=Integer.parseInt(read) ;
        return mt;
    }
 
    @objingid ("862453768:47")
    public void afficherSoldePanier(
        Client client)
        throws IOException
    {
        System.out.println("Information concernant le panier client");
        System.out.println("numClient="+client.getNumClient());
        System.out.println("solde du panier ="+client.getSoldePanier());
    }
 
    @objingid ("862453768:50")
    public void afficherMouvementPanier(
        Client client)
        throws IOException
    {
        String s;
        System.out.println("Historique des mouvements du panier client:"+client.getNumClient());
        System.out.println("solde du panier="+client.getSoldePanier ());
 
        for (int i=0;i<client.historiqueMouvement.size();i++)
        {
            if (client.historiqueMouvement.get(i).isMouvementArticle())
            {s="+";    }
            else
            {s="-";    }
            System.out.println(s+ " "+client.historiqueMouvement.get(i).getPrixArticle());
        }
    }
 
    @objingid ("862453776:42")
    public static void main(
        String[] argv)
        throws IOException
    {
        AffichagePanier ap=new AffichagePanier();
           Client c=new Client(1234,"martin","Toto","15 Rue des tests");
 
        ap.client.add(c);
        for (int z=0;z<2;z++)
        {
            ap.afficherSoldePanier(ap.client.get(z));
            for (int j=0;j<2;j++)
            {
                int op=ap.choixAction();        
                if (op==1)
                {
                    System.out.println("Prix de l'article à ajouter:");    
                    int mt=ap.choixArticle();    
                    ap.client.get(z).ajouterArticle(mt);
                }
                if (op==2)
                {
                    System.out.println("Prix de l'article à supprimer:");
                    int mt=ap.choixArticle();
                    ap.client.get(z).supprimerArticle(mt);
                }
            }
            ap.afficherSoldePanier(ap.client.get(z));
            ap.afficherMouvementPanier(ap.client.get(z));
        }
 
    }
}