ein Interface kann ja keine Klasse erweitern. Also
Code:
public interface Model extends Observable { ... }
funktioniert nicht.
Es wäre aber irgendwie gut, wenn man das doch so ähnlich machen könnte, denn wenn man z.B. die Models (beim MVC-Prinzip) austauschen möchte, ist es doch einfacher wenn man z.B. an die View und den Controller nur ein Interface übergibt (also, hab ich mir so gedacht). Aber ein Model muss meistens Observable erweitern.
Fällt vielleicht jemandem etwas dazu ein oder ist mein Denkansatz verkehrt?
Edit: Mir fällt grad selber noch was dazu ein. Es müsste mit einer abstrakten Klasse gehen, die Observable erweitert und alle Methoden die sonst im Interface stehen als abstrakte Methoden beinhaltet. Ist das richtig bzw. sinnvoll?
Es wäre aber irgendwie gut, wenn man das doch so ähnlich machen könnte, denn wenn man z.B. die Models (beim MVC-Prinzip) austauschen möchte, ist es doch einfacher wenn man z.B. an die View und den Controller nur ein Interface übergibt (also, hab ich mir so gedacht). Aber ein Model muss meistens Observable erweitern.
???:L wat?
ja, das ist richtig so dass man als model am besten nur mit interfaces arbeitet, aber was hindert dich daran dein model von oberservable erben zu lassen?
Kommt bei mir immer die Fehlermeldung für diese Zeile:
interface expected here
Ist ja auch irgendwie logisch (also denk ich jetzt mal), dass ein Interface nicht von einer Klasse erben kann. (Weiß es aber nicht genau).
Und wenn ich jetzt die konkrete Model-Klasse von Observable erben lasse, dann kann ich mich in der View, doch nicht als Observer bei dem Model anmelden, wenn das nicht schon im Interface festgelegt ist, sondern nur in der konkreten Klasse.
Also wahrscheinlich bringe ich jetzt einiges völlig durcheinander. Aber vielleicht kann jemand Licht ins Dunkel bringen.
nene, so geht das natürlich nicht. ist auch nicht üblich, dass models oder überhaupt andere klassen die klassen observable und observer benutzen, weiß gar nicht wozu die konkret implementiert wurden, wo das doch nur nen pattern ist :s aber ladde:
dein model interface ist im grunde nur eine für dich sinnvolle implementierung von dem pattern. mit der klasse observable musst du nix anfange, wenn du nix besseres zu tun hast kannst du sie ja benutzen
edit: hier kommt noch was...
edit2: oder auch nich
Ich hab das jetzt so verstanden, dass man also am besten selbst eine 'Observable - Observer - Beziehung' implementiert, indem man Methoden wie addModelListener(...) und removeModelListener(...) etc. selbst implementiert (und die 'Methoden-Definitionen' dazu im Model-Interface hat) und dann ensprechend ein Interface ModelListener schreibt, das dann von der View-Klasse implementiert wird. Hoffe das stimmt jetzt so in etwa.
naja - ich bin der Meinung, wenn sich das vorhandene System Observable eigent, nimm das - warum etwas neu erfinden, was schon gut implementiert ist.....
naja - ich bin der Meinung, wenn sich das vorhandene System Observable eigent, nimm das - warum etwas neu erfinden, was schon gut implementiert ist.....
naja - ich bin der Meinung, wenn sich das vorhandene System Observable eigent, nimm das - warum etwas neu erfinden, was schon gut implementiert ist.....
Es ist einfach so, dass ich dieses 'Observer-Pattern' für viele Model-Klassen brauche, weil ja jedes Model eigentlich 'beobachtbar' sein muss, und ich viele verschiedene Model-Klassen bzw. Interfaces habe.
Und jetzt muss ich für jedes Model-Interface immer alle Methoden die für dieses 'Observer-Pattern' wichtig sind mit in die konkrete Model-Klasse implementieren obwohl ich gar kein angepasstes Pattern unbedingt brauche. Deshalb habe ich gedacht, es gibt eine einfacherer Möglichkeit eine konkrete Implementiertung des Patterns wiederzuverwenden, aber gleichzeitig Interfaces zu gebrauchen.
Warum versteckst du kein Oberservable in deinen Klassen und sprichst es als Delegate an. Die Methoden aus Observable kannste ja in nem eigenen Interface definieren.
So haste dein Interface und musst kein Observable selbst bauen, dass du ja in dem Falle auch erst als Baisklasse entwickeln müsstest und entweder mit Vererbung oder ner abstrakten Klasse arbeitest...
@AlArenal
Mmh, Entschuldigung wenn ich da nochmal nachfrage. Irgendwie hab ich leider nicht verstanden, was Du genau meinst.
Edit: Ich glaub jetzt hab ich's doch kapiert. Du meinst praktisch ich schreibe in das Model-Interface die Methodenköpfe für z.B. addListener und removeListener. Und die konkrete Model-Klasse erweitert dann Observable und ich 'rufe' dann in diesen Methoden (also z.B. addListener, removeListener) die entsprechenden Methoden der Observable-Klasse auf. Das hört sich, glaub ich, wirklich gut an.
Deine Model-Klassen können entweder Observable erweitern, oder aber haben alle einen Member, der eine Instnaz von Observable ist und an den du über die Methoden aus dem Interface die Aufrufe weiterleitest. So würde man es bei nachträglichen Änderungen am Design machen, wenn man eine Klasse nicht direkt von Observable ableiten kann, z.B. weil sie auf ner anderen Klasse basiert, die aus ner externen Lib oder so kommt.
