04-associations.Rmd

# Les associations

## Association unidirectionnelle

Dans le cas d'une association unidirectionnelle, une classe A appelle une classe B, comme attribut, et peut l'utiliser comme un attribut normal : l'association est naviguable dans un sens uniquement.

> Si la classe A a une association unidirectionnelle sur la classe B, alors A connait B mais B ne connait pas A.

Méthodologie :

  - en amont :
      - on crée un projet : `MonProjet`
      - on crée un package : `fr.lsarribouette.monprojet.metier`
      - on crée deux classes : `MaClasseA.java` et `MaClasseB.java`

  - dans `MaClasseA` :
      - on ajoute un attribut objet dont le type est `MaClasseB` : `private MaClasseB instanceB;`
      - on peux l'implémenter dans le constructeur
      - on peux ajouter un getter et un setter 

  - dans la méthode `main` de la classe de test :
      - on crée d'abord une instance de `MaClasseB`
      - on crée ensuite une instance de `MaClasseA` qui utilise l'instance de `MaClasseB`  

### Exemple simple

Association unidirectionnelle entre un étudiant et son université :  

Projet en trois fichiers (*Universite.java*, *Etudiant.java* et *TestAssociationUnidir.java*) où la méthodologie expliquée au chapitre \@ref(creation-classe) est appliquée.

**Universite.java** :  
```{java, eval=FALSE}
package fr.lsarribouette.associonsnous;

public class Universite {
	
	// attributs d'instance
	private String nom;
	private String ville;
	private int nbEleves;
	
	// constructeurs
	public Universite(String nom, String ville) {
		this.nom=nom;
		this.ville=ville;
	}
	
	// assesseurs et mutateurs
	// choix :	get nbEleves, nom, ville
	//			set nbEleves
	public int getNbEleves() {
		return nbEleves;
	}
	public String getNom() {
		return nom;
	}
	public String getVille() {
		return ville;
	}
	public void setNbEleves(int nbEleves) {
		this.nbEleves = nbEleves;
	}
	
	// toString
	// TODO supprimer avant mise en production
	@Override
	public String toString() {
		return "Universite [nom=" + nom + ", ville=" + ville + ", nbEleves=" + nbEleves + "]";
	}
}
```

**Etudiant.java** :  
```{java, eval=FALSE}
package fr.lsarribouette.associonsnous;

public class Etudiant {
	
	// attributs d'instance
	private String prenom;
	private int age;
	private String niveauEtudes;
	
	private Universite univ; // attribut objet
	
	// constructeurs
	public Etudiant(String prenom, Universite univ) {
		this.prenom=prenom;
		this.univ=univ; // implementation normale
	}
	
	// assesseurs et mutateurs
	// choix : 	get prenom, age, niveauEtudes, univ
	//			set age, niveauEtudes, univ
	public String getPrenom() {
		return prenom;
	}
	public int getAge() {
		return age;
	}
	public String getNiveauEtudes() {
		return niveauEtudes;
	}
	public Universite getUniv() {
		return univ;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void setNiveauEtudes(String niveauEtudes) {
		this.niveauEtudes = niveauEtudes;
	}
	public void setUniv(Universite univ) {
		this.univ = univ;
	}

	// toString
	// TODO supprimer avant mise en production
	@Override
	public String toString() {
		return "Etudiant [prenom=" + prenom + ", age=" + age + ", niveauEtudes=" + niveauEtudes + ", univ=" + univ
				+ "]";
	}
}
```

**TestAssociationUnidir.java** :  
```{java, eval=FALSE}
package fr.lsarribouette.associonsnous;

public class TestAssociationUnidir {
	public static void main(String[] args) {
		// un eleve connait son universite, mais pas l'inverse
		
		Universite univBordeaux = new Universite("Universite de Bordeaux", "Bordeaux");
		
		Etudiant bob = new Etudiant("Bob",univBordeaux);
		
		System.out.println(univBordeaux); 	// Universite [nom=Universite de Bordeaux, ville=Bordeaux, 
											// nbEleves=0]
		System.out.println(bob);	// Etudiant [prenom=Bob, age=0, niveauEtudes=null, 
									// univ=Universite [nom=Universite de Bordeaux, ville=Bordeaux, nbEleves=0]]
	}	
}
```

## Association bidirectionnelle

Dans le cas d'une association bidirectionnelle, les classes A et B s'appellent mutuellement, comme attributs. Elles peuvent utiliser leurs attributs croisés : l'association est naviguable dans les deux sens.  

> Si les classes A et B ont une association bidirectionnelle, alors A connait B mais B connait aussi A.

Méthodologie : // à compléter

> Seule une implémente l'autre dans son constructeur, sinon c'est le serpent qui se mord la queue.  
*çàd* un seul constructeur avec `this` pour un attribut objet.



### Exemple simple

```{java, eval=FALSE}
// à compléter
```

## Toutes les associations