Designfrage zu Komonenten eines JPanels

[Guest]

Hallo liebe Leute!

Ich habe eine (simple) Frage zum Design von Swing-Applikationen.

Man stelle sich vor eine Programmkomponente wird auf einem
JPanel angezeigt.

In dieser Klasse Haupt-JPanel gibt es:

1. JTable auf dem in Listenform Aufträge amgezeigt werden
2. Einen eigenen JTable der JTable erweitert und die Produkte, des im ersten JTabel ausgewählten anzeigt.
3. Ein Hauptmenu JPanel, auf dem JButtons angezeigt werden, dei je nach Auswahl der Produkte im 2.Jtable enabled werden.
(Diese Komponenten sind Instanzvariablen der Klasse Haupt-JPanel)

Im Prinzip hab ich hier 3 Komponenten, die miteinander kommunizieren müssen.

Beispiel:
Wir im ersten JTable ein Auftrag ausgewählt muss der 2. eigene JTable mit den entsprechenden Produkten gefüllt werden.

Wird im 2. eigen JTabel ein Produkt ausgewählt, wird ein Button im Hauptmenu enabled.

Dies ist ein sehr simples Beispiel, jedoch wie löst man sowas sauber?
Sollt man da echt das Observer Pattern anwenden?
Oder ist das bei so einer relativ simplen Aufgabenstellung nicht übertriebener Aufwand?

Momentan ist es bei mir leider sehr unsauber:
D.h
Jeder Komponente wird die benötigte Kommunikationskomponente im Konstruktor mitübergeben.
Dies führt in diesem Beispiel zu folgendem "desaster":

Der ActionListenr des 1.JTabel mit den Aufträgen wird in der Klasse Haupt-JPanel implementiert.
D.h ich merke bereits in dieser Klasse, wenn ein Auftrag ausgewählt wurde und kann eine Method fülleJTable vom 2. eigenen Jtabel aufrufen. (Ist also kein Problem)

Wird nun im 2. JTable was aufgerufen, soll ein Button des Haupt-JPanel enabled werden.
Der ActionListener des 2. eigen Table befindet sich in der 2.eigenTableKlasse. Hier ist die Sache schon undurchsichtiger, den wie greife ich saueber auf den Button des Haupt-Jpanel zu?
(Wie gesagt, momentan kann ich das, da ich dieser Unterkomponete auch das Haupt-Jpanel übergebn habe)

Wie löst ein Profi sowas?
Wird in verschachtelten GUIs, in denen die eine Aktion in einer Komponente die Darstellung einer anderen beinflusst(Bsp füllen eines JTables, enabeln eins Buttons etc) immer über das Observer-Pattern gelöst?

Ich wäre sehr dankbar für etwaige Hinweise oder Vorschläge.
lg
mas

 

[Beni]

Wäre das eines meiner Programme, würde ich das folgendermassen lösen: die Listener jeweils als eigene Klasse (kann auch eine innere Klasse sein). Der erste Listener bekommt die beiden Tabellen über den Konstruktor, der zweite eine Tabelle und ein Button. Die zweite Klasse wären nur abstrakt, für jeden Button müsste noch eine Methode implementiert werden, welche entscheidet, ob der Button enabled oder disabled sein sollte (das dürfte aber meistens ein ein-zeiler sein).
Die Instanzen des zweiten Listeners könnte das Panel herstellen, welches auch die Buttons trägt - immerhin weiss dieses Panel am besten, welche Buttons es gibt.

Ob das übertriebener Aufwand ist? Nicht wenn du dein Programm jemals erweitern oder umstellen willst, diese Listener sind nämlich ziemlich unabhängig vom Rest des Programmes.

 

[Guest]

Hi!
Also leider kann ich dir nicht zu 100Prozent folgen.

Für alle die mitlesen:
Also Klasse1 (Ein JPanel) besitzt: Tabelle1, Tabelle2 und einen Button.
Wenn man in Tabelle1 was auswählt soll der Inhalt in Tabelle2 angezeigt werden.
Wenn man was in Tabelle2 auswählt soll ein Button enabled werden.
Die Tabellen sind in Wirklichkeit eigene komplexe Klassen, die JTable erweitern.
Die Frage war, wie da ein Profi die notwendigen Listener implementiert.


Ich versuchs mal (Totaler PseudoCode)

Klasse1 
    Tabelle1,Tabelle2,Button1;   //Instanzvariablem

    Tabelle1.addActionListener(listener1)  //Eigenen Listener1 Hinzufügen
    Tabelle2.addActionListener(listerner1) //Eigenen Listener2 Hinzufügen




Klasse Listener1
       Listener1(Tabelle1,Tabelle2)  //Konstruktor (Die beiden Tabellen übergeben)
       Action {Tabelle1.getAuswahl; Tabelle2.fülleMitAuswahl }  //So bei einer Action reagieren


Klasse Listener2
     Listener2(Tabelle2,Button1)   //Konstruktor (Tabelle2 und den Button uebergeben)
     Action {Tabelle1.getAuswahl

; if Auswahl ok Button1.enable } //So bei einer Action reagieren


Tja ich denke nicht, dass du das so in etwa meinst, da du noch von
Zitat "Die Instanzen des zweiten Listeners könnte das Panel herstellen, welches auch die Buttons trägt - immerhin weiss dieses Panel am besten, welche Buttons es gibt. " und "abstrakten Klassen" sprichst.

Ps:Ok das Panel mit den Buttons hab ich zwecks einfachheit hier jetzt rausgenommen und nur einen Button draus gemacht.

PPs: Danke für die Antwort!


Vielleicht kannst du oder jemand anderes mir das nochmal erläutern.
Vielen Dank
mas

 

[Beni]

Ich versuchs auchmal mit Pseudocode:

// 1. Tabelle
class Table1{
   ...
}

// 2. Tabelle
class Table2{
  ...
}

// Der 1. Listener, der Table1 und Table2 verbindet.
class Table1Listener implements ActionListener{
  private Table1 table1;
  private Table2 table2;

  public Table1Listener( Table1 table1, Table2 table2 ){
    this.table1 = table1;
    this.table2 = table2;
  }

  public void actionPerformed( ActionEvent e ){
    table2.machWas( 123 );
  }
}

// 2. Listener. Hauptsächlich ein Speicher der Daten - so kann diese abstrakte
// Klasse noch nicht sehr viel.
abstract class Table2Listener implements ActionListener{
  private JButton button;
  private Table2 table;

  public Table2Listener( Table2 table, JButton button ){
    this.table = table;
    this.button = button;
  }

  public void actionPerformed( ActionEvent e ){
    button.setEnabled( shouldEnable( table ));
  }

  protected abstract boolean shouldEnable( Table2 table );
}

// Panel mit den Buttons
class ButtonPanel extends JPanel{
  public ButtonPanel( Table2 table ){
     // Der ominöse Button instanziieren
    JButton knopf = new JButton( "alles löschen" );

    // Das Table2 und den Button "knopf" verbinden. Der Table2Listener ist 
    // abstrakt, deshalb müssen wir eine Unterklasse machen. Dazu reicht aber
    // eine anonyme Klasse wie hier. Die abstrakte Methode "shouldEnable"
    // muss noch implementiert werden - wir können hier gleich die Logik
    // für den Button "knopf" hinschreiben. 
    table.addActionListener( new Table2Listener( table, knopf ){
      protected boolean shouldEnable( Table2 table ){
        return tabel2.hatWasZumLöschen();
      }
    });

    // Der Knopf benötigt auch einen Listener, sonst passiert nichts, 
    // wenn man draufdrückt
    knopf.addActionListener( ... );



   JButton knopf2 = ... // nächster Knopf
  }
}