Vous êtes sur la page 1sur 9

L'UML est un ensemble de diagramme utilisé lors de la conception des programmes et qui

permettent de faciliter la réalisations de ceux-ci. Celui dont je vais vous parler est le diagramme
de classe qui donne une idée des différentes classes qui seront utilisée et comment elles seront
intégrées les unes par rapport aux autres.

Commençons par le plus simple.

La classe:

Ca donne ceci en UML:

Et voici sa traduction en java:

public class Bateau{

La classe abstraite :

On pourrait croire que la représentation d'une classe et d'une classe abstraite sont les mêmes
mais détrompez-vous, le nom de la classe abstraite est écrit en italique. Mais étant donné que
cette différence est très "flagrante", on peut utiliser un stéréotype qui facilitera la lecture de la
classe.

La traduction en code donne:

public abstract class Vehicule{


}

La représentation des attributs (variables):

petite explication:

Les +, - et # indiquent la portée des variables. Le + signifie que la variable est publique. Le -
signifie que la variable est privée. Seule la classe dans laquelle elle se trouve peut y accéder
directement. Le # signifie que la variable est protected. Cela signifie que la variable est
impossible à atteindre directement sauf pour les classes filles de la fille.

Avant le : c'est le nom de la variable qui l'identifiera. Après le : c'est le type de la variable. Ce type
peut être un type primitif ou un type depuis une classe.

La traduction en code donne:

public class Bateau{


public int longueur;
private String nom;
protected Carburant diesel;
}

Les méthodes :

Petite explication :

On note aussi la portée de la méthode devant le nom de celle-ci.

Les méthodes sont toujours accompagnées d'une parenthère (). Dans la parenthèse, nous
trouverons les variables d'entrée de la méthode.

En code, ça donne ceci:

public abstract class Vehicule{


public abstract int acceleration();
public String setNom(String nom){
return nom;
}
}

Méthode et attributs mélangés :

En code ça donne :

public class Bateau{


private String nom;

public String setNom(String nom){


...
}
}

Les interfaces en UML (+ une méthode) :

Ou

En code, ça donne ceci:


public interface IMoteur{
public void explosion();
}

L'héritage (généralisation) :

En code ça donne ceci pour la classe enfant (la classe mère ne change pas) :

public class Bateau extends Vehicule{

Important : en java, une classe ne peut héritée que d'une seule classe. Cela signifie que vous ne
pourrez utiliser une flèche comme celle-ci entre deux classe.

Realisation en UML (implémentation d'interface dans une classe) :


En code ça donne:

public class Bateau implements IMoteur{

@override
public void explosion(){
...
}
}

L'interface reste inchangée. Une classe peut implémenter plusieurs interfaces.

Les dépendances:

La dépendance signifie qu'il y aura l'utilisation d'un objet à l'intérieur d'une méthode de la classe.

En code, ça peut se traduire de deux façons :

public class Bateau{


public void methode(){
Port amsterdam = new Port();
amsterdam.autreMethode();
} //l'objet Amsterdam disparaît à la fin de la méthode
}

Ou

public class Bateau{


public void methode(Port amsterdam){
amsterdam.autreMethode();
}
}

L'association directe :

Se traduit en code comme ceci :

public class Bateau{


private Port amsterdam;
}

L'association directe (suite) :


L'étoile * signifie qu'il y aura plusieurs fois l'objet Port dans la classe Bateau. Ca peut se traduire
en code de deux façons:

public class Bateau{


private Port[] TableauPort;
}

ou

public class Bateau{


private ArrayList<Port> ListPort;
}

L'association:

Ceci se traduit de cette façon :

Pour la classe Bateau:

public class Bateau{


private Port amsterdam;
}

Pour la classe Port :

public class Port{


private Bateau titanic;
}

L'aggrégation :
L'aggrégation signifie est "composé de". Elle se traduit :

public class Bateau{


private Port amsterdam;

public Bateau(Port nomPort){


amsterdam=nomPort;
}
}

La composition :

La composition est très proche de l'aggrégation mais diffère de cette dernière. Ainsi le code
donne ceci :

public class Bateau{


private Port amsterdam;

public Bateau(){
amsterdam = new Port();
}
}
La composition peut aussi traduire une classe interne:

public class Bateau{

private class Port{ //classe interne