Chapitre VII: Préparation de l’implémentation partie 2: uml vers Java

Ce document présente les règles de passage du langage de modélisation UML vers le langage Java, en se concentrant sur la transformation des éléments du diagramme de classes de conception en code Java. Il s’adresse aux étudiants et développeurs souhaitant comprendre comment traduire une modélisation UML en une implémentation Java cohérente.

Règles de passage : Les Packages

En UML, les packages permettent de regrouper des classes et d’organiser le modèle. En Java, un package correspond à une déclaration package en début de fichier, et les imports permettent de référencer d’autres packages.

UML
package catalogue;
…

package bibliotheque;
import catalogue;

JAVA
package catalogue;
…

package bibliotheque;
import catalogue;

Règles de passage : Les classes

Les classes UML se traduisent directement en classes Java. Les classes abstraites et interfaces UML correspondent respectivement aux classes abstraites et interfaces Java.

UML

public class Personnel {
…
}

public abstract class Agent {
…
}

public interface Irecipient {
}

JAVA

public class Personnel {
…
}

public abstract class Agent {
…
}

public interface Irecipient {
}

Règles de passage : Attributs et méthodes

Les attributs UML avec leurs visibilités et types sont traduits en attributs Java avec les modificateurs d’accès correspondants. Les valeurs par défaut sont traduites en initialisations statiques si nécessaire. Les méthodes UML sont traduites en méthodes Java avec leur signature et corps.

UML

Personnel
+matricule:String
-nom:String
-prenom:String
-ageMin:int=18
#Adresse:String

+calculerDureePret():int
+getAge():int

JAVA

public class Personnel {

    public String matricule;
    private String nom;
    private String prenom;
    private static int ageMin = 18;
    protected String Adresse;

    public int calculerDureePret() {
        // corps de la méthode
    }

    public int getAge() {
        // corps de la méthode
    }
}

Règles de passage : Associations binaires

Associations bidirectionnelles

Une association bidirectionnelle entre deux classes se traduit par une paire de références, une dans chaque classe. Les noms des rôles aux extrémités de l’association servent à nommer les variables de type référence.

UML

Homme
+Id_homme:int
mari 0..1
epouse 0..4

Femme
+Id_femme:int

JAVA

public class Homme {
    public int IdHomme;
    private Femme[] epouse = new Femme[4];
    // autres membres
}

public class Femme {
    public int IdFemme;
    private Homme mari;
    // autres membres
}

Associations navigables

Les associations navigables se traduisent par des références dans la classe qui "navigue" vers l’autre, en tenant compte de la multiplicité.

UML

Personnel
private Rapport[] lesRapports;

JAVA

public class Personnel {
    private Rapport[] lesRapports;
    // autres membres
}

public class Rapport {
    private Personnel lePersonnel;
    // autres membres
}

Association réflexive

Une association réflexive, où une classe est associée à elle-même, se traduit par une référence vers un objet de la même classe.

JAVA

public class Personne {
    private Personne[] subordonne;
    private Personne chef;
    // autres membres
}

Règles de passage : Associations particulières

Généralisation

Le concept UML de généralisation correspond directement à l’héritage en Java.

UML

Personnel
-matricule:String
-nom:String
-prenom:String
#Adresse:String

Comptable
-iD:int

JAVA

public class Personnel {
    private String matricule;
    private String nom;
    private String prenom;
    protected String Adresse;
}

public class Comptable extends Personnel {
    private int iD;
}

Agrégation

L’agrégation est traduite par une relation où une classe contient une collection d’objets d’une autre classe.

JAVA

public class Association {
    private List<membre> membres;
}

public class Membre {
    // membres de la classe
}

Composition

La composition est une relation forte où la classe contenant crée et détruit l’objet contenu. En Java, cela se traduit par une instanciation dans le constructeur.

JAVA

public class Voiture {
    private Moteur moteur;

    public Voiture() {
        moteur = new Moteur();
    }
}

public class Moteur {
    // membres de la classe
}

Réalisation

Une classe UML peut implémenter plusieurs interfaces. En Java, cela se traduit par l’implémentation des interfaces avec le mot-clé implements.

JAVA

public class Livre implements IImprimable, IEmpruntable {

    private String titre;
    private String auteur;
    private ISBN isbn;

    public void imprimer() {
        // corps de la méthode
    }

    public void emprunter() {
        // corps de la méthode
    }

    public void retourner() {
        // corps de la méthode
    }
}

Réalisation avec utilisation (use)

Une classe peut utiliser une interface en créant une instance d’une classe qui l’implémente.

JAVA

public interface IUsine {
    // méthodes de l'interface
}

public class Usine implements IUsine {
    // implémentation des méthodes
}

public class Client {
    IUsine u1 = new Usine();
    // autres membres
}

Exemples d’outils de génération de code

• Papyrus UML (Eclipse Public Licence, multiplateforme) : génération de code en Java, C++ (avec CDT d’Eclipse) et Ada.
• StarUML (GPL, Windows uniquement) : génération de code en C++, C# et Java.
• ArgoUML (Eclipse Public Licence, multiplateforme) : génération de code en Java, C++, C# et PHP.
• Open ModelSphere (GPL, multiplateforme) : capable de générer du code Java à partir du diagramme de classes.

Glossaire des termes clés

• Package : Regroupement logique de classes en UML, traduit en package Java.
• Classe abstraite : Classe qui ne peut pas être instanciée directement, traduite par abstract class en Java.
• Interface : Contrat définissant des méthodes sans implémentation, traduit par interface en Java.
• Attribut : Propriété d’une classe, avec visibilité et type, traduite en variable d’instance Java.
• Méthode : Fonction membre d’une classe, traduite en méthode Java.
• Association binaire : Relation entre deux classes, traduite par des références dans chaque classe.
• Association réflexive : Association d’une classe avec elle-même, traduite par une référence vers un objet de la même classe.
• Généralisation : Relation d’héritage entre classes, traduite par extends en Java.
• Agrégation : Relation où une classe contient une collection d’objets d’une autre classe.
• Composition : Relation forte où la classe contenant crée et détruit l’objet contenu, traduite par instanciation dans le constructeur.
• Réalisation : Implémentation d’une interface par une classe, traduite par implements en Java.

Points clés à retenir

• Les packages UML se traduisent directement en packages Java avec déclaration et import.
• Les classes, abstraites ou interfaces UML, correspondent aux mêmes concepts en Java.
• Les attributs et méthodes UML sont traduits en variables et méthodes Java avec leurs visibilités et types.
• Les associations binaires se traduisent par des références dans les classes concernées, selon la navigabilité et multiplicité.
• L’héritage UML est directement traduit par l’héritage Java via extends.
• L’agrégation et la composition sont traduites par des relations d’objets et instanciations dans les classes Java.
• Les interfaces UML sont implémentées en Java avec implements, et une classe peut en implémenter plusieurs.
• Des outils comme Papyrus UML, StarUML, ArgoUML et Open ModelSphere facilitent la génération automatique de code Java à partir de diagrammes UML.