Java Anwendungsentwicklung – Tag 3 von 10
Von Franz-Martin, CTO bei Java Fleet Systems Consulting

Schwierigkeit: 🟢 Einsteiger bis 🟡 Fortgeschritten
Dauer: ~6-8 Stunden (mit Taschenrechner-Übung)
Voraussetzungen: Tag 1-2 abgeschlossen

🗺️ Deine Position im Kurs

TagThemaNiveauStatus
1Die Desktop-Ära: Warum GUIs?🟢 Grundlagen✅ Abgeschlossen
2AWT & Swing Grundlagen🟢 Grundlagen✅ Abgeschlossen
→ 3Layouts & Event-Handling🟢 Grundlagen👉 DU BIST HIER!
4Komplexe Swing-Komponenten🟡 Fortgeschritten🔜 Kommt als nächstes
5JavaFX: Die „moderne“ Alternative🔴 KOPFNUSS🔒 Gesperrt
6JDBC Grundlagen🟢 Grundlagen🔒 Gesperrt
7JDBC Best Practices🟡 Fortgeschritten🔒 Gesperrt
8JPA Einführung🟢 Grundlagen🔒 Gesperrt
9JPA CRUD & Queries🟡 Fortgeschritten🔒 Gesperrt
10Integration & Ausblick🔴 KOPFNUSS🔒 Gesperrt

Legende: 🟢 Einsteiger-freundlich | 🟡 Erfordert Grundlagen | 🔴 Optional/Anspruchsvoll

⚡ Das Wichtigste in 30 Sekunden

Heute lernst du:

  • ✅ LayoutManager – wie Komponenten automatisch angeordnet werden
  • ✅ BorderLayout, FlowLayout, GridLayout, BoxLayout
  • ✅ Event-Handling – auf Benutzeraktionen reagieren
  • ✅ ActionListener, MouseListener, KeyListener
  • ✅ Das Observer-Pattern in der Praxis

Die zwei goldenen Regeln:

1. NIEMALS setBounds() für Layout verwenden!
2. IMMER Lambda für einfache Listener!

🟢 GRUNDLAGEN: LayoutManager

Warum brauchen wir Layouts?

Stell dir vor, du setzt Komponenten mit festen Pixelpositionen:

// ❌ FALSCH - Das macht man nicht!
panel.setLayout(null);
button.setBounds(50, 50, 100, 30);

Das funktioniert auf DEINEM Bildschirm. Aber:

  • Auf einem 4K-Monitor? Winzig.
  • Auf einem Laptop mit 125% Skalierung? Verschoben.
  • Auf Mac vs. Windows? Andere Schriftgrößen!

LayoutManager lösen das Problem: Sie ordnen Komponenten automatisch an und passen sich an.

Abbildung 1: Die wichtigsten LayoutManager im Überblick

FlowLayout – Der Einfachste

Ordnet Komponenten wie Text: von links nach rechts, Zeilenumbruch bei Platzmangel.

JPanel panel = new JPanel(); // FlowLayout ist Standard!
// oder explizit:
JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT));

panel.add(new JButton("Eins"));
panel.add(new JButton("Zwei"));
panel.add(new JButton("Drei"));

Gut für: Button-Leisten, Toolbars
Schlecht für: Komplexe Formulare

BorderLayout – Der Standard für Fenster

5 Regionen: NORTH, SOUTH, EAST, WEST, CENTER.

JFrame frame = new JFrame();
// BorderLayout ist Standard für JFrame!

frame.add(toolbar, BorderLayout.NORTH);
frame.add(sidebar, BorderLayout.WEST);
frame.add(content, BorderLayout.CENTER);  // Nimmt den Rest!
frame.add(statusBar, BorderLayout.SOUTH);

Abbildung 2: BorderLayout – Das Standard-Layout für JFrame

Die Regeln:

  • CENTER nimmt ALLEN übrigen Platz
  • NORTH/SOUTH: volle Breite, minimale Höhe
  • WEST/EAST: Höhe zwischen N und S, minimale Breite
  • Jede Region: maximal EINE Komponente

💡 Mehrere Komponenten in einer Region? Erst in ein JPanel packen, dann das Panel hinzufügen!

GridLayout – Das Raster

Gleichmäßiges Raster, alle Zellen gleich groß.

JPanel panel = new JPanel(new GridLayout(4, 3, 5, 5));
// 4 Zeilen, 3 Spalten, 5px Abstand

for (int i = 1; i <= 12; i++) {
    panel.add(new JButton(String.valueOf(i)));
}

Perfekt für: Taschenrechner, Kalender, Spielfelder

BoxLayout – Stapeln

Stapelt vertikal (Y_AXIS) oder horizontal (X_AXIS).

JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

panel.add(new JButton("Oben"));
panel.add(Box.createVerticalStrut(10));  // 10px Abstand
panel.add(new JButton("Mitte"));
panel.add(Box.createVerticalGlue());     // Flexibler Füller
panel.add(new JButton("Unten"));

Wichtige Helfer:

  • Box.createVerticalStrut(10) – fester Abstand
  • Box.createVerticalGlue() – flexibler Füller
  • Box.createRigidArea(new Dimension(10, 10)) – feste Box

GridBagLayout – Der Mächtige

Das flexibelste Layout. Zellen können mehrere Spalten/Zeilen überspannen.

JPanel panel = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5);  // Abstand

gbc.gridx = 0; gbc.gridy = 0;
panel.add(new JLabel("Name:"), gbc);

gbc.gridx = 1; 
gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.weightx = 1.0;  // Dehnt sich horizontal
panel.add(new JTextField(20), gbc);

// Button über 2 Spalten
gbc.gridx = 0; gbc.gridy = 1;
gbc.gridwidth = 2;  // 2 Spalten!
panel.add(new JButton("Speichern"), gbc);

Wichtige GridBagConstraints:

  • gridx, gridy – Zellposition
  • gridwidth, gridheight – Über wie viele Zellen?
  • fill – HORIZONTAL, VERTICAL, BOTH, NONE
  • weightx, weighty – Wie viel vom Extra-Platz?
  • anchor – Ausrichtung in der Zelle

⚠️ GridBagLayout ist mächtig, aber komplex. Für 90% der Fälle reicht BorderLayout + BoxLayout!

🟢 GRUNDLAGEN: Event-Handling

Das Observer-Pattern

Abbildung 3: So funktioniert Event-Handling in Swing

Das Prinzip ist einfach:

  1. Event Source (z.B. JButton) erzeugt Events
  2. Listener reagiert auf Events
  3. Du registrierst den Listener bei der Source
// Der Button ist die Event Source
JButton button = new JButton("Klick mich");

// Wir registrieren einen Listener
button.addActionListener(e -> {
    System.out.println("Geklickt!");
});

ActionListener – Der Wichtigste

Für: Button-Klicks, Enter in TextField, MenuItems

// Variante 1: Lambda (empfohlen!)
button.addActionListener(e -> {
    doSomething();
});

// Variante 2: Methoden-Referenz
button.addActionListener(this::handleClick);

// Variante 3: Anonyme Klasse (alte Syntax)
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        doSomething();
    }
});

💡 Welche Variante? Lambda für kurze Aktionen, Methoden-Referenz wenn die Logik in eine eigene Methode gehört.

MouseListener

Für: Maus-Events (Klick, Enter, Exit, Press, Release)

// MouseAdapter ist praktischer - nur überschreiben was du brauchst
panel.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
        if (e.getClickCount() == 2) {
            System.out.println("Doppelklick!");
        }
    }
    
    @Override
    public void mouseEntered(MouseEvent e) {
        panel.setBackground(Color.BLUE);
    }
});

KeyListener

Für: Tastatureingaben

textField.addKeyListener(new KeyAdapter() {
    @Override
    public void keyPressed(KeyEvent e) {
        // Strg+S erkennen
        if (e.isControlDown() && e.getKeyCode() == KeyEvent.VK_S) {
            speichern();
        }
    }
});

DocumentListener

Für: Live-Überwachung von Textfeld-Änderungen (besser als KeyListener!)

textField.getDocument().addDocumentListener(new DocumentListener() {
    @Override
    public void insertUpdate(DocumentEvent e) { aktualisieren(); }
    
    @Override
    public void removeUpdate(DocumentEvent e) { aktualisieren(); }
    
    @Override
    public void changedUpdate(DocumentEvent e) { aktualisieren(); }
    
    private void aktualisieren() {
        String text = textField.getText();
        // Reagiere auf Änderung...
    }
});

💡 Warum DocumentListener statt KeyListener?
DocumentListener reagiert auch auf Copy/Paste!

🟡 PROFESSIONALS: Der Taschenrechner

Lass uns alles zusammenbringen: Ein funktionierender Taschenrechner!

Die Struktur

public class Taschenrechner extends JFrame {
    private JTextField display;
    
    public Taschenrechner() {
        setLayout(new BorderLayout(10, 10));
        
        // Display oben (BorderLayout.NORTH)
        display = new JTextField("0");
        add(display, BorderLayout.NORTH);
        
        // Tasten in der Mitte (GridLayout!)
        JPanel tastenPanel = new JPanel(new GridLayout(4, 4, 5, 5));
        // ... Tasten hinzufügen
        add(tastenPanel, BorderLayout.CENTER);
    }
}

Event-Handling für Tasten

// Für Zifferntasten - Methoden-Referenz
btn.addActionListener(this::zifferGedrueckt);

private void zifferGedrueckt(ActionEvent e) {
    String ziffer = e.getActionCommand();  // Der Button-Text
    display.setText(display.getText() + ziffer);
}

// Für Operatoren - Lambda mit Parameter
btn.addActionListener(e -> operatorGedrueckt("+"));

private void operatorGedrueckt(String operator) {
    // Logik...
}

Vollständiger Code im Download!

💬 Real Talk: Nova und das Layout-Problem

Java Fleet Büro, Mittwochnachmittag.

Nova: „Franz-Martin, mein Formular sieht auf meinem Laptop gut aus, aber auf dem großen Monitor total kaputt!“

Franz-Martin: (schaut auf den Code) „setBounds?“

Nova: „Ja, ich hab die Positionen genau berechnet…“

Franz-Martin: „Das ist das Problem. Du hast für EINEN Bildschirm designed. Was passiert, wenn jemand das Fenster vergrößert?“

Nova: (testet) „Die Buttons bleiben wo sie sind… alles ist in der Ecke.“

Franz-Martin: „Genau. setBounds ist wie ein Foto – es ist fix. Ein LayoutManager ist wie Wasser – es passt sich an.“

Nova: „Okay, aber GridBagLayout sieht so kompliziert aus…“

Franz-Martin: „Brauchst du für ein einfaches Formular nicht. Schau:“

// Hauptfenster: BorderLayout
setLayout(new BorderLayout());

// Titel oben
add(new JLabel("Formular"), BorderLayout.NORTH);

// Formular in der Mitte
JPanel form = new JPanel();
form.setLayout(new BoxLayout(form, BoxLayout.Y_AXIS));
// ... Felder hinzufügen
add(form, BorderLayout.CENTER);

// Buttons unten
JPanel buttons = new JPanel(new FlowLayout(FlowLayout.RIGHT));
buttons.add(new JButton("Abbrechen"));
buttons.add(new JButton("Speichern"));
add(buttons, BorderLayout.SOUTH);

Nova: „Das ist ja viel einfacher!“

Franz-Martin: „BorderLayout für die Grundstruktur, BoxLayout für vertikale Listen, FlowLayout für Button-Leisten. Damit kommst du sehr weit.“

Nova: „Und GridBagLayout?“

Franz-Martin: „Wenn du mal WIRKLICH ein komplexes Layout brauchst. Aber frag dich vorher: Kann ich das Problem mit verschachtelten Panels lösen?“

Nova: „Meistens ja?“

Franz-Martin: „Meistens ja.“

✅ Checkpoint

📝 Quiz

Frage 1: Welches Layout ist Standard für JFrame?

A) FlowLayout
B) GridLayout
C) BorderLayout
D) BoxLayout

Frage 2: Was macht Box.createVerticalGlue()?

A) Erstellt einen festen Abstand
B) Erstellt einen flexiblen Füller, der den übrigen Platz einnimmt
C) Klebt Komponenten zusammen
D) Erstellt eine unsichtbare Box

Frage 3: Warum ist DocumentListener besser als KeyListener für Textfeld-Überwachung?

A) DocumentListener ist schneller
B) DocumentListener reagiert auch auf Copy/Paste
C) KeyListener funktioniert nur für Zahlen
D) Es gibt keinen Unterschied

Frage 4: Welche Lambda-Syntax ist korrekt für einen ActionListener?

A) button.addActionListener(e => doSomething())
B) button.addActionListener(e -> doSomething())
C) button.addActionListener(e :: doSomething())
D) button.addActionListener(-> doSomething())

🎨 Challenge: Bau einen Taschenrechner!

🟢 Level 1 – Basis

  • [ ] Ein Display (JTextField, nicht editierbar)
  • [ ] Zifferntasten 0-9 (GridLayout!)
  • [ ] Klick auf Ziffer → Ziffer im Display Zeit: 30-45 Minuten

🟡 Level 2 – Funktional

  • [ ] Operatoren: +, -, ×, ÷
  • [ ] Gleichheits-Taste berechnet Ergebnis
  • [ ] Clear-Taste Zeit: 45-60 Minuten

🔵 Level 3 – Poliert

  • [ ] Tastatur-Support (KeyListener)
  • [ ] Dezimalzahlen
  • [ ] Fehlerbehandlung (Division durch 0)
  • [ ] Schönes Design mit FlatLaf Zeit: 1-2 Stunden

📝 Quiz-Lösungen

Frage 1: ✅ C – BorderLayout
JFrame verwendet standardmäßig BorderLayout. JPanel verwendet FlowLayout.

Frage 2: ✅ B – Erstellt einen flexiblen Füller
Glue füllt den übrigen Platz. Strut ist ein fester Abstand.

Frage 3: ✅ B – DocumentListener reagiert auch auf Copy/Paste
KeyListener sieht nur Tastenanschläge, nicht programmtische Änderungen.

Frage 4: ✅ B – button.addActionListener(e -> doSomething())
Java verwendet -> für Lambdas, nicht => wie JavaScript.

❓ FAQ

Kann ich Layouts mischen?
Ja! Das ist sogar der Standard. Ein JPanel mit GridLayout in einem JFrame mit BorderLayout ist völlig normal.

Wann brauche ich GridBagLayout?
Wenn du Zellen brauchst, die mehrere Spalten/Zeilen überspannen. Für einfache Formulare reicht oft BoxLayout.

Warum nicht einfach ein GUI-Builder?
Kannst du nutzen! NetBeans und IntelliJ haben GUI-Designer. Aber verstehe erst die Grundlagen, sonst weißt du nicht, was der Builder macht.

Wie mache ich responsive Layouts?
Mit LayoutManagern! Sie sind von Natur aus responsive. Vermeide feste Größen.

📦 Downloads

ProjektInhaltDownload
java-anwendungsentwicklung-tag3.zipLayout-Demos, Taschenrechner, Event-Demo⬇️ Download

Quick Start:

mvn exec:java              # Layout-Showcase
mvn exec:java -Prechner    # Taschenrechner
mvn exec:java -Pevents     # Event-Demo

🔗 Weiterführende Links

RessourceBeschreibung
Visual Guide to LayoutsOracle’s visuelle Übersicht
How to Use GridBagLayoutDetaillierte Anleitung
Event ListenersAlle Listener-Typen

🎉 Tag 3 geschafft!

Was du heute gelernt hast:

✅ LayoutManager verstehen und anwenden
✅ BorderLayout, FlowLayout, GridLayout, BoxLayout
✅ Event-Handling mit verschiedenen Listenern
✅ Lambda und Methoden-Referenzen für Listener
✅ Einen funktionierenden Taschenrechner gebaut

Morgen – Tag 4: Komplexe Swing-Komponenten

JTable, JTree, und das Model-View-Konzept. Es wird spannend!

Fragen? franz-martin@java-developer.online

📚 Das könnte dich auch interessieren

© 2025 Java Fleet Systems Consulting | java-developer.online

Autor

  • Franz-Martin

    65 Jahre alt, CTO und Gründer von Java Fleet Systems Consulting. Franz-Martin ist erfahrener Java-Entwickler, Tutor und Dozent, der das Unternehmen gegründet hat, um sein Wissen weiterzugeben und echte Java-Probleme zu lösen. Er moderiert Team-Diskussionen, mentoriert alle Crew-Mitglieder und sorgt dafür, dass technische Exzellenz mit Business-Realität kombiniert wird.

Tags:

JavaJava SE
← Vorheriger Artikel Komplexe Swing-Komponenten – JTable, JTree und das Model-View-Konzept
Nächster Artikel → AWT & Swing Grundlagen – Dein erstes Fenster und die wichtigsten Komponenten