[Prophet]

Mion,

ich spiele ja im moment noch ein wenig mit Java rum. Nun wollte ich ein kleines Programm erstellen was als reaktion auf ein Ereignis etwas im Fenster verändert.

Nun habe ich aber ein logisches Problem. Wie realsiere ich es, das die ActionListener implementierende Klasse auch problemlos auf die eigenschaften meiner Fensterklasse zugreifen kann um diese zu verändern?

Soll ich ein Member reinschreiben welches eine Reference auf die Hauptklasse bereitstellt? Dann müsste aber wieder die ganzen Gets und Sets definieren was ich ja eigetnlich gar nicht brauche.

Ich habe mir auch schon überlegt das sich das Objekt selbst zuhört aber dann ergibt sich das Problem das ich nur ein einziges Ereignis erstellen kann nicht mehrere.

Alos wie löse ich das Problem am geschicktesten/besten/einfachsten?

Gruß, Prophet

[Ben]

Sagen wir du klickst in dem Frame auf einen Button. Dann hängst du an diesen den ActionListener und implementierst diesen als anonyme innere Klasse.

Vielleicht mal hier schauen:
http://forum.developers-guide.net/showthread.php?t=3035

Grüße, Ben.

[PS]
Je nachdem, wie sich der Thread entwickelt verschiebe ich den auch noch ins Applets, AWT, Swing und SWT-Forum.

[Prophet]

Ah, danke das werde ich machen!

EDIT: Wenn ich das Ereignis irgendwann mal ändern (also removen) will geht das doch nur wenn ich die Annonyme Klasse in form eine Variablen speichere oder? Bei direkter übergabe wie in dem von die genannten thread besteht diese möglichkeit nicht mehr oder?

EDIT2: Ich habe gerade oben in dem geposteten Artikel noch etwas gelesen und dort ist die lösung meines Problems über die this-Reference beschrieben.

[karahead]

Ich weiß zwar nicht ob ich dich richtig verstanden habe aber du willst, dass eine Klasse eine andere Klasse informiert, wenn es was neues gibt, nicht oder?

Dafür ist das Observer-Pattern bestens geeignet.
Google mal danach und guck dir in der API die Klassen Observer und Observable an.

---Edit
Swing mit seinen ganzen Listenern ist nach dem Observer/MVC Pattern aufgebaut.

Gruß KaraHead

[Ben]

Dazu eine Einleitung aus einem anderen Forum:
http://www.java-forum.org/de/viewtopic.php?t=6090#28148

[Prophet]

Ich muss gestehen das ich das mit den Observern nicht verstehe... Das problem was ich habe bleibt doch das selbe oder? Es ist ja ganz schön wenn die seich fein säuberlich getrennt nachrichten schicken. In dem Model kann ich doch genausowenig die Komponenten der GUI von der Daten Klasse aus kontrollieren. Oder habe ich das Missverstanden?

Diese Moder/Control/View-Model kenne ich bereits aus der Macintosh API die arbeitet in Objective-C nach dem gleichen prinzip. Aber sowohl da als auch hier verstehe ich nicht wie das ganze zusammen funktionieren und interagieren soll...

Könnt ihr mir das noch mal erklären?

Gruß, Prophet

[pago]

Daten ändern sich -> schicken Nachricht an Observer/Listener -> View, dass sich selbst als Listener bei den Daten registriert hat, ändert Anzeige entsprechend.

Warum ändern die Daten sich? Ganz einfach:
View registriert User-Aktion -> leitet Aktion an Controller weiter -> Controller modifiziert Daten.

Heißt also: View ließt Daten, Controller schreibt Daten, Daten benachrichtigen Observer von Änderungen (d.h. in diesem Falle das View).

Um die ursprüngliche Frage zu beantworten:

Soll ich ein Member reinschreiben welches eine Reference auf die Hauptklasse bereitstellt?

Ja. (Außer du arbeitest mit inneren Klassen oder anonymen Klassen.)

Dann müsste aber wieder die ganzen Gets und Sets definieren was ich ja eigetnlich gar nicht brauche.

Wenn du sie definieren musst, dann brauchst du sie. Beim generieren hilft dir die IDE deines Vertrauens.

[Prophet]

Ich habe mich mal mit dem Thema beschäftigt.

Ich habe als anhang eine Grafik begefügt die Zeigt wie ich das MVC Prinzip verstanden habe. Dabei habe ich den Controller weggelassen weil ich mich nach diesem Kapitel des buches "Java ist auch eine Insel" richte. Ist es so richtig? Ich habe versucht mich an das MVP Prinzip zu halten.

swing-mv-pattern.png

[pago]

Und da sag noch einer ich sei nicht künstlerisch begabt...

[Prophet]

Also besitzt die GUI eine Instanz der Daten / des Modells und ändert diese Entsprechend. Und die Daten alamieren die EventListener damit diese die GUI verändern?
Aber lauschen die EventListener nicht den GUI Komponenten? Müsste ich diese dann ich beiden Richtungen definieren? Die von Java bereitgestellten damit sich die Daten bei GUI eingaben ändern und die Selbsterstellten damit sich die GUI ändert wenn es die Daten / das Modell will?
Verstehe ich das so richtig?

[pago]

Hab nen Teil deines Posts nicht verstanden, deshalb nochmal in Worten:

Die GUI besitzt eine Instanz des Models und modifiziert diese, richtig. Die EventListener benachrichtigt, wenn das Model sich verändert. Die GUI registriert sich selbst oder einen Helfer als EventListener des Models und wird über Änderungen des Models benachrichtigt, woraufhin sie die angezeigten Daten ändert.

Den GUI-Komponenten lauscht niemand. Du darfst hier nicht das Swing-interne MVC mit deinem eigenen verwechseln. Aus der Programm-Perspektive gehört nämlich z.B. ein TableModel schon zum View!

d.h. hier ist eine Unterscheidung zwischen Swing-MVC und App-MVC zu treffen. Die Swing-Komponenten (inkl. ihrer Model und EventListener) sind View, nicht Model.

[Prophet]

Ok ich glaube ich habe es verstanden... Wenn ich ein fertiges Programm habe poste ich es nochmal hier dann weiß ich wenigstens das ich es richtig habe...

Vielen dank schonmal!

[Prophet]

Also da ich nicht schnalle wie ich das "vereinfachte" MVC Pattern benutzte. Habe ich mich mal an das normale herangewagt. Und ich muss sagen ich finde es verständlicher. Hier ein Beispiel nur um sicherzugehen das ich das alles richtig verstanden habe:

class TestView
{
  private JButton button;

  public JButton getButton()
  {
    return this.button;
  }
}

class TestModel implements Observable
{
  private boolean buttonPressed;

  public boolean getButtonPressed()
  {
    return this.buttonPressed;
  }

  public void setButtonPressed(boolean btnPressed)
  {
    this.buttonPressed = btnPressed;
  }
}

class TestControl
{
  private TestView mainView;
  private TestModel mainModel;

  public static void main(String[] args)
  {
    mainBla = new TestControl();
  }

  public TestControl
  {
    this.mainView = new TestView();
    this.mainModel = new TestModel();

    this.mainView.getButton().addActionListener(new ActionHandlerButtonPressed());

    this.mainModel.addObserver(new ObserverButtonPressed());
  }

  protected class ActionHandlerButtonPressed implements ActionListener
  {
    public void actionPerformed(ActionEvent actionEvent)
    {
      this.mainModel.setButtonPressed(true);
    }
  }

  protected class ObserverButtonPressed implements Observer
  {
    public void update(Observable o, Objekt arg)
    {
      this.mainView.getButton(); // Tu Was
    }
  }
}

Ich hoffe ich habe das MVC-Pattern dort oben richtig dargestellt.

Mir stellen sich jetzt noch zwei fragen:
1. Was erhalte ich in Observer.update an parametern die mir weiterhelfen?

2. Wenn ich jetzt zum beispiel dinge im datei system mache wohin gehören diese? In das Vie nicht das ist klar. Aber ich weiß nicht ob sowas in Control oder Model gehört.

[pago]

Ähm... was soll das darstellen? *sfz*

Pass auf, nochmal das ganze: Du musst zwischen Komponenten und Programmen unterscheiden. Was du da machst macht vielleicht dann Sinn, wenn du eine Komponente entwickelst, aber mit der Programmlogik hat das nichts zu tun.

Was genau verstehst du an meiner Erklärung nicht (mal abgesehen von "alles")? Und von welchem "vereinfachten MVC-Pattern" sprichst du? Was ich dir hier erklärt habe ist nicht vereinfacht. So funktioniert das - und nicht anders.

[Prophet]

Ich verstehe nicht wie ich das umsetzten soll. Was mich daran noch viel mehr irritiert ist die tatsache das es anderswo (http://de.wikipedia.org/wiki/MVC) anders für mich verständlicher erklärt wird. Aber sich doch deutlich von deinen erkläreungen unterscheidet. Ich habe nun versucht nach dem für mich verständlicherem vorzugehen. Also dem "großen" MCV Pattern welches ja zb oben auch unter wikipedie erklärt wird...
Ich habe nochmal eine Grafik erstellt die mein verständnis dieses Pattern verdeutlichen soll. Und bei dem Quelltext oben wollte ich an einem Praktischen Beispiel testen ob ich es richtig verstanden habe...

mvc-pattern.png

EDIT: Dadurch erreiche ich doch eine klare trennung zwischen Daten, Verarbeitung und Darstellung oder?

[pago]

*sfz*
Was du in dem Beispielprogramm oben realisiert hast, hat nichts mit MVC zu tun. Meine Güte...

Noch einmal wiederholen: Du kannst das Komponenten-MVC (z.B. JButton, ButtonModel, ActionListener) nicht auf dein Programm übertragen. Es macht absolut überhaupt gar keinen Sinn, einer View-Komponente eine "getButton"-Methode zu verpassen. Das ist absoluter Schwachfug. Es macht fasst noch weniger Sinn, dass der Controller als Listener beim Model eingetragen ist.

Ich kann's nur nochmal versuchen: Das View registriert sich beim Model und ändert sich, wenn das Model sich ändert. Der Controller wird vom View benachrichtigt, wenn der Benutzer irgendwas im View umstellt, und macht dann, was als Reaktion notwendig ist (Daten speichern, Model ändern, etc.). Dem Controller ist _völlig egal_, ob sich das Model ändert. Das bedeutet für ihn nichts.

Und nochmal: Das hat mit vereinfachtem MVC hier überhaupt nichts zu tun. Und das MVC, was auf Wikipedia erklärt wird, ist auch nicht "größer" oder sonstwas. Du schaffst es nur nicht, dass Prinzip von Komponenten auf Programme umzulegen.

Beispiel:

// Controller.java
interface Controller {
    void processUserInput(String input);
}
 
// User.java
import java.beans.*;
 
class User {
    // Attribute
    private String name;
    private int age;
    
    // Utility
    private PropertyChangeSupport support;
    
    public User() {
    }
    
    public User(String name, int age) {
        this.name = name;
        this.age  = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        String old = this.name;
        this.name = name;
        support.firePropertyChange("name", old, name);
    }
    
    // usw.
}
 
// UserInterface.java
interface UserInterface {
    public String readUserName();
    public int readUserAge();
}
 
// ConsoleUserInterface.java
class ConsoleUserInterface implements UserInterface, PropertyChangeListener {
    private User user;
    private Scanner in;
    
    public ConsoleUserInterface(User user) {
        this.user = user;
        in = new Scanner(System.in);
        
        user.addPropertyChangeListener(this);
    }
    
    public void propertyChanged(PropertyChangeEvent e) {
        if("age".equals(e.getPropertyName())) {
            System.out.printf("Age of user changed from %s to %s.%n", e.getOldValue(), e.getNewValue());
        } else if("name".equals(e.getPropertyName())) {
            System.out.printf("Name of user changed from %s to %s.%n", e.getOldValue(), e.getNewValue());
        }
    }
    
    public String readUserName() {
        System.out.println("Please insert user name:");
        return in.nextLine();
    }
    
    public int readUserAge() {
        System.out.println("Please insert user age:");
        return in.nextInt();
    }
    
    public void run() {
        controller = new DefaultController(user, this);
        while(true) {
            System.out.println("What next (setName, setAge, quit)?");
            String cmd = in.nextLine();
            controller.processUserInput(cmd);
        }
    }
}
 
// DefaultController.java
class DefaultController implements Controller {
    private UserInterface ui;
    private User user;
    
    // [Konstruktor]
 
    public void processUserInput(String input) {
        if("setAge".equals(input)) {
            int age = ui.readUserAge();
            if(0 < age && age < 130) {
                user.setAge(age);
            }
        } else if("setName".equals(input)) {
            String name = ui.readUserName();
            if(name.length() > 0) {
                user.setName(name);
            }
        } else if("quit".equals(input)) {
            System.out.println("Thanks for using this demo. Going to halt now.");
            System.exit(0);
        }
    }
}
 
// Main.java
public class Main {
    public static void main(String args&#91;&#93;) {
        User user = new User("Dummy User", 19);
        UserInterface ui = new ConsoleUserInterface(user);
        ui.run();
    }
}
 

Nun klarer?