De UML vers Java

Ce document présente la traduction des concepts UML en code Java. Il s’adresse aux étudiants et développeurs souhaitant comprendre comment passer d’un modèle UML à une implémentation Java, en couvrant les classes, attributs, méthodes et associations.

Traduction des classes

Chaque classe UML devient par défaut un fichier .java contenant la définition de la classe en Java.

Exemple :

class Personne {
    ...
    ...
    ...
}

Une classe abstraite en UML est une classe qui ne s’instancie pas directement mais sert à factoriser des propriétés communes. Elle est notée avec le mot-clé abstract en UML et se traduit par le mot-clé abstract en Java.

Exemple :

abstract class Personne {
    ...
    ...
}

Une interface UML est une classe spéciale dont toutes les méthodes sont abstraites. En Java, elle est traduite par le mot-clé interface. Pour implémenter une interface, on utilise le mot-clé implements.

Exemple :

interface Forme {
    ...
    ...
    ...
}

class Rectangle implements Forme {
    ...
}

Traduction des attributs

Les attributs UML deviennent des attributs en Java. Leur type peut être un type primitif (comme int) ou une classe.

La visibilité des attributs est traduite comme suit :

• + (public) → public en Java
• # (protégé) → protected en Java
• - (privé) → private en Java

Les attributs de classe en UML deviennent des membres statiques en Java, c’est-à-dire marqués avec le mot-clé static.

Traduction des méthodes

Les méthodes UML se traduisent directement en méthodes Java. Leur visibilité suit les mêmes conventions que pour les attributs.

Les opérations de classe deviennent des méthodes statiques (static).

Les opérations abstraites (indiquées en italiques en UML) se traduisent par le mot-clé abstract en Java.

Exemple :

class Personne {
    private int code;
    private String nom;
    private static int nombre;

    public Personne() {
    }

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

    public String getInf() {
        // corps de la méthode
    }
}

Traduction des associations

La généralisation

La généralisation en UML se traduit directement par le mécanisme d’héritage en Java.

Remarque : Contrairement à C++, Java interdit l’héritage multiple entre classes.

Exemple :

class Personne {
    ...
}

class Employe extends Personne {
    ...
}

Associations navigables

La traduction d’une association navigable dépend de la multiplicité de l’extrémité concernée (celle pointée par la flèche) :

• Une multiplicité 1 se traduit par une variable d’instance de type référence vers une instance de classe.
• Une multiplicité « * » se traduit par un attribut de type collection de références d’objets, au lieu d’une simple référence.

Associations bidirectionnelles

Une association bidirectionnelle se traduit par une paire de références, une dans chaque classe impliquée dans l’association.

Les noms des rôles aux extrémités d’une association servent à nommer les variables de type référence.

Classe association

Une classe association possède les caractéristiques d’une association et d’une classe : elle peut porter des attributs qui se valorisent pour chaque lien.

Elle est traduite en une classe normale, à laquelle on ajoute des variables de type référence.

Exemple :

// Exemple non détaillé dans le document mais la classe association devient une classe Java normale avec des références

Glossaire des termes clés

• Classe abstraite : classe qui ne peut pas être instanciée directement, utilisée pour factoriser des propriétés communes, traduite par abstract class en Java.
• Interface : type spécial dont toutes les méthodes sont abstraites, traduite par interface en Java, implémentée avec implements.
• Attribut : propriété d’une classe, avec un type et une visibilité, traduite en attribut Java avec public, protected ou private.
• Méthode : opération d’une classe, avec visibilité et éventuellement statique ou abstraite.
• Héritage : mécanisme de généralisation, traduit par extends en Java.
• Association : relation entre classes, traduite par des références ou collections selon la multiplicité.
• Multiplicité : nombre d’instances liées dans une association (1 ou *), influençant la traduction en variable simple ou collection.
• Classe association : classe qui représente une association avec des attributs propres, traduite en classe Java normale.

Points clés à retenir

• Chaque classe UML devient un fichier .java avec une classe Java correspondante.
• Les classes abstraites et interfaces UML se traduisent respectivement par abstract class et interface en Java.
• La visibilité UML (+, #, -) se traduit par public, protected, private en Java.
• Les attributs et méthodes statiques UML deviennent static en Java.
• L’héritage UML se traduit par extends en Java, mais l’héritage multiple est interdit.
• Les associations navigables se traduisent en références ou collections selon la multiplicité.
• Les classes association sont transformées en classes Java normales avec des références.