Bonjour,

J'essaye d'illustrer le pattern mediator par un exemple en Java.

Je génère une population d'amis qui ont un carnet d'adresses. On imagine qu'un des individu veut organiser un évènement et appel ses amis (ceux de son carnet) qui a leur tour appellent leurs amis et ainsi de suite.

Je veux montrer que si on laisse faire, des personnes seront appellées un grand nombre de fois, là où une suffirait (ce que fera le mediateur).

Pas de problème pour générer la population, les carnet d'adresses. Le problème c'est lorsqu'ils passent leurs appels, le programme s'interromp. Apparement, s'il y a trop d'appellants, ça sature:

import java.util.Random;
import java.util.ArrayList;

class Main{
	 public static void main(String[] args){
			Random r = new Random();

			System.out.println("Séquence de 10 collègues sans médiateur");
			ArrayList<Colleague> population;
			population  = new ArrayList<Colleague>();
			Mediator m = new Mediator();

			//Constitution de la population
			int i;
			for(i=0; i<10; ++i){
				  population.add(new Colleague(String.valueOf(i), m));
			}

			//Constitution des carnets d'adresse
			for(Colleague g: population){
				 int nbamis = r.nextInt(4)+1;
	 
				 ArrayList<Colleague> fl = new ArrayList();
				 //On prend de 0 à 10 amis dans la liste pour constituer le carnet d'adresse
				 int j = 0;
				 while(j<nbamis){
						int pos = r.nextInt(10);
						if(!population.get(pos).equals(g) && !fl.contains(population.get(pos))){
							 //On ajoute au carnet d'adresses
							 fl.add(population.get(pos));
							 j++;
							 System.out.println(g.getName()+" a pour amis "+population.get(pos).getName());
						}
				 }
				 g.setFriendList(fl);
			}


			System.out.println("Carnet d'amis générés, passage de tous les appels a partir de la premiere personne");
			
			population.get(0).giveAllCalls(false, population.get(0));

			System.out.println("------------------------------------------");
			System.out.println("Résultat sans médiateur:");

			for(Colleague g: population){
				 System.out.println(g.getName()+" a été appellé: "+g.getCalled()+" fois.");

			}

	 }
}

Les collègues:

import java.util.ArrayList;

class Colleague{
	 private ArrayList<Colleague> friendList;
	 private String name;
	 private Mediator m;
	 private int nbCalls;
	 private boolean hasCalled;


	 public Colleague(String nom, Mediator m){
			name = nom;
			this.friendList = friendList;
			this.m = m;
			nbCalls = 0;
			hasCalled = false;
	 }

	 public void setFriendList(ArrayList<Colleague> a){
			friendList = a;
	 }

	 public boolean equals(Colleague c){
			if(c.getName() == name)
				 return true;
			return false;
	 }

	 public Colleague(String nom, ArrayList friendList){
			name = nom;
			this.friendList = friendList;
			m = null;
	 }

	 public int nbCalled(){
			return nbCalls;
	 }

	 public void giveAllCalls(boolean mediate, Colleague father){
			if(hasCalled == false){
				 if(!mediate){
                                                hasCalled = true;
						for(Colleague g : friendList){
							 System.out.println("Appelant: "+getName()+"Appelé: "+g.getName());
							 if(!g.equals(father)){
									g.called();
									g.giveAllCalls(false, this);
							 }
						}
				 }else{
						 for(Colleague g : friendList){
							 if(!g.equals(father)){
									m.phone(g);
							 }
						}
				 }
				System.out.println(this.getName()+" finis");
			}
	 }

	 public void called(){
			nbCalls++;
	 }
	 
	 public int getCalled(){
			return nbCalls;
	 }

	 public String getName(){
			return name;
	 }

}

Et le médiateur (qui ne sert pas pour le moment):

class Mediator{
	 public void phone(Colleague receiver){
			if(receiver.nbCalled() != 1){
				 receiver.called();
			}
	 }
}

Si vous pouviez m'éclairer sur la manière d'éviter cet empilement d'appels de fonctions, ça m'aiderais GRANDEMENT

Merci d'avance
Seeme