Salut a tous !
 
je suis novice sous java et je me demandais si on pouvait gerer soit meme les évenements java un peu a la maniere C++.
Par evenement j'entend les évenements non graphique.
 
J'ai vu dans d'autres topics que l'on pouvais utiliser des 'listener', mais la classe appellante doit connaitre son ou ses listeners
 
En fait j'aimerais faire un truc comme ca :
 
Classe MonThread
{
traitement();
envoyer_evenement(MESSAGE_1);
}
 
et une classe qui recoit les evenements :  
 
Classe MonServeur
{
attendre_Evenement(Event);
switch (Event)
{
case MESSAGE_1 : traitement();
break;
case MESSAGE_2 : traitement();
....
 
}
 
J'ai l'impression que Java fait abstraction de ce systeme. C est possible de faire ca en java ?
 

tu entends quoi par evenement ?

Bah c est genre un événement qui indique que quelque chose s'est passé. Par exemple sous win quand tu cliques sur OK ca envoie un evenement a la fenetre qui le traite et se remet en attente d'autres evenements.
Mais peut etre que le mot plus juste serais message

tu peux faire ca avec des windowlistener
(tu met un window listener pour chaque evenement que tu veux)

le souci  c est que je veux qu'il y ait que tres peu de dépendence entre package. Or le listener doit etre connu de la classe qui l'emet
 
On peut pas se passer des listeners et faire son propre serveur de messages/evenements ?

si tu veux en CPP avec les MFC tu vas dire sur ce bouton je veux que cette fonction soit executée.
Ya abstraction de la gestion des messages, c est ce que propose JAVA.
 
Mais derriere ce qui se passe, c est que quand tu cliques sur le bouton, la ressource envoie un message a la fenetre, qui traite le message et appelle la fonction que l'on a définie. Voila ce que je veux faire, mais je me demande si c est faisable en java.

up si qqn a une idée

peut importe le système d'evenement que tu mets en place, il faut que à la fois l'emmetteur et le recepteur connaisse ce système ...
Donc ca veut dire passer par des interfaces/classes communes.
 
Toi, ce que tu veux faire, ca ressemble beaucoup un mécanisme observé/observable statique, c'est à dire un endroit où on va envoyer les évenements et un (ou des) endroits où on va pouvoir les recevoir.
 
Ben ca se fait avec des listeneners : T'as une "classe statique" EventManager qui a une méthode statique addEvent(Event) qui permet d'ajouter des évenements. Elle a aussi une méthode statique addEventListener(EventListener) qui va permettre d'ahjouter des listener de cet évenement. L'interface de EventListener contient juste une méthode du type performEvent(Event).
 
Donc, quand le EventManager reçoit un évenement, il appelle performEvent de cet évenement sur chacun des listener qui se sont enregistrés.
 
C'était pour faire simple. Pour être complet il faut désynchroniserle mécanisme, mettre des méthodes removeListener, ajouter la notion de source d'evenement ...
 
C'est le design pattern observé/observable classique, sauf que toi tu veux le faire de façon "centralisée" => statique : un seul réservoir d'evenements