Associations

Association simple

Un objet B (Opérateur) est associé à un objet A (Calcul).

Code Java équivalent

class Operateur{}

class Calcul{
  private Operateur b;
}

Association avec rôle

Un objet B (Opérateur) est associé à un objet A (Calcul) et son rôle est identifié sur le diagramme.

Code Java équivalent

class Operateur{}

class Calcul{
  private Operateur op;
}

Initialisation (possibilité 1)

Par un setter :

class Calcul{
  private Operateur op;
  public setOperateur(Operateur op){
    this.op = op;
  }
  public getOperateur(){return op;}
}

Initialisation (possibilité 2)

Par le constructeur :

class Calcul{
  private Operateur op;
  public Calcul(Operateur op){
    this.op = op;
  }
  public getOperateur(){return op;}
}

Initialisation (possibilité 3)

Au moment de l’instanciation :

class Calcul{
  private Operateur op;
  public Calcul(){
    op = new Operateur();
  }
  public getOperateur(){return op;}
}

Association bidirectionnelle

Deux objets sont liés l’un à l’autre:

chaque instance possède une référence vers l’autre instance.

Code Java équivalent

class Moteur {
  private Vehicule vehicule;
}

class Vehicule {
  private Moteur moteur;
}

Initialisation impossible !

Ce code ne fonctionne pas :

void init(){
  Moteur moteur ;
  Vehicule vehicule;

  //Vehicule n'est pas instancié:
  moteur = new Moteur(vehicule);
  vehicule = new Vehicule(moteur);
}

Initialisation (possibilité 1)

void init(){
  Moteur moteur ;
  Vehicule vehicule;

  moteur = new Moteur();
  vehicule = new Vehicule(moteur);
  moteur.setVehicule(vehicule);
}

Initialisation (possibilité 2)

void init(){
  Moteur moteur ;
  Vehicule vehicule;

  moteur = new Moteur();
  vehicule = new Vehicule();
  moteur.setVehicule(vehicule);
  vehicule.setMoteur(moteur);
}

Initialisation (possibilité 3)

class Vehicule {
  private Moteur moteur;
  public void setMoteur(Moteur moteur){
    this.moteur = moteur;
    moteur.setVehicule(moteur);
  }
}

void init(){
  Moteur moteur ;
  Vehicule vehicule;

  moteur = new Moteur();
  vehicule = new Vehicule();
  vehicule.setMoteur(moteur);
}

Dépendance, utilisation

Il est possible de représenter une relation de dépendance entre deux classes sans qu’il y ait une association telle que représentée précédemment.

Relation de dépendance

La classe principale LancerCalculs utilise la classe Calcul

Relation de création

La classe principale LancerCalculs crée au moins une instance de la classe Addition

Peut aussi être noté:

Agrégation

Définition

Une agrégation consiste en un assemblage d’objets:

• chaque objet est une partie de l’agrégat

Exemple

Relations

Les relations entre agrégat et parties peuvent être:

• structurelles
• comportementales

Destruction

La destruction de l’agrégat n’implique pas la destruction des parties

Exemple en Java

Diagramme de classes

Classe Livre

Classe Livre

public class Livre {
    String titre;
    Livre(String t){
        titre = t;
    }
}

Classe TableChevet

Classe TableChevet

public class TableChevet {
    Livre livreMatin;
    Livre livreSoir ;
    
    public void afficherTitres() {
        System.out.println("Livre posé: "+livreMatin.titre);
        System.out.println("Livre posé: "+livreSoir.titre);
    }
    public void setLivreSoir(Livre livreSoir) {
        this.livreSoir = livreSoir;
    }
    public void setLivreMatin(Livre livreMatin) {
        this.livreMatin = livreMatin;
    }
    public void finalize() {
        System.out.println("La table de chevet est vendue");
    }
}

Classe Personne

Classe Personne

public class Personne {
    TableChevet tableChevet ;
    
    Livre aube = new Livre("Aube");
    Livre crepuscule = new Livre("Crepuscule");
    
    Personne(){
        tableChevet = new TableChevet();
        tableChevet.setLivreMatin(aube);
        tableChevet.setLivreSoir(crepuscule);
    }
    public void vendreTableChevet() {
        tableChevet = null;
    }
    public void citerLivres() {
        System.out.println("Mon livre du matin: "+ aube.titre);
        System.out.println("Mon livre du soir: "+crepuscule.titre);
    }
}

Classe LireMatinEtSoir

Classe LireMatinEtSoir

public class LireMatinEtSoir {
    public static void main(String[] args) {
        Personne joey = new Personne();
        
        joey.citerLivres();
        joey.tableChevet.afficherTitres();
        joey.vendreTableChevet();
        nettoyerObjets();
        System.out.println(joey.tableChevet);
        joey.citerLivres();
    }
    
    public static void nettoyerObjets() {
        System.out.println("Ramasse-miettes");
        try {
            System.gc();
            Thread.sleep(100);
        } catch (InterruptedException e) {
            System.err.println(e);
        }
    }
}

Composition

Définition

Une composition consiste en un assemblage d’objets:

• chaque objet est un composant de l’élément composite

Exemple

Relations

Les relations entre composite et composants sont structurelles

Destruction

La destruction de la composition implique la destruction des composants

Exemple en Java

Diagramme de classes

Classe Livre

Classe Livre

import java.util.ArrayList;
import java.util.List;

public class Livre {
    String titre;
    List<Page> pages = new ArrayList<>();
    
    Livre(String t){
        titre = t;
        pages.add(new Page(1, this));
        pages.add(new Page(2, this));
        pages.add(new Page(3, this));
    }
    
    public void finalize() {
        System.out.println("Le livre "+titre+" est brûlé.");
    }
}

Classe Page

Classe Page

public class Page {
    int numero;
    Livre livre ;
    Page(int num, Livre l){
        numero = num;
        livre = l;
    }
    public void finalize() {
        System.out.println("La page "
                +numero+" du livre "
                +livre.titre+" brûle.");
    }
}

Classe Personne

Classe Personne

public class Personne {
    Livre aube = new Livre("Aube");
    Livre crepuscule = new Livre("Crepuscule");
    
    Personne(){
    }
    public void brulerLivres() {
        System.out.println("Je brûle mes livres");
        aube = null;
        crepuscule = null;
    }
    public void citerLivres() {
        if (aube != null) {
            System.out.println("Mon livre du matin: "+ aube);
        }else {
            System.out.println("Pas de livre du matin");
        }
        if (crepuscule != null) {
            System.out.println("Mon livre du soir: "+ crepuscule);
        }else {
            System.out.println("Pas de livre du soir");
        }
    }
}

Classe BrulerLivres

Classe BrulerLivres

public class BrulerLivres {
    public static void main(String[] args) {
        Personne joey = new Personne();
        
        joey.brulerLivres();
        nettoyerObjets();
        joey.citerLivres();
    }
    
    public static void nettoyerObjets() {
        System.out.println("Ramasse-miettes");
        try {
            System.gc();
            Thread.sleep(100);
        } catch (InterruptedException e) {
            System.err.println(e);
        }
    }
}

Délégation

Définition

Déléguer c’est faire réaliser le travail par un tiers (un délégué)

Caractéristiques

La délégation :

• permet de faire réaliser une tâche par le délégué
• donne l’entière responsabilité de la réalisation au délégué

Diagramme de séquence

Diagramme de classe

Interface Operateur

Operateur.java

public interface Operateur {
    public int appliquer(int a, int b);
    public String getType();
}

Classe Calcul

Calcul.java

public class Calcul {
    private int resultat ;
    private int op1 ;
    private int op2;
    private Operateur operateur;
    
    Calcul(Operateur lOperateur){
            operateur = lOperateur;
    }
    
    /**
     * Accesseur: donne accès à la valeur
     * d'op1
     * @return op1
     */
    public int getOp1() {
            return op1;
    }
    
    public void setOp1(int a) {
            calculer(a, op2);
    }
    
    public void setOp2(int b) {
        calculer(op1, b);
    }
    
    public void calculer(int a, int b) {
        op1 = a;
        op2 = b;
        resultat = operateur.appliquer(op1, op2);
    }
    
    /**
     * Accesseur: donne accès à la valeur
     * d'op2
     * @return op2
     */
    public int getOp2() {
        return op2;
    }
    
    public int getResultat() {
            return resultat;
    }
    
    public String getInformation() {
        return "Le resultat de "+operateur.getType()
                + " avec " + op1 + " et " + op2 
                + " est " + resultat;
    }
}

Classe OperateurAddition

OperateurAddition.java

public class OperateurAddition implements Operateur {
    @Override
    public int appliquer(int a, int b) {
        return a + b;
    }

    @Override
    public String getType() {
        return "addition";
    }
}

Classe LancerCalculs

Classe principale LancerCalculs

public class LancerCalculs {
    public static void main(String[] args) {
        Calcul calcul1 = new Calcul(new OperateurAddition());
        calcul1.calculer(3, 5);
        System.out.println(calcul1.getInformation());
        
        Calcul calcul2 = new Calcul(new OperateurSoustraction());
        calcul2.calculer(4, 5);
        System.out.println(calcul2.getInformation());
        
        Calcul calcul3 = new Calcul(new OperateurMultiplication());
        calcul3.calculer(3, 5);
        
        calcul3.setOp1(7);
        System.out.println(calcul3.getInformation());
        calcul3.setOp2(6);
        System.out.println(calcul3.getInformation());
        System.out.println(calcul3.getResultat());
    }

}

Exercice

Compléter le diagramme suivant:

Classe OperateurSoustraction

Classe OperateurSoustraction

public class OperateurSoustraction extends OperateurAddition {
    @Override
    public int appliquer(int a, int b) {
        return super.appliquer(a, -b);
    }
    @Override
    public String getType() {
        return "soustraction";
    }   
}

Délégation hybride

Caractéristiques

La délégation hybride :

• permet de faire réaliser une opération par un objet tiers
• permet au délégué de solliciter le délégateur pour l’aider dans la réalisation

Diagramme de séquence

Diagramme de classe

Interface Operateur

Interface Operateur

public interface Operateur {
    public int appliquer(Calcul c);
    public String getType();
}

Classe Calcul

Classe Calcul

public class Calcul {
    private int resultat ;
    private int op1 ;
    private int op2;
    private Operateur operateur;
    
    Calcul(Operateur lOperateur){
            operateur = lOperateur;
    }
    
    /**
     * Accesseur: donne accès à la valeur
     * d'op1
     * @return op1
     */
    public int getOp1() {
            return op1;
    }
    
    public void setOp1(int a) {
            calculer(a, op2);
    }
    
    public void setOp2(int b) {
        calculer(op1, b);
    }
    
    public void calculer(int a, int b) {
        op1 = a;
        op2 = b;
        resultat = operateur.appliquer(this);
    }
    
    /**
     * Accesseur: donne accès à la valeur
     * d'op2
     * @return op2
     */
    public int getOp2() {
        return op2;
    }
    
    public int getResultat() {
            return resultat;
    }
    
    public String getInformation() {
        return "Le resultat de "+operateur.getType()
                + " avec " + op1 + " et " + op2 
                + " est " + resultat;
    }
}

Classe OperateurAddition

Classe OperateurAddition

public class OperateurAddition implements Operateur {
    @Override
    public int appliquer(Calcul c) {
        return c.getOp1() + c.getOp2();
    }

    @Override
    public String getType() {
        return "addition";
    }
}

Classe OperateurSoustraction

Classe OperateurSoustraction

public class OperateurSoustraction implements Operateur {
    @Override
    public int appliquer(Calcul c) {
        return c.getOp1() - c.getOp2();
    }
    @Override
    public String getType() {
        return "soustraction";
    }   
}

Classe LancerCalculs

Elle reste idendique à la version précédente.

Exercices

Lettre

La classe Lettre permet de représenter les lettres d’un alphabet. Chaque lettre possède un nom.

A chaque instance est associée :

• une instance de la classe Symbole correspondant à sa représentation en majuscule
• une autre à sa représentation en minuscule

1. Donner le diagramme de classe UML correspondant
2. Créer les classes correspondantes en Java.
3. Créer une classe principale ‘LettresEtSymboles’ qui instancie les lettres: A, B et C.
4. Afficher les noms et symboles pour ces trois instances de Lettre

Chiffres

La classe Chiffre permet de représenter les symboles de numération. Chaque chiffre est associé:

• à un nom
• à une valeur numérique (sous forme d’entier)
• à un symbole

1. Donner le diagramme de classe UML correspondant
2. Créer les classes correspondantes en Java.
3. Modifier la classe principale ‘LettresEtSymboles’ pour instancier les chiffres: 0, 1 et 9.
4. Afficher les noms et symboles pour ces trois instances de Chiffre

Mot et nombre

La classe Mot représente un ensemble composée de lettres.

La classe Nombre représente un ensemble composée de chiffres.

1. Représenter ces classes sous forme de diagramme UML et leurs associations avec les classes précédemment créées.

Associations à cardinalités multiples

Ensemble non ordonné

Un ensemble représente une collection d’objets non ordonnés.

Code Java équivalent

public class EntiersRelatifs {
    Set<String> mots = new TreeSet<>(); //ou une classe implémentant Set
}

Ensemble ordonné (cardinalité fixée)

Objets ordonnés dont le nombre est fixé.

Code Java équivalent

public class Wagon {
    private PlaceAssise[] placesAssises = new PlaceAssise[36] ;
}

Ensemble ordonné

Objets ordonnés dont le nombre peut varier.

Code Java équivalent

public class Classeur {
    private List<Feuille> feuilles = new ArrayList<>();
                             // ou LinkedList ou classe implémentant List
}

Sequence

Collection ordonnée pouvant contenir plusieurs fois la même occurence d’une même valeur.

Au Clair De La Lune : {Do, Do, Do, Ré, Mi, Ré, Do, Mi, Ré, Ré, Do}

Code Java équivalent

public class Melodie {
    private List<Note> notes = new ArrayList<>();
                             // ou LinkedList ou classe implémentant List
}

Initialisation des associations 1-n

Création

public class Classeur {
    private List<Feuille> feuilles ;

    public Classeur() {
        feuilles = new ArrayList<>();
    }

    public Classeur(List<Feuille> feuilles) {
        this.feuilles = feuilles;
    }

    public Classeur(Feuille... feuilles) {
        this.feuilles = new ArrayList<>(Arrays.asList(feuilles));
    }
}

Ajout

public class Classeur {
    private List<Feuille> feuilles ;
    //...
    public void addFeuille(Feuille p) {
        feuilles.add(p);
    }

    public void addFeuilles(Collection<Feuille> feuilles) {
        this.feuilles.addAll(feuilles);
    }

    public void addFeuilles(Feuille... feuilles) {
        this.feuilles.addAll(Arrays.asList(feuilles));
    }
}

Accès

public class Classeur {
    private List<Feuille> feuilles ;
      //...
    public Feuille getFeuille(int index) {
        return feuilles.get(index);
    }

    public Iterator<Feuille> getFeuilles() {
        return feuilles.iterator();
    }
}

Exercices

Alphabet

Créer une classe Alphabet. Cette classe permet d’associer des symboles (‘A’, ‘b’, ‘Z’) sous la forme d’un ensemble (déterminer lequel est pertinent). Ces symboles seront représentés par la classe Lettre.

Chaque symbole a une représentation minuscule ou majuscule.

1. Donner la représentation UML des différentes relations entre Alphabet, Lettre et Symbole.
2. Créer les classes correspondantes en Java.
3. Modifier la classe principale ‘LettresEtSymboles’ pour créer un alphabet complet (alphabet latin) : de A, à Z.
4. Afficher les noms et symboles pour ces trois instances de Lettre

Mot

Un mot est une séquence de lettres. La classe Mot représente cette séquence.

1. Donner la représentation UML des différentes relations entre Mot et Lettre.
2. Créer les classes correspondantes en Java.
3. Créer une classe principale ‘DesMassesDeMots’ et créer les mots chat, le, lait, boit.
4. Afficher ces mots.

Associations qualifiées

Cardinalité simple

Code Java équivalent

public class Lexique {
    private Map<Mot, Signification> significations;
}

Cardinalité multiple

Code Java équivalent

public class Lexique {
    private Map<Mot, Set<Page>> indexAlphabetique;
}

Exercices

Glossaire

Dans un glossaire, on associe à chaque mot une définition dans une discipline donnée.

Le glossaire sera ici organisé comme suit:

• pour chaque mot, on associera une et une seule définition

Dictionnaire

Le dictionnaire sera ici organisé comme suit:

• pour chaque lettre de l’alphabet, on associera un ensemble de mots commençant par cette lettre
• pour chaque mot, on associera une ou plusieurs définitions, stockées dans un ensemble.