Literatur

BorderLayout

Das BorderLayout zählen wir zu den „höheren“ Layout-Managern in dem Sinne, dass es praktisch mit Sicherheit selbst JPanels oder andere Container enthalten wird und nicht Controls: es ist dazu gedacht, einen Rahmen für Userinterfaces von Programmen auf oberster Ebene zur Verfügung zu stellen.

Das BorderLayout teilt seinen Container in 5 Bereiche: einen oberen und unteren über die gesamte Breite und drei vertikale Streifen dazwischen. Insbesondere, als man nach belieben Bereiche unbenutzt lassen kann, erfüllt dieses grundlegende Layout die Anforderungen für alle möglichen Arten von Programmen: angefangen von Filebrowsern (oben: Menü und Buttonbar – links: ein Baum – mitte: eine Anzeigefläche – unten: eine Statuszeile) oder Mailreadern (zusätzlich rechts: ein einzelnes Mail) bishin zu allgemeinen Office-Programmen wie Textverarbeitung oder Tabellenkalkulation lässt sich dieses Schema immer wieder erkennen. Es ist sicher eine gute Übung, sich die Programme, mit denen Sie sonst so arbeiten, etwas genauer in Hinblick auf den strukturellen Aufbau ihres jeweiligen Userinterface anzuschauen und zu überlegen, inwieweit sich diese mit einem BorderLayout darstellen lassen würden – Sie werden überrascht sein.

Das folgende Beispiel bauen wir wieder in netbeans mit matisse auf. Wieder, wie beim GridLayout, nehmen wir JButtons, um die einzelnen Felder sichtbar zu machen. Nicht etwa, weil wir am Ende ein Userinterface aus 5 Buttons haben wollen, sondern weil Buttons das Prinzip am besten sichtbar machen: das gesetzte Element wird „aufgeblasen“, sodass es seinen gesamten Bereich ausfüllt. In einem realen Entwicklungsprojekt werden Sie statt der Buttons wahrscheinlich wieder JPanels nehmen und so Ihr Interface hierarchisch gestalten.

Beachten Sie bitte, dass wir von dem Punkt ausgehen, der im Einleitungsabschnitt beschrieben ist: ein JFrame, das ein JPanel enthält, welchem wir das BorderLayout zuweisen (zu erkennen im Schirmschuss bei der grünen Markierung. Das Layout weisen Sie zu, indem Sie das JPanel dort rechtsklicken, und aus dem Kontextmenü „set Layout“ – „BorderLayout“ auswählen. Das Icon, das daraufhin im Baum erscheint, zeigt bereits das grundlegende Design.)

BorderLayout in Netbeans 1

Anm.: Sollte der „Navigator“ bei Ihnen ausgeblendet sein, können Sie ihn mit Strg+7 anzeigen.

Nun können wir 5 Elemente verteilen. Dazu wählen wir rechts bei den „Swing Controls“ den „Button“ und – ohne ein weiteres mal zu klicken und ihn damit zu platzieren – fahren erst einmal zur Orientierung über das Panel (5 entsprechende Schirmschüsse sind hier übereinander gelegt):

BorderLayout Platzierung in Netbeans

An der Position, wo Sie klicken, wird jButton1 platziert – wir nehmen den oberen Bereich. Beachten Sie, wie der Button „sein“ gesamtes Feld ausfüllt!

BorderLayout Platzierung oben

Anm.: Wenn Sie den ersten Button in die Mitte legen, scheint das JPanel voll zu sein, aber Sie können einfach wie gezeigt fortfahren, weitere Buttons zu verteilen!

Wir setzen die JButtons 2-5 und erhalten das „fertige“ Layout:

BorderLayout mit JButtons

Wie schon beim GridLayout halten wir fest: Beachten Sie, dass das BorderLayout die Elemente grundsätzlich „aufbläst“, sodass sie ihre gesamte Zelle im Raster ausfüllen. Bei den hier verwendeten JButtons ist das sehr schön sichtbar (deswegen haben wir sie verwendet), bei JLabels (die nur einen Text anzeigen), würde man davon gar nichts bemerken – obwohl es passiert! 

Jede Zelle nimmt nur ein einziges Element auf in einer realen Entwicklung wird das so gut wie immer selbst ein Container sein.

Auch hier Quellcode, mit dem Sie das Beispiel mit copy und paste erzeugen können:

 
package gui;
 
/**
 * Demo für den Layout-Manager BorderLayout.
 * 
 * Wenn Sie dieses Codebeispiel zum Laufen bringen wollen, beachten Sie, dass 
 * Sie den Quelltext in einer Datei namens BorderLayoutDemo.java speichern 
 * (Achtung auf Groß-und Kleinschreibung) und dass sich die Datei in einem 
 * Unterordner „gui“ unter Ihrem Projektordner befinden muss.
 *
 * Die meisten Swing-Formulare leiten javax.swing.JFrame ab.
 * 
 * @author phaidros
 */
public class BorderLayoutDemo extends javax.swing.JFrame {
 
    // Die Objektvariablen für die Elemente auf dem JFrame:
 
    // Auf dem JPanel wird alles angeordnet. 
    // Es ist das Element, dem das Flow-Layout zugewiesen wird
    private javax.swing.JPanel jPanel1 = new javax.swing.JPanel();
 
    // Die sichtbaren Elemente werden als Objektvariablen angelegt:
    private javax.swing.JButton jButton1 = 
           new javax.swing.JButton( "jButton1" );
    private javax.swing.JButton jButton2 = 
           new javax.swing.JButton( "jButton2" );
    private javax.swing.JButton jButton3 = 
           new javax.swing.JButton( "jButton3" );
    private javax.swing.JButton jButton4 = 
           new javax.swing.JButton( "jButton4" );
    private javax.swing.JButton jButton5 = 
           new javax.swing.JButton( "jButton5" );
 
    /**
     * Der Konstruktor.
     */
    public BorderLayoutDemo() {
 
        // Was soll bei Klick auf das System-X rechts oben passieren:
        // Das Programm soll gänzlich beendet werden.
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
 
        // Beachten Sie, dass Swing gar nicht so selten auf Elemente der 
        // Vorgänger-Bibliothek awt zugreift. Auch Das BorderLayout gehört 
        // eigentlich zum awt. Das JPanel bekommt sein Layout:
        jPanel1.setLayout( new java.awt.BorderLayout() );
 
        // Die Implementierung von ActionListenern sehen Sie in den 
        // Codebeispielen für das FlowLayout (einzelner Listener für einen
        // einzelnen Button) oder auch beim GridLayout (ein Listener für ein
        // ganzes Array von Buttons. Hier verzichten wir auf die Implementierung
        // eines Listeners, da das BorderLayout im Grunde nur Container 
        // enthalten wird, nie Controls wie die JButtons, die wir hier benützt
        // haben.
 
        // Hier werden die JButtons dem Panel hinzugefügt
        jPanel1.add(jButton1, java.awt.BorderLayout.PAGE_START);
        jPanel1.add(jButton2, java.awt.BorderLayout.PAGE_END);
        jPanel1.add(jButton3, java.awt.BorderLayout.LINE_START);
        jPanel1.add(jButton4, java.awt.BorderLayout.CENTER);
        jPanel1.add(jButton5, java.awt.BorderLayout.LINE_END);
 
        // Anm: Griffiger und leichter zu merken finden wir die alten 
        // Konstanten, die immer noch benützt werden können:
//        jPanel1.add(jButton1, java.awt.BorderLayout.NORTH);
//        jPanel1.add(jButton2, java.awt.BorderLayout.SOUTH);
//        jPanel1.add(jButton3, java.awt.BorderLayout.WEST);
//        jPanel1.add(jButton4, java.awt.BorderLayout.CENTER);
//        jPanel1.add(jButton5, java.awt.BorderLayout.EAST);
 
        // Das Panel zum aktiven, sichtbaren Inhalt des JFrame machen:
        this.getContentPane().add ( jPanel1 ) ;
 
        // Alle Elemente auf kleinstmögliche Größe bringen
        pack();
 
        // Anm.: Durch das pack() sieht dieses Beispiel etwas anders aus, als 
        // das, das Sie ev. mit matisse zusammengebaut haben, weil die Buttons
        // klein sind. Aber wenn Sie das Fenster skalieren werden Sie sehen,
        // dass wir hier genau dasselbe Design erzeugt haben
    }
 
    /**
     * Zeigt ein JFrame im BorderLayout mit je einem Button pro Bereich an.
     *
     * Jedes Java-Programm beginnt bei einer Methode main() zu laufen, so auch 
     * dieses. Beachten Sie, dass die Methode main() in jeder beliebigen 
     * Klasse stehen könnte, die Zugriff auf BorderLayoutDemo hat, also auch in 
     * ihr selbst – also hier:
     */
    public static void main(String args[]) {
        // Ein Objekt der Klasse erzeugen und sichtbar machen.
        new BorderLayoutDemo().setVisible ( true );
    }    
 
}

Text, Code und Bilder © Phaidros (Gast-Autor)