1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

[Diskussion & Frage] Grundlegendes Code Design von GUI Applikationen

Dieses Thema im Forum "Java Grundlagen" wurde erstellt von Licorice, 26. April 2012.

  1. Licorice

    Licorice Allrounder

    Ich möchte hier gerne eine Diskussion rund um das Thema 'sauberer Code' im Bezug auf GUI Applikationen starten.
    Zum einen geht es um allgemeine Entwurfstechniken, zum anderen habe ich auch viele konkrete Fragen.

    Vorab: Ich bin [noch] kein professioneller Entwickler. (Aber studiert)
    Habe demnach noch Wissenslücken und mir fehlt praktische Erfahrung.
    Ich entwickle im Moment eher für mich selbst oder eine kleine Gruppe von Leuten als Single Developer.


    Meine Probleme:

    Meine größten Probleme liegen im Moment noch darin GUI Code von Anwendungsspezifischem Code besser zu trennen. Ich bringe gerne zu viel Code in einer Klasse unter. Das erschwert den Austausch der Oberfläche oder der Logik.

    Beispiel: Es geht um die Entwicklung eher kleinerer Tools. Bestehend aus einem Hauptfenster und einigen Dialogen, sekundären Fenstern und ein bisschen Logik und spezifischen Algorithmen.


    Die Logik, Algorithmen und die Datenstruktur ist nicht das Problem. Diese lassen sich ja einfach in verschiedene Klasse auslagern.
    Problematisch wird es wenn die GUI mit dem Rest vereint werden soll.

    Dialoge lassen sich im Grunde auch recht einfach Designen. Man spendet ihnen Set- und Get- Methoden und gibt ihnen ein internes Verhalten, welches man ja direkt in der Dialog-Klasse implementieren kann. (Beispielsweise soll sich ein Button bei Klick auf eine Checkbox deaktivieren o.ä.)


    Im Gegenzug dazu steht das Hauptfenster der Anwendung. Das besteht meist aus einer etwas komplexeren Oberfläche, die sich mitunter auch in verschiedenen Zuständen befinden und verschiedene Inhalte haben kann.

    Alle Listener auf Buttons, die MenuItems des Hauptmenüs und sonstige GUI Elemente werden nun meist in einer Init-Methode dieses Hauptfensters registriert. (Das macht der GUI Builder schon so)
    Darin wird dann eine anonyme Implementation des Action Interfaces übergeben, in der wiederum eine extra dafür definierte Methode innerhalb der Hauptfenster Klasse aufgerufen wird.
    Code (Java):
    1.  
    2. // Beispiel
    3. public class MainWindow extends JFrame {
    4.     private JButton buttonOk;
    5.    
    6.     /** GUI Init Methode */
    7.     private void init() {
    8.         // Neuen Button erzeugen
    9.         buttonOK = new JButton("Ok");
    10.        
    11.         // Action Listener registrieren
    12.         buttonOK.addActionListener(new ActionListener() {
    13.             public void actionPerformed(ActionEvent evt) {
    14.                 // Aufruf der internen Methode zur Eventbehandlung
    15.                 buttonOkActionPerformed(evt);
    16.             }
    17.         });
    18.        
    19.         // <mor init code>
    20.     }
    21.    
    22.     /** Event Methode */
    23.     private void buttonOkActionPerformed(ActionEvent evt) {
    24.         // Code der bei Button Klick ausgeführt wird
    25.         // ...
    26.         // Hier möchte ich nun _eigentlich_ keinen Code schreiben,
    27.         // der z.B. meine Datenstruktur in eine Datei schreibt
    28.         // oder sonstige Aufrufe auf externe Klasse machen...
    29.     }
    30. }
    31.  
    Frage bis hier: Ist das vernünftig?
    Oder sollte man selbst für das Hauptfenster eine eigene Controller-Klasse implementieren, die sich bei allen GUI Elementen des Hauptfensters als Listener registriert? Dann müsste man also der Hauptfenster Klasse logischerweise public Methoden spendieren, die die Listenerregistrierung an die internen GUI Elemente weitergeben, richtig!?
    Wäre das eine bessere Lösung oder gibt es noch eine Dritte? Wie wird das in der Praxis denn meistens gelöst?

    Um nicht schon alles vorweg zu nehmen, belasse ich es erst mal hierbei. Dennoch habe ich sicher noch mehr Fragen.

    Also... Wie strukturiert ihr denn so eure Anwendungen angefangen von der main-Methode bis zum GUI-Start?

    Zum Schluss: Ich entwickle mit Netbeans. Nutze dort den GUI Builder. Programmiere meist mit SWING.
  2. genodeftest

    genodeftest Erfahrenes Mitglied

    Hi
    1. Code-Design bei GUIs ist stark vom Framework abhängig. Wenn du dir SWT-Code ansiehts, sieht das aus wie C oder C++, entsprechend ähnlich den dort üblichen Programmierstilen.
    2. Hilfreich und sinnvoll ist das MVC-Modell, siehe https://en.wikipedia.org/wiki/Model–view–controller . MVC ist aber in Swing nur teilweise umgesetzt und auch unter Umständen schwierig zu realisieren.
    3. Ich würde das init-Zeug in den Constructor packen, es sei denn, Teile der Initialisierung müssen evtl. auch zur Laufzeit des Objekts noch mal durchgeführt werden. Ohne inits ist der Code übersichtlicher.
    4. zu der anonymen inneren Klasse in der init()-Methode: Eigentlich ist der Listener ein Teil des Controls (nach MVC) und damit nicht ideal im Modell aufgehoben. Außerdem sind nach manchen Code Conventions anonyme innere Klassen ungern gesehen. als Alternative würde ich dir eine „normale“, aber statische innere Klasse vorschlagen, die das Interface für den Listener implementiert.
  3. Fabio Hellmann

    Fabio Hellmann Erfahrenes Mitglied

    Hi,
    also ich für meinen Teil versuche GUIs so weit wie möglich mit MVC zu umzusetzen. Das funktioniert allerdings nicht immer. Aber in diesem Zusammenhang kann ich den Eventbus von Guava empfehlen. Damit geht das meiste viel einfacher.

    Gruß

    Fabio

Diese Seite empfehlen