Pattern Observer plusieur observateur pour [Résolu]

seichan94 38 Messages postés mardi 29 octobre 2013Date d'inscription 6 novembre 2014 Dernière intervention - 28 avril 2014 à 21:40 - Dernière réponse : cs_Julien39 6450 Messages postés mardi 8 mars 2005Date d'inscriptionModérateurStatut 17 mai 2018 Dernière intervention
- 1 mai 2014 à 20:13
Bonjour bonjour,

bon je vient poser une nouvelle question, au sujet du pattern Observer.
Je réalise une application avec swing,
j'ai un contrôleur qui implémente Observable
avec plusieur liste d'observateur

j'ai un JPanel qui implémente Observateur avec la fonction update qui va bien
je souhaite qu'une autre JPanel implémente Observateur mais j ai pas envie d'avoir le update du précédent est il possible d'avoir 2 Observateur

exemple

Observable
ObservateurClient
ObservateurProduit

sans avoir a crée 2 Observable different ???

je sais si je suis bien claire peut-etre qu je mi prend pas comme il faut je sais pas trop

merci pour votre aide
Afficher la suite 

Votre réponse

4 réponses

Meilleure réponse
cs_Julien39 6450 Messages postés mardi 8 mars 2005Date d'inscriptionModérateurStatut 17 mai 2018 Dernière intervention - 29 avril 2014 à 08:57
2
Merci
La problème est que les classes du JDK qui te permettent d'implémenter ce pattern n'ont pas prévu ce cas de figure. Tu ne pourras donc pas les utiliser. Cependant, tu peux toi même redéfinir le comportement d'un pattern Observer sans te servir des classe du JDK.

Par exemple :

Tu créés deux interfaces :
public interface ObservateurClient {
    
    public void updateClient();

}
public interface ObservateurProduit {
    
    public void updateProduit();

}


Puis tu créés tes classes Observables :
public class ObservableClient {

    private List<ObservateurClient> observateurs;

    public ObserVableClient(){
        observateurs = new ArrayList<ObservateurClient>();
    }

    public void addObserver(ObservateurClient o){
        observateurs.add(o);
    }

    public void notifyAll(){
        for(ObservateurClient o : observateurs){
            o.updateClient();
        }
    }

}


Je ne te détaille pas ObservableProduit, c'est la même.

Et ensuite, tu créés la classe qui observe les modifications de ObservableProduit et ObservableClient :
public class ObserverProduitClient implements ObservateurProduit, ObservateurClient(){
    
    @Override
    public void updateProduit(){
        // Code exécuté quand ObservableProduit notifie
    }

    @Override
    public void updateClient(){
        // Code exécuté quand ObservableClient notifie
    }

}


Et voilà, tu viens d'implémenter à la main le pattern Observer, il ne te reste plus qu'à initialiser :

ObservableProduit obProduit = new ObservableProduit();
ObservableClient obClient = new ObservableClient();
ObserverProduitClient observer = new ObserverProduitClient();
obProduit.addObserver(observer);
obClient.addObserver(observer);

Merci cs_Julien39 2

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 119 internautes ce mois-ci

Commenter la réponse de cs_Julien39
cs_Julien39 6450 Messages postés mardi 8 mars 2005Date d'inscriptionModérateurStatut 17 mai 2018 Dernière intervention - 29 avril 2014 à 08:45
1
Merci
Salut,

Si j'ai bien compris tu as deux classes observables :
- ObservableClient
- ObservableProduit

Et tu veux ajouter des observateurs de ces deux classes.

Problème, c'est toujours la même méthode update() qui est appelée et tu voudrais que ces deux observable déclenchent des comportement différents.

Donc que faire ?
Commenter la réponse de cs_Julien39
seichan94 38 Messages postés mardi 29 octobre 2013Date d'inscription 6 novembre 2014 Dernière intervention - 29 avril 2014 à 12:13
0
Merci
Bonjour

Merci pour ta réponse je vais faire comme cela en terme de bonne pratique c'est courant ce style d'utilisation ?

Merci bonne journée
Commenter la réponse de seichan94
cs_Julien39 6450 Messages postés mardi 8 mars 2005Date d'inscriptionModérateurStatut 17 mai 2018 Dernière intervention - 1 mai 2014 à 20:13
0
Merci
Il y a tout un tas de bonnes raison de ré-implémenter ce pattern en java.

Il est possible que dans la conception de ton application tu ais fait quelques maladresses, mais ce n'est pas garanti, en tout cas, je ne peux pas le savoir avec si peu d'informations.

Dans tous les cas, ré-implémenter le pattern Observer dans ce cas ne me semble pas être une solution maladroite.

C'est une chose que je fais assez souvent pour d'autres raisons, l'implémentation de ce pattern est à mon sens assez mal pensée. J'avais dans un projet implémenté ce pattern avec des classes génériques de manière à récupérer des informations sur l'état de l'observable dans la méthode update de cette manière :
public class Observer<T extends IObservable> {
   
    public void update(T observable){

    }
}
Commenter la réponse de cs_Julien39

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.