Ok, der Ansatz mit den in Separaten Klassen realisierten Listenern war eigentlich die Zuständigkeit auszulagern um den Code in den einzelnen Klassen nicht unnötig aufzublähen, klar das schafft natürlich auch zusätzliche Komplexität....
Da ich vorher noch nicht nach dem MVC Pattern gearbeitet habe hier mal zum Verständnis eine grade schnell zusammengebaute Struktur , ob ich es verstanden habe, ( hier noch ohne Observer )
Ich habe mal versucht es so Simpel wie möglich zu gestalten:
Model:
[code=Java]
package mvcTest;
public class Model {
public Model() {}
public String manipulateInput(String input){
return new String(input + " dies macht das Model.");
}
}
[/code]
View:
[code=Java]
package mvcTest;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
public class View extends JFrame {
private static final long serialVersionUID = 1L;
JButton btn ;
JTextField txt;
JLabel label;
GridBagConstraints g;
public View() {
initialise();
addComponents();
}
private void initialise(){
txt = new JTextField();
btn = new JButton("Abschicken");
label = new JLabel();
this.setLayout(new GridBagLayout());
g = new GridBagConstraints();
this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
this.setSize(300,150);
}
private void addComponents(){
g.gridx = 0;
g.gridy = 0;
g.insets = new Insets(10,0,0,10);
g.gridwidth = 1;
g.fill = GridBagConstraints.HORIZONTAL;
this.add(txt, g);
g.gridx = 0;
g.gridy = 1;
this.add(btn, g);
g.gridx = 0;
g.gridy = 2;
this.add(label, g);
}
public void setListener(ActionListener l){
btn.addActionListener(l);
}
public String getTextInput(){
return this.txt.getText();
}
public void setLabelText(String text){
this.label.setText(text);
}
public void showFrame(){
this.setVisible(true);
}
}
[/code]
Controller:
[code=Java]
package mvcTest;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Controller {
View v;
Model model;
public Controller(Model model) {
initialise(model);
addListener();
}
public void showView(){
v.showFrame();
}
private void initialise(Model model){
this.v = new View();
this.model = model;
}
private void addListener(){
v.setListener(new ButtonListener());
}
// ---------------Inner Class Listner -------------------
public class ButtonListener implements ActionListener{
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == v.btn) {
v.setLabelText(model.manipulateInput(v.getTextInput()));
}
}
}
}
[/code]
und zu guter letzt der Aufruf
Test:
[code=Java]
package mvcTest;
public class Test {
public static void main(String[] args) {
new Controller(new Model()).showView();
}
}
[/code]
und so sähe das ganze dann im Zusammenspiel zu Testzwecken aus:
Hierzu dann noch ein paar Frage bzw. annahmen,
1. Kennt im Normalfall das Model den View ?
2. Das Model übernimmt ja nur Logische Aufgaben (bzw. die Logik) , in meinem Beispiel die einfache Manipulation des im View über den Controller , an das Model geleiteten Strings, angenommen ich müsste jetzt nur einen Text in ein Lable setzen ohne diesen weiter zu Manipulieren etc. wäre es nicht einfacher dieses direkt über den Controller zu regeln als an das Model weiterzuleiten ?
3. In der jetzigen Situation kennt der View weder das Model, noch den Controller, so wäre also Model und Controller, bzw. View gekapselt und austauschbar, im prinzip also vollkommen konform oder täusche ich mich ?
4. Der Controller Steuer über in View und Model bereitgestellte Methoden die Verarbeitung der Aktionen im View und die daraus resultierenden Aktionen und delegiert diese dann aus dem Model an den View.
5. Wie sähe jetzt das ganze mit der Implementierung des Observer-Patterns aus
danke schonmal für deine Mühen 
