Cours 6 - Les associations

name: inverse
layout: true
class: center, middle, inverse

---
# JAVA - Cours 6
## Les associations
## Inès de Courchelle

![image](img/CY-tech.png)

---
layout: false

# Rappel - Les Collections
## 3 familles
Il existe 3 grandes familles de collections
- List : une valeur
- Map : un couple
- Set : un couple

#### Exemple d'un ArrayList
```java
/* Création d'une liste d'élèves */
ArrayList <Eleve> gryffondor= new ArrayList<Eleve>();
/* Création d'élèves */
Eleve e1 = new Eleve("Potter","Harry",-150);
Eleve e2 = new Eleve("Weasley","Ron",-150);
Eleve e3 = new Eleve("Granger","Hermione",200);
/* Ajout des élèves dans gryffondor */
gryffondor.add(e1);
gryffondor.add(e2);
gryffondor.add(e3);
```

---
# Rappel - Les iterateurs
## Définition
- Un itérateur est un objet qui a pour rôle de parcourir une collection
- Quelque soit la collection, on peut parcourir tous ses éléments
- 3 lignes :

```java
Iterator<String> i= maCollection.iterator();
while (i.hasNext()){
 System.out.println(i.next());
}
```

---
# Rappel - Les types 1/2
## Les types issues de Classe - C'est la même !
- Il existe déjà des classes pré-codées pour String, Integer, Double ...
- Elles commencent toujours pas une majuscule

#### Exemple 1 - String
```java
String maChaine = new String("LedZeppelin");
System.out.println(maChaine.substring(3));
```
#### OUTPUT
```bash
Zeppelin
```

---
# Rappel - Les types 2/2
## Les types primitifs
- Les types primitifs ne sont pas des classes
- C'est un type comme en C, avec int, char ...
- [Rappel : On l'a apperçu dans des diapos avant](../../TD2/cours/cm2.html#9)
- Aucunes fonctionnalités n'existent à leur sujet !

#### Exemple 2 - ERROR
```java
int b =4;
System.out.println(b.floatValue());
```
#### OUTPUT
```bash
 java.lang.Error: Unresolved compilation problem:
 Cannot invoke floatValue() on the primitive type int
```

---
# Today
## Objectifs
- Traduire un diagramme de classes UML en Java
- Mettre en place des collections
- Utiliser un fichier Properties

---
# Les associations 1 - 1
Nous considérons le diagramme suivant :
<center>
 <img src="img/association1-1.svg" width=500/>
</center>

.underV[Comment représenter en Java le lien entre ces deux classes ?]

---
# Les associations 1 - 1
## Etape 1 : Je code la classe Pays
.pull-left-big[
```java
public class Pays {
	/* Mes attributs */
    private Integer id;
    private String nom;
	/* Mon constructeur */
    public Pays(Integer id, String nom) {
		this.id = id;
		this.nom = nom;
	}
    /* Mes GETTERs/SETTERs */
    /* ... */
}
```
]

.pull-left-small[
 
 <center>
 <img src="img/Pays.svg" width=170/>
 </center>
]

---
# Les associations 1 - 1
## Etape 2 : Je code la classe Capital
.pull-left-big[
```java
public class Capital {
	/* mes Attributs */
	private Integer id;
	private String nom;
	/* Mon constructeurs */
	public Capital(Integer id, String nom) {
		this.id = id;
		this.nom = nom;
	}
   /* Mes GETTERs/SETTERs */
   /* ... */
}
```
]

.pull-left-small[
 
 <center>
 <img src="img/Capital.svg" width=170/>
 </center>
]

---
# Les associations 1 - 1
## Etape 3 : Je relie les deux

.underV[ICI, je peux faire un choix ]
- Soit je met le pays dans la capital
- Soit je met la capital dans le pays

.underR[Mais Comment ?]

---
# Les associations 1 - 1
## Etape 3 : Je relie les deux
- En rajoutant un attribut de type Capital dans Pays
- .underR[Attention]
  - Il faut rajouter/modifier le constructeur afin d'ajouter la Capital
  - Dans son utilisation, il va falloir créer la Capital et ensuite le Pays

---
# Les associations 1 - 1
## Etape 3 : Je relie les deux
.pull-left[
#### Pays
```java
public class Pays {
 /* Mes attributs */
 private Integer id;
 private String nom;
 private Capital cap;
 /* Mon constructeur */
 public Pays(Integer id, String nom, Capital cap) {
  this.id = id;
  this.nom = nom;
  this.cap =cap;
 }
 /* Mes GETTERs/SETTERs */
 /* ... */
}
```
]

.pull-right[
#### Capital
```java
public class Capital {
 /* Mes Attributs */
 private Integer id;
 private String nom;

/* Mon constructeurs */
 public Capital(Integer id, String nom) {
  this.id = id;
  this.nom = nom;
 }
 /* Mes GETTERs/SETTERs */
 /* ... */
}
```
]

---
# Les associations 1 - 1
<center>
 <img src="img/association1-1.svg" width=500/>
</center>

#### Exemple d'instanciation

```java
Capital c1 =new Capital(01,"Paris");
Pays p1 = new Pays (01,"France",c1);
```

---
# Les associations 1 - *
<center>
 <img src="img/association1-N.svg" width=500/>
</center>

#### Traduction des cardinalités
- Un Musicien possède 1 ou plusieurs Guitare(s)
- Une Guitare est possèdée par 1 et 1 seul Musicien

.underV[Un Musicien ] .underR[ collectionne ] .underV[  des guitares]

---
# Les associations 1 - *
## Etape 1 : Je code ma guitare

```java
public class Guitare {
 private Integer id;
 private String appelation;
 private String couleur;
 public Guitare(Integer id, String appelation, String couleur) {
    this.id = id;
	this.appelation = appelation;
	this.couleur = couleur;
 }
 /* Mes GETTERs/SETTERs */
 /* ... */
}
```
---
# Les associations 1 - *
## Etape 2 : Je code Musicien
```java
public class Musicien {
 private Integer id;
 private String nom;
 private String prenom;
 public Musicien(Integer id, String nom, String prenom) {
    this.id = id;
    this.nom = nom;
    this.prenom = prenom;
 }
 /* Mes GETTERs/SETTERs */
 /* ... */
}
```

---
# Les associations 1 - *
## Etape 3 : Je dis que Musicien collectionne des guitares

.underR[Mais comment je rajoute la collection ?]
<center>
 <img src="https://media.giphy.com/media/12nfFCZA0vyrSw/giphy.gif" width=150/>
</center>

---
# Les associations 1 - *
## Le musicien
```java
public class Musicien {
	private Integer id;
	private String nom;
	private String prenom;
	private List<Guitare> mesGuitares;
 ...
```

#### Comment le manipuler ?
- Est ce que je le rajoute au constructeur ?
- Est ce que j'instancie la List dans la classe Musicien ?

---
# Les associations 1 - *
## Solution 1 - Est ce que je le rajoute au constructeur ?
```java
import java.util.List;

public class Musicien {
	private Integer id;
	private String nom;
	private String prenom;
	private List<Guitare> mesGuitares;

public Musicien(Integer id, String nom,
 String prenom, List<Guitare> mesGuitares) {
 this.id = id;
		this.nom = nom;
		this.prenom = prenom;
		this.mesGuitares = mesGuitares;
 }

}
```
.underR[Mais comment utiliser cette classe ?]

---
# Les associations 1 - *
## Solution 1 - Est ce que je le rajoute au constructeur ?
.underR[Mais comment utiliser cette classe ?]
1. Créer des guitares
2. Créer la collection
3. Ajouter des guitares à la collection
4. Créer un musicien avec sa collection

---
# Les associations 1 - *
## Solution 1 - Est ce que je le rajoute au constructeur ?
```java
/* 1. Créer des guitares */
Guitare g1 = new Guitare(01,"lesPaul","Gold Top");
Guitare g2 = new Guitare(02,"Stratocaster","Blanche");
Guitare g3 = new Guitare(03,"Télécaster","Noire");
/* 2. Créer la collection */
List<Guitare> maCollect = new ArrayList<Guitare>();
/* 3. Ajouter des guitares à la collection */
maCollect.add(g1);
maCollect.add(g2);
maCollect.add(g3);
/* 4. Créer un musicien avec sa collection */
Musicien m1 = new Musicien (01,"Perry","Joe",maCollect);
```

---
# Les associations 1 - *
## Solution 2 - Est ce que j'instancie la List dans la classe Musicien ?
```java
public class Musicien {
	private Integer id;
	private String nom;
	private String prenom;
	private List<Guitare> mesGuitares;
	public Musicien(Integer id, String nom, String prenom) {
		mesGuitares=new ArrayList<Guitare>();
		this.id = id;
		this.nom = nom;
		this.prenom = prenom;
	}
 public List<Guitare> getGuitare() {
 return mesGuitares;
	}
}
```
---
# Les associations 1 - *
## Solution 2 - Est ce que j'instancie la List dans la classe Musicien ?
.underR[Mais comment utiliser cette classe ?]
1. Un musicien a forcément une collection de guitare vide
2. Ajouter des guitares une fois que le musicien est créé
3. Accèder à la collection via un getter pour pouvoir ajouter des éléments

---
# Les associations 1 - *
## Solution 2 - Est ce que j'instancie la List dans la classe Musicien ?
```java
/* 1. Un musicien a forcément une collection de guitare vide */
Musicien m2 = new Musicien(01,"Page","Jimmy");
/* 2. Créer des guitares */
Guitare g4 = new Guitare (04,"flying V","Rose");
Guitare g5 = new Guitare (05,"Explorer","Noire");
/* 3. Ajouter des guitares une fois que le musicien est créé */
m2.getGuitare().add(g4);
m2.getGuitare().add(g5);
```
.underR[ATTENTION]
- Dans cette solution il est obligatoire d'avoir un getter pour la collection de Guitare
- SINON, on ne pourra jamais y accèder et y ajouter des guitares

---
# Les associations 1 - *
## Solution 3 - Solution 1 + Solution 2
- Rien ne m'empêche d'avoir 2 constructeurs
- Il faut juste savoir comment j'utilise mes classes à un instant t
- Je peux donc utiliser suivant le contexte l'un ou l'autre

---
# Les associations 1 - *
## Musicien
```java
public class Musicien {
	private Integer id;
	private String nom;
	private String prenom;
	private List<Guitare> mesGuitares;
 /* constructeur 1 */
	public Musicien(Integer id, String nom, String prenom) {
		mesGuitares=new ArrayList<Guitare>();
		this.id = id;
		this.nom = nom;
		this.prenom = prenom;
	}
 /* constructeur 2 */
 public Musicien(Integer id, String nom,
 String prenom, List<Guitare> mesGuitares) {
 this.id = id;
		this.nom = nom;
		this.prenom = prenom;
		this.mesGuitares = mesGuitares;
 }
	public List<Guitare> getGuitare() {
		return mesGuitares;
	}
}
```
---
# Les associations 1 - *
## Les objets
```java
/* Solution 1 */
/* 1. Créer des guitares */
Guitare g1 = new Guitare(01,"lesPaul","Gold Top");
Guitare g2 = new Guitare(02,"Stratocaster","Blanche");
Guitare g3 = new Guitare(03,"Télécaster","Noire");
/* 2. Créer la collection */
List<Guitare> maCollect = new ArrayList<Guitare>();
/* 3. Ajouter des guitares à la collection */
maCollect.add(g1);
maCollect.add(g2);
maCollect.add(g3);
/* 4. Créer un musicien avec sa collection */
Musicien m1 = new Musicien (01,"Perry","Joe",maCollect);

/* Solution 2 */
/* 1. Un musicien a forcément une collection de guitare vide */
Musicien m2 = new Musicien(01,"Page","Jimmy");
/* 2. Créer des guitares */
Guitare g4 = new Guitare (04,"flying V","Rose");
Guitare g5 = new Guitare (05,"Explorer","Noire");
/* 3. Ajouter des guitares une fois que le musicien est créé */
m2.getGuitare().add(g4);
m2.getGuitare().add(g5);

```

---
# Les associations * - * porteuses
## Le diagramme
<center>
 <img src="img/associationN-N.svg" width=500/>
</center>

Il faut rajouter une étape entre le diagramme de classes et le java !

- un étudiant a des notes
- des notes sont une valeur un coeff et une matière
- une matière est une matière

---
# Les associations * - * porteuses
## On obtient le schema intermèdiaire suivant
<center>
 <img src="img/solutionetoiles.svg" width=400/>
</center>

## En gros :
<center>
 <img src="img/Engros.svg" width=500/>
</center>

---
# Les associations * - * porteuses
.pull-right-big[
```java
public class Etudiant {
	private Integer id;
	private String nom;
	private String prenom;
 private List<Notes> mesNotes;

/* Constructeur 1 */
	public Etudiant(Integer id, String nom, String prenom) {
		this.id = id;
		this.nom = nom;
		this.prenom = prenom;
	}
 /* Constructeur 2 */
 public Etudiant(Integer id, String nom, String prenom) {
		this.id = id;
		this.nom = nom;
		this.prenom = prenom;
 	mesNotes= new ArrayList<Notes>();
	}
 /* ... */
}
```
]

.pull-left-small[
 
 <center>
 <img src="img/Etudiant.svg" width=170/>
 </center>
]

---
# Les associations * - * porteuses
.pull-right-big[
```java
public class Notes {
	private Integer note;
	private Integer coeff;
    private Matiere mat;

/* Constructeur 1 */
	public Notes() {}

/* Constructeur 2 */
	public Notes(Integer note,
           Integer nom, Matiere mat) {
		this.note = note;
		this.coeff = coeff;
		this.mat = mat;
	}

/* ... */
}
```
]
.pull-left-small[
 
 <center>
 <img src="img/notes.svg" width=170/>
 </center>
]

---
# Les associations * - * porteuses

.pull-right-big[
```java
public class Matiere {
	private Integer id;
	private String appelation;
	private String niveau;

/* Constructeur 1 */
    public Matiere() {}

/* Constructeur 2 */
	public Matiere(Integer id,
           String appelation, String niveau) {
		this.id = id;
		this.appelation = appelation;
		this.niveau = niveau;
	}
    /* ... */

}
```
]

.pull-left-small[
 
 <center>
 <img src="img/Matiere.svg" width=170/>
 </center>
]

---
# Les associations * - * porteuses
## Exemple :
- Inès a eu 4/20 en Projet Voltaire qui a pour coefficient 2 !
- Harry a eu 20/20 en Défense contre les forces du mal qui a pour coefficient 5 !
- Inès a eu 10/20 en Défense contre les forces du mal qui a pour coefficient 2 !
- Harry a eu 12/20 en Projet Voltaire qui a pour coefficient 2 !

| etudiant     | note | matière                          | coeff |
| ---          | ---  | ---                              | ---   |
| Inès DC      | 4    | Projet Voltaire                  | 2     |
| Harry Potter | 20   | Défense contre les forces du mal | 5     |
| Inès DC      | 10   | Défense contre les forces du mal | 2     |
| Harry Potter | 12   | Projet Voltaire                  | 2     |

.underR[Euh mais comment ?]

.underV[Pourquoi Harry a de meilleures notes ?]

---
# Les associations * - * porteuses
## Raison 1 - Sans Hermione il ne sait rien faire !
Je vous invite à lire ce top [ici](https://www.serieously.com/harry-potter-11-choses-prouvent-harry-serait-rien-sans-hermione/) (Après le cours hein ???)

## Raison 2 - Il connait que Expelliarmus
 <center>
 <img src="img/hp.jpeg" width=500/>
 </center>

---
# Les associations * - * porteuses
## Raison 3 - C'est le chouchou de Dumbledore
 <center>
 <img src="img/dumb.jpeg" width=300/>
 </center>

# Il y a 11 942 raisons !

---

## Revenons à nos moutons !
 <center>
 <img src="https://media.giphy.com/media/cjhGnTOW1bIV2TmthV/giphy.gif" width=300/>
 </center>

---
# Les associations * - * porteuses
## Step by step de la création des objets
| etudiant     | note | matière                          | coeff |
| ---          | ---  | ---                              | ---   |
| Inès DC      | 4    | Projet Voltaire                  | 2     |
| Harry Potter | 20   | Défense contre les forces du mal | 5     |
| Inès DC      | 10   | Défense contre les forces du mal | 2     |
| Harry Potter | 12   | Projet Voltaire                  | 2     |

---
# Les associations * - * porteuses
## Step by step de la création des objets

```java
 /* Je créé mes étudiants */
 Etudiant e1 = new Etudiant(01,"DC","Ines");
 Etudiant e2 = new Etudiant(02,"Potter","Harry");
```

---
# Les associations * - * porteuses
## Step by step de la création des objets

```java
 /* Je créé mes matières */
 Matiere m1 = new Matiere(01,"Projet Voltaire","annee 1");
 Matiere m2 = new Matiere(02,"Defense contre les forces du mal","annee 1");
```
---
# Les associations * - * porteuses
## Step by step de la création des objets

```java
 /* Je créé mes notes */
 Notes n1 = new Notes(04,02,m1);
 Notes n2 = new Notes(10,02,m2);
 Notes n3 = new Notes(12,02,m1);
 Notes n4 = new Notes(20,05,m2);
```
---
# Les associations * - * porteuses
## Step by step de la création des objets

```java
 /* J'associe les notes aux étudiants */
 e1.getMesNotes().add(n1);
 e1.getMesNotes().add(n2);
 e2.getMesNotes().add(n3);
 e2.getMesNotes().add(n4);
```

---
# Les associations * - * porteuses
## Exemple complet !
```java
 /* Je créé mes étudiants */
 Etudiant e1 = new Etudiant(01,"DC","Ines");
 Etudiant e2 = new Etudiant(02,"Potter","Harry");

/* Je créé mes matières */
 Matiere m1 = new Matiere(01,"Projet Voltaire","annee 1");
 Matiere m2 = new Matiere(02,"Defense contre les forces du mal","annee 1");

/* Je créé mes notes */
 Notes n1 = new Notes(04,02,m1);
 Notes n2 = new Notes(10,02,m2);
 Notes n3 = new Notes(12,02,m1);
 Notes n4 = new Notes(20,05,m2);

/* J'associe les notes aux étudiants */
 e1.getMesNotes().add(n1);
 e1.getMesNotes().add(n2);
 e2.getMesNotes().add(n3);
 e2.getMesNotes().add(n4);
```
---
# Les associations reflexives
 <center>
 <img src="img/AssoReflexive.svg" width=270/>
 </center>

```java
Public class Personne {
 private Integer id;
 private String nom;
 private String prenom;
 private List<Personne> estParentDe;
 /* ... */

}
```

---
# Agrégations VS Compositions
## Agrégations
.otro-blockquote[Une agrégation est une association qui représente une relation d'inclusion structurelle ou comportementale d'un élément dans un ensemble.]

## Compositions
.otro-blockquote[La composition, également appelée agrégation composite, décrit une contenance structurelle entre instances. Ainsi, la destruction de l'objet composite implique la destruction de ses composants.]

---
# Agrégations VS Compositions
## Agrégations
.underV[Si le Projet n'existe plus, Alors les Étudiants restent !]
<center>
<img src="img/Agregation.svg" width=370/>
</center>

## Compositions
<center>
<img src="img/composition.svg" width=370/>
</center>

.underV[Si le Livre n'existe plus, Alors les Chapitres aussi !]

---
# Agrégations VS Compositions
## Projet
<center>
<img src="img/Agregation.svg" width=370/>
</center>
.pull-left[
```java
public class Projet{
 private List<Etudiant> etudiants;

public List<Etudiant> getEtudiants() {
 return etudiants;
 }

public void setEtudiants(List<Etudiant> etudiants ) {
 this.etudiants =etudiants;
 etudiants.setProjet(this);
 }
}
```
]
.pull-right[
```java
public class Etudiant{
 private Projet proj;

public Projet getProjet() {
  return proj;
 }

public void setProjet(Projet proj) {
  this.proj = proj;
 }
}
```
]

---
# Agrégations VS Compositions
## Livre

<center>
 <img src="img/composition.svg" width=370/>
 </center>
.pull-left[
```java
public class Livre{
	private List<Chapitre> chapitres;

public Projet(){
 this.chapitres = new List<Chapitre>();
 this.chapitres.setLivre(this);
 }
}
```
]
.pull-right[
```java
public class Chapitre{
 	private Livre livre;

public Livre getLivre() {
		return livre;
	}

public void setLivre(Livre livre) {
		this.livre = livre;
	}
}
```
]

---
# Agrégations VS Compositions
## Dans l'agrégation
- J'associe la liste des étudiants au projet dans la classes Projet
- La liste des étudiantes n'existent pas dans la classe Projet

## Dans la composition
- J'associe la liste des chapitres au livre dans la classes Livre
- Je créé la liste de chapitres dans la classe Livre (elle ne peut être créée ailleurs) !
<center>
<img src="https://media.giphy.com/media/3oxRmoTueKDmUguzL2/giphy.gif" width=290/>
</center>

---
# Agrégations VS Compositions
## Bilan Agrégation
<center>
<img src="img/AgregationA.svg" width=370/>
</center>
.pull-left[
```java
public class A {
	private B b;

public B getB() {
		return b;
	}

public void setB(B b) {
		this.b = b;
		b.setA(this);
	}
}
```
]
.pull-right[
```java
public class B {
	private A a;

public A getA() {
		return a;
	}

public void setA(A a) {
		this.a = a;
	}
}
```
]
---
# Agrégations VS Compositions
## Bilan - Composition
<center>
<img src="img/CompositionB.svg" width=370/>
</center>
.pull-left[
```java
public class A {
	private B b;

public A(){
		this.b = new B();
		this.b.setA(this);
	}
}
```
]
.pull-right[
```java
public class B {
	private A a;

public A getA() {
		return a;
	}

public void setA(A a) {
		this.a = a;
	}
}
```
]

---
# L'héritage (Rappel) 1/2
[On l'a déjà vu](../CM4/cm4.html#6)
- Avec le mot clé extends
- Une classe ne peut hérité que d'une classe à la fois
- Le constructeur de la classe fille doit faire appel au constructeur de la classe mère

#### Exemple
<center>
 <img src="img/heritageEx.svg" width=370/>
</center>

---
# L'héritage (Rappel) 2/2
## Exemple Professeur
```java

public class Professeur extends Personne {

private Integer id;
	private String bureau;
	private String  departement;
	public Professeur(Integer id, String nom, String prenom,
              String bureau, String departement) {
		super(id, nom, prenom);
		this.bureau=bureau;
		this.departement=departement;
	}
}
```
Ici .underV[super] fait référence au constructeur de la classe Personne qui prends 3 paramètres.

---
# L'interface (Rappel)
[On l'a déjà vu](../CM4/cours/cm4.html#39)

.underR[Pas de panique ! je vais cliquer ! ]

---
# Les classes Abstraites (Rappel)
[On l'a déjà vu](../CM4/cm4.html#41)

.underR[Pas de panique ! je vais cliquer ! ]

---
# Bilan 1/2
Quand on parle de java, on parle souvent de << Software engering >> AKA << Génie logiciel >>
<center>
 <img src="https://media.giphy.com/media/YlbKk8Wx9MX3aGYzWn/giphy.gif" width=370/>
<center>
<center>
 <a href="https://fr.wikipedia.org/wiki/Margaret_Hamilton_(scientifique)" target="_blank">Margaret Hamilton</a>

</center>

---
# Bilan 2/2
- Coder en java est le résultat d'une analyse approfondie
<center>
 <img src="https://media.giphy.com/media/Gj2iZfSI1rMmQ/giphy.gif" width=250/>
</center>
- Ne pas foncer tête baissée dans le code
- Regarder s'il vaut mieux utiliser une classe abstraite ou interface
- Comprendre les particularités de codage autour de la notion d'héritage
- Faire la différence entre agregation et composition
 - du moins contrégnant au plus contraignant
 - agrégation commence par un A donc la moins restrictive
 - composition commence par un C donc la plus restrictive