Gestion d'événements en Java vs en C#

Question

Je souhaite écrire une solution de gestion d'événements simple en Java avec des événements personnalisés. J'ai seulement trouvé des exemples basés sur l'interface graphique, en utilisant ActionListeners jusqu'à présent. J'ai inclus un code, que j'ai écrit en C#.

Je veux créer quelque chose comme ceci en Java:

using System; 
 
using System.Threading; 
 

 
namespace EventHandlingPractice 
 
{ 
 
    class Program 
 
    { 
 
     static void Main(string[] args) 
 
     { 
 
      MusicServer mServer = new MusicServer(); 
 
      Sub subber = new Sub(); 
 

 
      mServer.SongPlayed += subber.SubHandlerMethod; 
 

 
      mServer.PlaySong(); 
 

 
      Console.ReadKey(); 
 
     } 
 
    } 
 

 
    // this class will notify any subscribers if the song was played 
 
    public class MusicServer 
 
    { 
 
     public event EventHandler SongPlayed; 
 

 
     public void PlaySong() 
 
     { 
 
      Console.WriteLine("The song is playing"); 
 
      Thread.Sleep(5000); 
 
      OnSongPlayed(); 
 
     } 
 

 
     protected virtual void OnSongPlayed() 
 
     { 
 
      if (SongPlayed != null) 
 
       SongPlayed(this, EventArgs.Empty); 
 
     } 
 
    } 
 

 
    // this class is class is the subscriber 
 
    public class Sub 
 
    { 
 
     public void SubHandlerMethod(object sender, EventArgs e) 
 
     { 
 
      Console.WriteLine("Notification from: " + sender.ToString() + " the song was played"); 
 
     } 
 
    } 
 
}

Answer 1

En Java, vous créez généralement une classe pour l'événement lui-même, l'extension de EventObject. Les événements d'intérêt sont définis dans une interface se terminant par le nom Listener, étendant l'interface EventListener.

La classe qui est capable de diffuser des événements a des méthodes d'ajout/suppression d'écouteurs, où la partie intéressée peut s'enregistrer elle-même.

Votre code fonctionnera sans suivre ces conventions, mais il est (était?) Destiné aux outils pour comprendre les noms des classes et des méthodes.

Voici un échantillon pseudo mise en œuvre de votre domaine:

public class Song { 

} 

public class SongEvent extends EventObject { 
    private final Song song; 

    public SongEvent(Object source, Song song) { 
     super(source); 
     this.song = Objects.requireNonNull(song); 
    } 

    public Song getSong() { 
     return song; 
    } 
} 

public interface SongListener extends EventListener { 
    default void songStarted(SongEvent event) { } 
    default void songPaused(SongEvent event) { } 
} 

public class SongServer { 
    private List<SongListener> listeners = new ArrayList<>(); 

    public void addSongListener(SongListener listener) { 
     listeners.add(listener); 
    } 

    public void removeSongListener(SongListener listener) { 
     listeners.remove(listener); 
    } 

    public void playSong(Song song) { 
     // .... 
     SongEvent event = new SongEvent(this, song); 
     listeners.forEach(l -> l.songStarted(event)); 
    } 
} 

public class MyEventHandler implements SongListener { 
    @Override 
    public void songStarted(SongEvent e) { 
    System.out.printf("Now listening to %s%n", e.getSong().getName()); 
    } 
} 

Dans les versions précédentes de Java, il était standard d'inclure un Adapter() qui implémente l'interface auditeur que les opérations no-op. La raison en était que si vous ajoutiez des classes d'événements qui s'étendaient depuis l'adaptateur, vous n'aviez pas besoin d'ajouter du code. Avec Java 8, vous pouvez inclure des méthodes par défaut, de sorte que le modèle d'adaptateur d'événement n'est plus nécessaire.