Ereignisbehandlung in Java vs in C#

Question

Ich möchte eine einfache Event-Handling-Lösung in Java mit benutzerdefinierten Ereignissen schreiben. Ich habe nur GUI-basierte Beispiele gefunden, die bisher ActionListeners verwenden. Ich habe einen Code hinzugefügt, den ich in C# geschrieben habe.

möchte ich so etwas wie dies in Java erstellen:

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

In Java Sie in der Regel eine Klasse für das Ereignis selbst erstellen, aus EventObject erstreckt. Die interessierenden Ereignisse werden in einer Schnittstelle definiert, die mit dem Namen Listener endet und die Schnittstelle EventListener erweitert.

Die Klasse, die Ereignisse übertragen kann, verfügt über eine Add/Remove-Listener-Methode, über die sich die interessierte Person selbst registrieren kann.

Ihr Code wird funktionieren, ohne diese Konventionen zu beachten, aber sie sind (sind?) Für Tools gedacht, um Namen der Klassen und Methoden zu verstehen.

Hier ist ein Beispiel Pseudo Implementierung für Ihre Domain:

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()); 
    } 
} 

In früheren Versionen von Java war es Standard gehören ein Adapter(), die die Listener-Schnittstelle als No-op-Operationen implementieren würde. Der Grund dafür war, dass beim Hinzufügen von Ereignisklassen, die vom Adapter aus verlängert wurden, kein Code hinzugefügt werden musste. Mit Java 8 können Sie Standardmethoden hinzufügen, sodass das Event-Adapter-Muster nicht mehr benötigt wird.