Sauberes GUIieren mit dem AWT | Frage zur Kapselung

[Hutmacher]

Welches Konzept wendet man an, wenn man GUIs sauber vom GUI-Code trennen will?
Beispiel:
Ich habe auf einem Frame einen Button und ein TextField. Wenn ich auf den Button klicke, soll der Text des TextFields ausgegeben werden; kann man das dann überhaupt mit sauberer GUI-Trennung vereinbaren?

Ich benötige:

1. Eine Klasse, die einen ActionListener implementiert
2. Eine Klasse mit einer actionPerformed-Methode
3. Ein Frame, auf das ich Button und TextField (am besten als ein Panel) packe

Das könnte quasi so aussehen:

import java.awt.*;
import java.awt.event.*;
import java.util.*;

class MyGUI
 extends Frame
 implements ActionListener
{
    private Button textAusgabeButton; //Der Button, der den Text des TextFields ausgibt
    private TextField eingabefeld; //Enthält den vom Button ausgegeben werdenden Text
    private final static Color BACK_COLOR = new Color(220, 220, 220);

    //MAIN-METHODE
    public static void main(String[] args)
    {
        MyGUI wnd = new MyGUI();
    }


    /*Konstruktor */
    public MyGUI()
    {
	//Initialisierung
	super("GUI-Test #3"); //Erstellt das Raw-Fenster
	setSize(330, 65);
	setBackground(MyGUI.BACK_COLOR);
	addWindowListener(new WindowAdapter(){
			  public void windowClosing(WindowEvent event)
			  { System.exit(0); }});	
	setResizable(false);

        
	Panel panel = new Panel(); //Layout-Vorlage
	panel.setLayout(null); //Damit die Komponenten frei mit Koordinaten gesetzt werden können

	//Komponenten erstellen
	textAusgabeButton = new Button("Text ausgeben");
	textAusgabeButton.setBounds(5, 5, 150, 30); //Erstellt auf 5|5 einen Button mit w = 50, h = 30
        
	eingabefeld = new TextField("Irgendein Text");
	eingabefeld.setBounds(160, 5, 150, 30);
        

	//Komponenten Listener hinzufuegen und in das Panel einbinden	
	textAusgabeButton.addActionListener(this);
	panel.add(textAusgabeButton);

	eingabefeld.addActionListener(this);
	panel.add(eingabefeld);

	//Panel einbinden/auf das Fenster setzen
	add(panel);

	setVisible(true);
    }

    /* Wenn der Button geklickt wurde, wird der Text aus dem TextField
 ausgegeben */
    public void actionPerformed(ActionEvent event)
    {
        if (event.getSource() == textAusgabeButton)
        {
            System.out.print(eingabefeld.getText());
        }
    }
}

Wirklich geordnet ist das jetzt aber nicht und besonders wenn es mehrer Komponenten wären, würde die Übersicht schnell verloren gehen.

Frage 1:
Wie kann man es besser machen (muss kein Codebeispiel sein!)?

Frage 2:
Zur Kapselung: Wäre es besser, würde ich aus dem obigen Code Folgendes machen?

import java.awt.*;
import java.awt.event.*;
import java.util.*;

class MyGUI
 extends Frame
 implements ActionListener
{
    private Button textAusgabeButton; //Der Button, der den Text des TextFields ausgibt
    private TextField eingabefeld; //Enthält den vom Button ausgegeben werdenden Text
    private final static Color BACK_COLOR = new Color(240, 240, 240);

    //MAIN-METHODE
    public static void main(String[] args)
    {
        MyGUI wnd = new MyGUI();
    }


    /*Konstruktor */
    public MyGUI()
    {
        //Inits
        super("GUI-Test #3"); //Erstellt das Raw-Fenster
        setSize(330, 65);
        setVisible(true);
        setBackground(MyGUI.BACK_COLOR);
        addWindowListener(new WindowAdapter(){
			  public void windowClosing(WindowEvent event)
			  { System.exit(0); }});	
        setResizable(false);
        
	
        createAndAddPanel(createComponents());
    }

    /* Wenn der Button geklickt wurde, wird der Text aus dem TextField
 ausgegeben */
    public void actionPerformed(ActionEvent event)
    {
        if (event.getSource() == textAusgabeButton)
        {
            System.out.print(eingabefeld.getText());
        }
    }

    private Component[] createComponents()
    {
        //Komponenten erstellen
        textAusgabeButton = new Button("Text ausgeben");
        textAusgabeButton.setBounds(5, 5, 150, 30); //Erstellt auf 5|5 einen Button mit w = 50, h = 30
        textAusgabeButton.addActionListener(this);  
      
        eingabefeld = new TextField("Irgendein Text");
        eingabefeld.setBounds(160, 5, 150, 30);
        eingabefeld.addActionListener(this);

        Component[] comp = {textAusgabeButton, eingabefeld};
        return comp;
    }

    private void createAndAddPanel(Component[] components)
    {
        Panel panel = new Panel(); //Layout-Vorlage
        panel.setLayout(null); //Damit die Komponenten frei mit Koordinaten gesetzt werden können
    
        for (int i = 0; i < components.length; i++)
        {
             panel.add(components[i]);
        }

        add(panel);
    }
}

So habe ich den langen Konstruktor-Code gekapselt – aber ist das wirklich besser, und sollte ich noch mehr kapseln?

Danke für eure Antworten im Voraus; und sry für den langen Code

 

[0815]

zu deinem beispiel:
kapselung ist das verbergen von daten nach aussen.
da alle deine objecte und methoden in beiden codebeispielen private sind, machen beide schreibweisen keinen unterschied in hinsicht auf die kapselung. sie sind fast völlig gekapselt (ausnahme ist die public void actionPerformed(ActionEvent event) kleine hintertür )

zur schreibweise. wie und wo du member der klasse initialisierst bzw bearbeitest ist geschmackssache. da wirs du dir mit der zeit ein für dich sinnvolles system finden.

trennung von gui und core:
ein beispiel:

class Gui extends Frame{
   private button;
   private textfeld;
  
   public Gui(){
      //private button / textfeld anlegen und bearbeiten und anzeigen
   }

   //gettter für TF inhalt ohne textfeldzugriff
   public getTextFeldText(){ 
      return textfeld.getText(); 
   }

   //methode zum anmelden für buttonklicks
   public void lausche(ActionListener l){
      button.addActionListener(l);
   }
}

das ist denn eine fast völlig gekapselte oberfläche.
und nun die verarbeitungsklasse:

class GuiCore implements ActionListener{
   private Gui gui = new Gui();
 
   public GuiCore(){
      gui.lausche(this);    // am actionlistener der gui anmelden
   }

   public void actionPerformed(ActionEvent event){
       // bei buttonklick auf der gui den text abholen und ausgeben
       System.out.print(Gui.getTextFeldText());
   }
}

die verarbeitungsklasse hat einen member der guiKlasse, und kann sich über die öffentlichen methoden am buttonlistener der gui klasse anmelden (lausche())
und holt sich über die methode getTextFeldText() den inhat des eingabefeldes.

->gui und verarbeitung komplett getrennt.
->die verarbeitungsklasse ist fast völlig gekapselt: GuiCore bekommt keinen direkten zugriff aud den button, das textfeld. wird nur informiert und darf sich n String abholen.

nun zu dem fast. durch die hintertür "event.getSourse()" bekommt die Core-klasse doch noch zugriff auf private member nämlich den butten und könnte text farbe enabled ändern. sollte aber in diesem stadium des programmieren lernens nicht das problem sein. hauptsache man weiss es.

(lässt sich über ein selbstgeschriebenes Event verhindern bei dem evtl schon der text übergeben wird)<- sollte aber für den anfang zu weit führen.

eine anmerkung noch. fals es nich unbedingt notwendig ist mim AWT zu arbeiten schau dir mal javax.swing an sind n paar nette spielereien bei.

 

[Hutmacher]

Wow, danke! Wirklich nett von dir

Ich sollte nicht immer mit Fachwörtern um mich schmeißen, die ich noch nicht einmal richtig kenne^^

Ich dachte nämlich, Kapselung wäre das Zusammenfassen von verschiedenen Lines in Methoden, um dann mehr Übersichtlichtkeit zu erreichen.
Ich meine

int x = berechneEineZahl();

ist besser als

int tmpX = 0;
tmpX += (tmpX/2)*5,5;
tmpX /= Math.sin(15);

for (int i = 0; i < 20; i++)
{
    tmpX-=1;
}

 

[0815]

Ich sollte nicht immer mit Fachwörtern um mich schmeißen, die ich noch nicht einmal richtig kenne^^

ich hoffe, du lässst das um herschmeissen mit fachbegriffen NICHT!!!!!!!!!

denn
ohne den ansatz eines evtl. fehlgeleiteten gedanken kann dir nich geholfen werden. und ich könnte nich meinen senf dazugeben. ;D