suche events wie in c#

seHaas

hallo,

der thread-titel ist vllt nicht optimal, aber hier mein problem:
ich versuche grade eine art asynchrone communication zwischen 2 classen zu implementieren. also C# wuerde ich es so machen
klasse A erzeugt klasse B, klasse B hat ein event, bei dem klasse A eine funktion von sich registriert.

Code

public delegate void SetIntHandler(int);

in A:

Code

private void neuerInt(int) { ... }
...




B b = new B();
b.onNewInt += this.neuerInt;

in B:

Code

public event SetIntHandler onNewInt;


...


this.onNewInt(7);

wie mach ich das in java? ich hab schon versucht der klasse B ein interface mit der fkt neuerInt mitzugeben aber das will ich nicht weil ja dann die funktion public ist und das soll nicht so sein. ich habs auchschon mit abstract funktionen in B versucht aber dadurch verschmelzen die zwei klassen zu stark.

ich hab bisher noch keine gscheite antwort auf diese frage googlen koennen - brauche aber dringend eine loesung.

mfg seHaas

Paulchen

Hm, ohne dass da irgendwas public ist, wird's nicht gehen, denk ich. Vielleicht kannst du den gewünschten Effekt - dass der Handler nur von dort aus aufgerufen werden kann, wo es Klasse A will - mit einer inneren Klasse von A erreichen, die ein Interface implementiert, welches die von B aufgerufene Methode spezifiziert:

Code

public interface IHandler {
    public void neuerInt(int value);
}

Code

public class A {
    /* ... */
   B b = new B();
   b.addIntHandler(new Handler());
   /* ... */


   private void intHandler(int value) {
       /* ... */
   }


   private class Handler implements IHandler {
      public void neuerInt(int value) { intHandler(value); }
   }
}

Alles anzeigen

Code

public class B {
    /* ... */
    public addIntHandler(IHandler handler) {
        /* ... */
    }
    /* ... */
}

a9bejo

delegates in C# sind nichts weiter als eine Abstraktion fuer das Command Pattern. Events wiederum sind eine Abstraktion des Observer Pattern.

Da sich sowohl Oberserver als auch Command in Java abbilden lassen, kann man deinen Code auch in Java umsetzen:

Java

import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;


public final class Test {
  public static void main(String[] args) {
    final B b = new B();
    new A().set(b);
    b.produceAnInteger();
  }
}


final class A {
  final Logger logger = Logger.getLogger(A.class.getName());


  public void set(final Observable observable) {
    observable.addObserver(new Observer() {
      public void update(Observable o, Object arg) {
        neuerInt((Integer) arg);
      }
    });
  }


  private void neuerInt(final Integer n) {
    logger.info("I got this shiny new Integer from B: " + n);
  }
}


final class B extends Observable {
  public void produceAnInteger() {
    final Integer n = 5;
    setChanged();
    notifyObservers(n);
  }
}

Alles anzeigen

Im Beispiel verwende ich eine Implementierung des Observer Pattern, das mit dem JDK ausgeliefert wird. Das ist hier praktisch, allerdings ist es auch sehr leicht selber nachzubasteln (Die API aus dem JDK hat auch einige Nachteile, z.B. das Klasse B von einer abstrakten Klasse ableiten muss, oder das man immer setChanged(); vor notifyObservers aufrufen muss).

seHaas

danke schon mal.

a9bejo: was ich vergessen habe zum hinschreiben, meine sache ist ein wenig komplexer, also es geht um mehrere funktionen mit mehreren parametern und so beim kurz ueberfliegen des observer interfaces schauts nicht so aus als wuerde die das koennen.

@Paulchen: ich hab mir dann ueberlegt vllt gehts mit expliziten interfaces, aber anscheinden gibts das in java auch wieder nicht

aber ich glaub fast, dass mir das ganze zu viel aufwand wird - gefordert is ja nicht - aber schoener waere es halt - ich werd sonst einfach die sachen publich machen und mich drauf freuen, dass ich in 2 wochen wieder .NET vor mir habe

schoenen abend noch,
seHaas

a9bejo

Zitat von seHaas

a9bejo: was ich vergessen habe zum hinschreiben, meine sache ist ein wenig komplexer, also es geht um mehrere funktionen mit mehreren parametern und so beim kurz ueberfliegen des observer interfaces schauts nicht so aus als wuerde die das koennen.

Alles klar, trotzdem hier noch zwei Bemerkungen:

Mehrere funktionen mit mehreren parametern sind mit dem Observer Pattern eigentlich kein Problem. Mit der im JDK enthaltenen API kannst Du zumidnest statt einem push einen pull ansatz verwenden. D.h. anstatt das B das integer oder was auch immer direkt mit der Nachricht schickt, bekommt der Observer nur eine Message, das sich der Zustand von B veraendert hat. A holt sich dann von B alles, was es braucht:

Code

public void set(final Observable observable) {
    observable.addObserver(new Observer() {
      public void update(Observable o, Object arg) {
        final B b = (B) o;
        neuerInt(b.getSomeInteger());
        b.somethingElse();
        ...
    });
  }

Zum anderen musst du ja nicht die JDK implementierung ( java.util.Observable und java.util.Observer ) verwenden. Das Observer Pattern ist das haeufigste Pattern, das im JDK verwendet wird, aber dort wird es fast immer mit eigenen Interfaces implementiert (z.B. Listener in awt/swing).

Eine eigene Implementierung besteht auch nur aus zwei Interfaces, mit der Du dann ganz leicht beliebig viele Methoden unterstuetzen kannst:

Code

interface Observable{

  void addObserver(Observer observer);

  void removeObserver(Observer observer);


  void notifyObservers();
}


interface Observer{

  //some sample methods:

  void onNewInt(int i);

  void onNewString(String str);

  void onNewDate(Date date);

  void onAnythingElse(Observable obs);

  //...
}

Alles anzeigen

Wie gesagt ist das event in C# ja auch nur eine (in die Sprachsyntax eingebaute) Implementierung von Observer.

Jetzt mitmachen!