Callbacks

[Killit]

Hey Leute, ich hab grad mal kurz nen code zu callbacks geschrieben. Ich glaube so funktioniert das.
Ich versteh aber das ganze trotzdem doch nicht.
Wieso kann ich nicht einfach callbackimpl lol = new callbackimpl(); z.B. anlegen und dann einfach
so aufrufen, ohne über das interface zu gehen? das versteh ich nicht. Ich komm einfach net drauf,
was callbacks sind und wozu ich sie genau brauche.


[Java]
interface callback{

public void callbackmethod();
}

public class callbackimpl implements callback{
public void callbackmethod(){
System.out.println("Jetzt gehts los!");
}

public class Caller (){
public void register( callback call){
call.callbackmethod();
}
}

public static void main ( String[] args ){
Caller call = new Caller();
callback call2 = new callbackimpl();
call.register(call2);
}
}
[/Java]

 

[Marco13]

Ein Callback ist in diesem Fall ein "Nachrichtenkanal", der überall hin rumgereicht werden kann.

Beispiel: Ein callback, der nach einer Berechnung augerufen werden soll

class Computer
{
    private Callback callback;

    public void setCallback(Callback c) { this.callback = c; }


    public void compute()
    {
        // rechne...
        ...
        // Am Ende:
        callback.call();
    }
}

Dort kann man bei "setCallback" beliebige Objekte von Klassen übergeben, die "Callback" implementieren. Man könnte z.B. einen Callback erstellen, der dort "Fertig!" ausgibt

class CallbackGerman implements Callback {
    public void call(){ System.out.println("Fertig!"); }
}

computer.setCallback(new CallbackGerman());

oder, wie man sich vielleicht schon denken kann, einen der stattdessen "Finished!" ausgibt

class CallbackEnglish implements Callback {
    public void call(){ System.out.println("Finished!"); }
}
computer.setCallback(new CallbackEnglish());

Oder einen, der was ganz anderes macht. Das Interface dient dabei quasi (wie eigentlich immer) das spezifische "rauzufaktorisieren" und verschiedene mögliche Implementierungen zu erlauben.

 

[SleepProgger]

Ich persönlich finde folgendes auch ganz schön:

public interface GenericObserver <T>{
	public void update(T object);
}

zum Thema: das was Marco13 schrieb

 

[Killit]

Ich verstehs immer noch nicht...

Abgesehen von den Interfaces ist es doch ein ganz normaler Methoden aufruf.
Statt InstanzvonKlasse.Methode(); halt InstanzvonInterface.Methode();

 

[Marco13]

Das ist auch ein ganz normaler Methodenaufruf, wenn man NICHT von den Interfaces absieht Eben einfach Polymorphie. Die meisten "Design Patterns" sind auch nur Ausprägungen von Polymorphie, und da kann man sogar Bücher drüber schreiben

 

[Killit]

aber wenn jetzt in der Prüfung in nem Monat z.B. steht:

Was sind Callback-Interfaces oder: programmieren sie xy mit Callback-Interfaces...

Na dann wüsst ich net genau was der prof von mir will... würds vll trotzdem irgendwie richtig machen...
Also Java ist schon etwas seltsam (;

 

[TheDarkRose]

Also Java ist schon etwas seltsam (;

was soll dran seltsam sein?

 

[Marco13]

Naja... "DIE" Musterlösung würde mich bei so einer Frage dann auch interessieren. Aber wenn es ein Interface (oft, aber nicht notwendigerweise mit nur einer Methode) gibt, und Instanzen davon irgendwo rumgereicht werden, damit auf ihnen die Methode aufgerufen werden kann, kann das nicht sooo falsch sein...

 

[TheDarkRose]

Oft braucht man ja nicht mehr als ein oder zwei Methoden. Ein Interface definiert sowas wie einen Vertrag zwischen der implementierenden Klasse und dem Aufrufer. Z.b. das Interface Runable, definiert ja nur die Methode run(). Dies reicht aber aus um das gewünschte Verhalten zu beschreiben. der Konstruktor vom Thread bekommt eine Klasse vom Typ (d.h. Runable implementiert) übergeben und hat somit die Sicherheit, das die Methode run() auch implementiert wurde. Was die Klasse sonst noch kann, ist ihm völlig egal und kann auch nicht aufgerufen werden. Also eben so ne Art Vertrag.