Arten der GUI-Erstellung

[Rudi100]

Hallo,
ich möchte eine Oberfläche mit mehreren JTabbedPanes. Ein JTabbedPane für "Autos" ein JTabbedPane für "Kunden" etc.
Innerhalb einer JTabbedPane wird ein JPanel mit JLabels und JTextFields gesetzt. Soweit wird auch alles korrekt angezeigt (1. Möglichkeit im Quellcode).

Da die Struktur der JPanels mit den JLabels und JTextFields ähnlich sind (weitere JPanels z.B. mit Buttons zum Blättern in einem Fachkonzeptklassen-Container sind vorgesehen), wollte ich für das JPanel eine eigene Klasse erstellen. Die Einbindung erfolgt nun statt mit:

pnlCenter.add(getPnlCenterCenter());

mit:

pnlCenter.add(new CenterCenterPanel(),BorderLayout.CENTER);

Mit der letzteren Art kann ich ja viele Objekte vom Typ CenterCenterPanel erstellen, weil kein Singleton-Muster verwendet wird. Das JPanel wird aber mit dieser (2.) Methode nicht angezeigt.

Wenn ich die Objekterstellung in die Deklaration verschiebe, wie:

private JPanel pnlCenterCenter=new CenterCenterPanel();

ändert dies nichts, also keine Anzeige.

Meine Fragen wären nun:
a) Ist die Methode mit separate Klassen eine GUI aufzubauen sinnvoll (Ersparung von doppeltem Code)?
b) Wenn mein Weg Sinn macht, warum wird nichts angezeigt? Stimmt etwas an der Reihenfolge der Objekterzeugung nicht?
c) Gibt es eine bessere Methode zur Erstellung der Oberfläche bei mehreren ähnlichen Teilkomponenten?

Herzlichen Dank für eine hilfreiche Antwort.

Gruß Rudi100

public class Test extends JFrame {
  private static Test dasAnwendungsFenster=null;

  private JPanel jContentPane = null;
  private JTabbedPane tpCenter = null;
  private JPanel pnlCenter = null;
  //private JPanel pnlCenterCenter=new CenterCenterPanel();//3. Möglichkeit: Panel erscheint nicht
  private JPanel pnlCenterCenter = null;  //  @jve:decl-index=0:visual-constraint="488,157"
  private JLabel lblName = null;
  private JLabel lblVorname = null;
  private JTextField tfName = null;
  private JTextField tfVorname = null;

  /**
   * This method initializes tpCenter	
   * 	
   * @return javax.swing.JTabbedPane	
   */
  private JTabbedPane getTpCenter() {
    if (tpCenter == null) {
      tpCenter = new JTabbedPane();
      tpCenter.addTab("Kunde", null, getPnlCenter(), null);
    }
    return tpCenter;
  }

  /**
   * This method initializes pnlCenter	
   * 	
   * @return javax.swing.JPanel	
   */
  private JPanel getPnlCenter() {
    if (pnlCenter == null) {
      pnlCenter = new JPanel();
      pnlCenter.setLayout(new BorderLayout());
      
      //pnlCenter.add(new CenterCenterPanel(),BorderLayout.CENTER);//2. Möglichkeit: Mit dieser Zeile erscheint der Panel nicht
      pnlCenter.add(getPnlCenterCenter()); //1. Möglichkeit: Mit dieser Zeile erscheint der Panel auf der Oberfläche
    }
    return pnlCenter;
  }

  /**
   * This method initializes pnlCenterCenter	
   * 	
   * @return javax.swing.JPanel	
   */
  private JPanel getPnlCenterCenter() {
    if (pnlCenterCenter == null) {
      lblVorname = new JLabel();
      lblVorname.setText("Vorname");
      lblVorname.setPreferredSize(new java.awt.Dimension(100,16));
      lblName = new JLabel();
      lblName.setText("Name");
      lblName.setPreferredSize(new java.awt.Dimension(100,16));
      pnlCenterCenter = new JPanel();
      pnlCenterCenter.setSize(new java.awt.Dimension(376,219));
      pnlCenterCenter.add(lblName, null);
      pnlCenterCenter.add(getTfName(), null);
      pnlCenterCenter.add(lblVorname, null);
      pnlCenterCenter.add(getTfVorname(), null);
    }
    return pnlCenterCenter;
  }

  /**
   * This method initializes tfName	
   * 	
   * @return javax.swing.JTextField	
   */
  private JTextField getTfName() {
    if (tfName == null) {
      tfName = new JTextField();
      tfName.setPreferredSize(new java.awt.Dimension(140,20));
    }
    return tfName;
  }

  /**
   * This method initializes tfVorname	
   * 	
   * @return javax.swing.JTextField	
   */
  private JTextField getTfVorname() {
    if (tfVorname == null) {
      tfVorname = new JTextField();
      tfVorname.setPreferredSize(new java.awt.Dimension(140,20));
    }
    return tfVorname;
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    dasAnwendungsFenster=new Test();
  }

  /**
   * This is the default constructor
   */
  public Test() {
    super();
    initialize();
  }

  /**
   * This method initializes this
   * 
   * @return void
   */
  private void initialize() {
    this.setSize(300, 200);
    this.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
    this.setContentPane(getJContentPane());
    this.setTitle("JFrame");
    this.setVisible(true);
  }

  /**
   * This method initializes jContentPane
   * 
   * @return javax.swing.JPanel
   */
  private JPanel getJContentPane() {
    if (jContentPane == null) {
      jContentPane = new JPanel();
      jContentPane.setLayout(new BorderLayout());
      jContentPane.add(getTpCenter(), java.awt.BorderLayout.CENTER);
    }
    return jContentPane;
  }

}

Und die separate Klasse:

public class CenterCenterPanel extends JPanel {
  private JLabel lblVorname=null;
  private JLabel lblName=null;

  /**
   * This is the default constructor
   */
  public CenterCenterPanel() {
    super();
    initialize();
  }

  /**
   * This method initializes this
   * 
   * @return void
   */
  private void initialize() {
    this.setSize(300, 200);
    lblVorname = new JLabel();
    lblVorname.setText("Vorname");
    lblVorname.setPreferredSize(new java.awt.Dimension(100,16));
    lblName = new JLabel();
    lblName.setText("Name");
    lblName.setPreferredSize(new java.awt.Dimension(100,16));
  }

}

 

[Antoras]

a) Ist die Methode mit separate Klassen eine GUI aufzubauen sinnvoll (Ersparung von doppeltem Code)?

Schwierig zu sagen. Das ist wahrscheinlich Ansichtssache. Ich mache es immer so, dass ich überlege ob das was ich vorhabe wirklich ein neues Objekt definiert oder ob es eben nur der Verhaltensweise eines Objekts entspricht. Weiterhin macht es meiner Meinung nach keinen Sinn Code in eine eigene Klasse auszulagern wenn es zu spezifisch ist.
D.h. wenn ich ein Auto-Complete-TextField haben möchte, dann macht es Sinn eine Klasse AutoCompleteTextField zu definieren (ein Aspekt, den man hier noch beachten kann ist, dass ein solches Textfeld mehrmals instantiiert werden kann - das zeichnet Objekte ebenfalls aus). Wenn ich aber komplett unterschiedliche Sachen mit einem Objekt machen möchte - es also individuell anpasse, z.B. Hintergrundfarbe ändern oder neue Komponenten hinzufügen - dann würde ich das nie in eine eigene Klasse auslagern (=> es ist kein Objekt, sondern es sind seine Verhaltensweisen und Eigenschaften).

b) Wenn mein Weg Sinn macht, warum wird nichts angezeigt? Stimmt etwas an der Reihenfolge der Objekterzeugung nicht?

Dein Code funktioniert schon, du hast nur vergessen deine GUI-Elemente deinem Panel hinzuzufügen (dem deiner Klasse):

private void initialize() {
  // ...
  add(lblVorname);
  add(lblName);
}

c) Gibt es eine bessere Methode zur Erstellung der Oberfläche bei mehreren ähnlichen Teilkomponenten?

Man kann generalisieren. Das macht aber nur Sinn wenn du wirklich neue Objekte hast, die du dann individuell erweitern kannst.

 

[KrokoDiehl]

a) Ist die Methode mit separate Klassen eine GUI aufzubauen sinnvoll (Ersparung von doppeltem Code)?

Prinzipiell ist das eine gute Idee. Wenn deine Tabs immer nach dem gleichen Muster aufgebaut sind, wäre es auch sinnvoll hier eine allgemeine Klasse zu erstellen, die dieses Muster schon einmal vorgibt, inklusive der Möglichkeit die individuellen Unterschiede zu setzen.

b) Wenn mein Weg Sinn macht, warum wird nichts angezeigt? Stimmt etwas an der Reihenfolge der Objekterzeugung nicht?

Dass der Code

pnlCenter.add(new CenterCenterPanel(),BorderLayout.CENTER);

bei mehrmaligem Aufruf dennoch nur ein Panel zeigt, liegt daran, dass du immer auf

BorderLayout.CENTER

hinzufügst. Ein BorderLayout hat nunmal nur einen CENTER-Bereich, sodass dieser immer wieder überschrieben wird.
Da du von einer JTabbedPane gesprochen hast, vermute ich, dass du eher etwas vorhast wie

myTabbedPane.add(new CenterCenterPanel(), "Tab-Text");

Das ist zumindest das, was ich ohne Lesen des ganzen Codes vermute. Aber vielleicht hat Antoras hier bereits eine bessere Antwort geliefert

c) Gibt es eine bessere Methode zur Erstellung der Oberfläche bei mehreren ähnlichen Teilkomponenten?

"Besser" ist immer so eine Sache, weil es sehr stark davon abhängig ist, was man vorhat und was die eigenen Anforderungen sind.
Aus allgemeiner Programmierersicht würde ich sagen: Doppelte Implementierungen immer vermeiden.