Events

[HeribertH]

Hi!

Ich bin recht neu in Java, komme aber mit den Grundlagen ganz gut zurecht. Ich komme von Delphi und C#. Ich würde gerne eigene Ereignisse, wie ich in den beiden anderen Sprachen schon oft gemacht habe, programmieren. Wenn ich was über Java und Ereignisse lese, dann immer nur im Zusammenhang mit AWT.
Es wird doch auch anderweitig möglich sein Eregnisse zu implementieren und dann im Programm abzufangen.

Kennt jemand gute Hilfestellungen?

Vielen Dank!

Gruß
Heribert

 

[SlaterB]

große Frameworks wie AWT machen Sinn, wenn du auf Systemereignisse wie Mausklicks + Tastatur reagieren willst,

je nach Definition ist jeder Operationsaufruf ein Ereignis,
du musst dir erst überlegen was du haben willst, dann kann man es programmieren..

Observer/ Observable sind dennoch Klassen, die du vielleicht anschauen möchtest

 

[Guest]

Ereignisse, vom Typ eines delegaten, wie in C# gibts meines Wissens nach in Java nicht, da es in Java keine Zeiger gibt. Meinst du das?

 

[Guest]

Ereignisse, vom Typ eines delegaten, wie in C# gibts meines Wissens nach in Java nicht

Definitiv nicht. Schade eigentlich, das spart einem viel Getippe.

In Java gibt es mehrere Möglichkeiten.

1) Observer/Observable
2) Eigene Events und EventListener (im Prinzip gleich wie 1, nur etwas anders )
3) PropertyChangeListener bzw. VetoablePropertyChangeListener

Hier mal ein Beispiel zu 2 anhand eines Counters (was anderes fällt mir gerade nicht ein)

public class CounterEvent extends EventObject
{
   private static final long serialVersionUID = 2538632333955403453L;
   private Long value;
   
   public CounterEvent(Object source, Long value)
   {
      super(source);
      this.value = value;
   }
   
   public Long getValue()
   {
      return value;
   }
}

public interface CounterListener extends EventListener
{
   void counterIncreased(CounterEvent event);
   void counterDecreased(CounterEvent event);
}

public class CounterAdapter implements CounterListener
{
   public CounterAdapter()
   {
   }

   public void counterIncreased(CounterEvent event)
   {
   }
   
   public void counterDecreased(CounterEvent event)
   {
   }
}

public class CounterListenerSupport 
{
   private EventListenerList listenerList = new EventListenerList();
   
   public CounterListenerSupport()
   {
   }
   
   public void addCounterListener(CounterListener listener)
   {
      listenerList.add(CounterListener.class, listener);
   }

   public void removeCounterListener(CounterListener listener)
   {
      listenerList.remove(CounterListener.class, listener);
   }
   
   public void fireCounterIncreased(Object source, Long newValue)
   {
      CounterEvent event = new CounterEvent(source, newValue);
      for(CounterListener listener : listenerList.getListeners(CounterListener.class))
      {
         listener.counterIncreased(event);
      }
   }
   
   public void fireCounterDecreased(Object source, Long newValue)
   {
      CounterEvent event = new CounterEvent(source, newValue);
      for(CounterListener listener : listenerList.getListeners(CounterListener.class))
      {
         listener.counterDecreased(event);
      }
   }
}

Verwendung

public class Counter
{
   private CounterListenerSupport listenerSupport = new CounterListenerSupport();
   private Long counter;
   
   public Counter()
   {
   }
   
   public void addCounterListener(CounterListener listener)
   {
      listenerSupport.addCounterListener(listener);         
   }
   
   public void removeCounterListener(CounterListener listener)
   {
      listenerSupport.addCounterListener(listener);         
   }
   
   public void increase()
   {
      counter += 1L;
      listenerSupport.fireCounterIncreased(this, counter);
   }
   
   public void decrease()
   {
      counter -= 1L;
      listenerSupport.fireCounterDecreased(this, counter);
   }

   public static void main(String[] args)
   {
      Counter counter = new Counter();
      
      // Mit CounterAdapter muss man nicht alle Methoden des Interface CounterListener implementieren
      counter.addCounterListener(
            new CounterAdapter()
            {
               public void counterIncreased(CounterEvent event)
               {
                  System.out.println(String.format("CounterAdapter#counterIncreased %d", event.getValue()));
               }
            }
      );

      // Mit CounterListener müssen beide Methoden implementiert werden
      counter.addCounterListener(
            new CounterListener()
            {
               public void counterIncreased(CounterEvent event)
               {
                  System.out.println(String.format("CounterListener#counterIncreased %d", event.getValue()));
               }
               public void counterDecreased(CounterEvent event)
               {
                  System.out.println(String.format("CounterListener#counterDecreased %d", event.getValue()));
               }
            }
      );
      
      counter.increase();
      counter.increase();
      counter.decrease();
      counter.decrease();
      counter.increase();
   }

}

 

[Guest]

Hier zum Vergleich C#. Irgendwie gefällt mir die C# Variante besser. Gerade solche elementaren Funktionalitäten
wie Event-Handling sollten durch die Syntax einer Programmiersprache abgedeckt sein.

public class CounterEvent : EventArgs
{
   private long value;

   public CounterEvent(long value)
      : base()
   {
      this.value = value;
   }

   public long Value
   {
      get
      {
         return value;
      }
   }
}

public class Counter
{
   public event EventHandler<CounterEvent> Increased;
   public event EventHandler<CounterEvent> Decreased;

   private long value;

   public Counter()
   {
   }

   public static Counter operator ++(Counter counter)
   {
      counter.value++;
      if (counter.Increased != null)
      {
         counter.Increased(counter, new CounterEvent(counter.value));
      }
      return counter;
   }

   public static Counter operator --(Counter counter)
   {
      counter.value--;
      if (counter.Decreased != null)
      {
         counter.Decreased(counter, new CounterEvent(counter.value));
      }
      return counter;
   }
}



// Dann die Verwendung

Counter counter = new Counter();
counter.Increased += new EventHandler<CounterEvent>(CounterIncreased);
counter.Decreased += new EventHandler<CounterEvent>(CounterDecreased);

counter++;
counter++;
counter--;


void CounterIncreased(object sender, CounterEvent counterEvent)
{
   Console.WriteLine(string.Format("CounterIncreased: {0}", counterEvent.Value ));
}

void CounterDecreased(object sender, CounterEvent counterEvent)
{
   Console.WriteLine(string.Format("CounterDecreased: {0}", counterEvent.Value ));
}

 

[Guest]

Kleiner Korrektur zum CounterListenerSupport (unnötige Erzeugung von Events vermeiden)

     public void fireCounterIncreased(Object source, Long newValue)
      {
         if (listenerList.getListenerCount() > 0)
         {
            CounterEvent event = new CounterEvent(source, newValue);
            for (CounterListener listener : listenerList.getListeners(CounterListener.class))
            {
               listener.counterIncreased(event);
            }
         }
      }

      public void fireCounterDecreased(Object source, Long newValue)
      {
         if (listenerList.getListenerCount() > 0)
         {
            CounterEvent event = new CounterEvent(source, newValue);
            for (CounterListener listener : listenerList.getListeners(CounterListener.class))
            {
               listener.counterDecreased(event);
            }
         }
      }