prev up inhalt next

Swing-Beispiel

In diesem Abschnitt wird eine einfache grafische Anwendung vorgestellt, in der eine Zahl per Knopfdruck wahlweise hoch- oder runtergezählt und sowohl numerisch als auch per Slider angezeigt wird. Diese Anwendung wird zum Einen als eigenständige Applikation und zum Anderen als Applet, welches in einem Webbrowser zu betrachten ist, realisiert.

Die Anwendung besteht aus fünf Klassen. Der Kern mit dem grafischen User-Interface und dem Eventhandling ist gemäß der Model-View-Controller-Architektur in den Klassen Zustand (Model), RaufRunter(View) und KnopfKontrollierer (Controller) implementiert. Die Klassen RaufRunterApp und RaufRunterApplet stellen die Top-Level Container dar, in denen die Anwendung als Application bzw. als Applet ausgeführt wird.

package raufrunter;

import java.util.*;
import java.awt.*;
import javax.swing.*;

public class RaufRunter extends JPanel implements Observer {

  private JButton rauf;                           // Button zum raufzaehlen
  private JButton runter;                         // Button zum runterzaehlen
  private Zustand z;                              // Zustand
  private JLabel  ergebnis;                       // Label zur Anzeige 
  private JSlider schieber;                       // Slider zur Visualisierung
  private Font    font;                           // Font fuer Label

  public RaufRunter() {                           // Konstruktor
 
    setLayout(new GridLayout(4,1));               // einspaltiges Gridlayout 

    rauf   = new JButton("Addiere");              // Knopf rauf anlegen
    runter = new JButton("Subtrahiere");          // Knopf runter anlegen
    schieber = new JSlider(0,100,50);             // Slide von 0 bis 100
    ergebnis = new JLabel("50",JLabel.CENTER);    // JLabel ergebnis anlegen
    font = new Font("SansSerif",Font.BOLD,30);    // Schriftgroesse einstellen
    ergebnis.setFont(font);                       // an Label uebergeben

    add(rauf);                                    // JButton rauf einfuegen
    add(ergebnis);                                // JLabel ergebnis einfuegen
    add(schieber);                                // Slider einfuegen
    add(runter);                                  // JButton runter einfuegen
    
    z = new Zustand(50);                          // Zustand initialisieren 
    z.addObserver(this);                          // dort als Observer eintragen

    KnopfKontrollierer raufK;                     // fuer rauf-Eventhandling
    raufK = new KnopfKontrollierer(z,+1);         // soll hochzaehlen 
    rauf.addActionListener(raufK);                // Listener an rauf haengen

    KnopfKontrollierer runterK;                   // fuer runter-Eventhandling
    runterK = new KnopfKontrollierer(z,-1);       // soll runterzaehlen 
    runter.addActionListener(runterK);            // Listener an runter haengen
  }

  public void update(Observable z, Object dummy){ // wird aufgerufen bei notify
    ergebnis.setText(((Zustand)z).get() + "");    // Zaehlerstand anzeigen
    schieber.setValue(((Zustand)z).get());        // Zaehlerstand visualisieren
  }
}

Die Klasse RaufRunter stellt die View dar und stammt von JPanel ab. Bei der Instanziierung wird zunächst das Layout festgelegt und im weiteren werden die benötigten Komponenten erstellt. Für das Programm wird ein JButton zum Hochzählen, ein JButton zum Runterzählen, ein JLabel zur Anzeige und ein JSlider zur Visualisierung des Zahlenwerts benötigt. Alle Komponenten werden innerhalb des einspaltigen Gridlayouts auf dieselbe Größe gesetzt. Diese ist nicht fest und kann sich ggf. durch die Größe des Top-Level Containers (das Applet oder die Applikation) ändern. Diese vier Komponenten werden dem JPanel hinzugefügt, welches in den jeweiligen Top-Level Container eingefügt werden kann.

Weiterhin wird eine Instanz der Klasse Zustand initialisiert, welche die Rolle des Model übernimmt, sowie zwei Instanzen des KnopfKontrollierer, welche als ActionListener beim jeweiligen Knopf eingehängt werden.

Schließlich wird mit der Methode update das Interface Observer implementiert, wodurch auf eine Zustandsänderung reagiert werden kann, die vom Observable per notify gemeldet wird.

package raufrunter;

import java.util.Observer;
import java.util.Observable;
 
public class Zustand extends Observable{       // Zustand

  private int zaehler;                         // Zaehler
    
  public Zustand(int zaehler){                 // Konstruktor
    this.zaehler=zaehler;                      // initialisiere Zaehler
  }              
    
  int get(){return zaehler;}                   // Zaehler abfragen
    
  void aendern(int delta){                     // Zaehlerstand aendern
    zaehler = zaehler + delta;                 // erhoehen oder erniedrigen
    setChanged();                              // notiere Aenderung 
    notifyObservers();                         // Observer benachrichtigen
  }
}

Die Klasse Zustand stellt das Model dar und beinhaltet den aktuellen Zählerstand. Sie ist von der Klasse Observable abgeleitet und verfügt daher über Methoden setChanged und notifyObservers, durch die beim Observer die Methode update gestartet wird. Durch den Konstruktor erhält der Zähler seinen initialen Wert und mit der Methode get() kann der aktuelle Zählerstand in Erfahrung gebracht werden.

Die Klasse KnopfKontrollierer stellt den Controller dar und ist für das Eventhandlung zuständig. Dazu wird das Interface ActionListener implementiert, welches aus der einzigen Methode actionPerformed besteht. Dieser Listener wird in unterschiedlichen Instanziierungen den beiden JButtons übergeben. Bei einem klick auf einen Button wird dieser Event an den Listener übergeben und dort die Methode actionPerformed aufgerufen.

package raufrunter;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
public class KnopfKontrollierer implements ActionListener {

  private Zustand z;                                 // Verweis auf Zustand
  private int delta;                                 // spezifischer Inkrement

  public KnopfKontrollierer(Zustand z, int delta) {
    this.z       = z;                                // merke Zustand
    this.delta   = delta;                            // merke Inkrement
  }

  public void actionPerformed(ActionEvent e) {       // bei Knopfdruck
    z.aendern(delta);                                // Zustand aendern
  }        
}

Es fehlem noch die beiden Top-Level Container, welche den Rahmen für die Anwendung bilden, in dem die Instanz der Klasse RaufRunter ausgeführt wird.

package raufrunter;

import java.awt.BorderLayout;
import javax.swing.JFrame;

public class RaufRunterApp {
  
  public static void main(String args[]) {
    JFrame rahmen = new JFrame("RaufRunter-Applikation");
    rahmen.getContentPane().add(new RaufRunter(), BorderLayout.CENTER);
    rahmen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    rahmen.pack();
    rahmen.setVisible(true);
  }
}

In RaufRunterApp wird ein JFrame erzeugt und in dessen ContentPane wird die RaufRunter-Komponente eingefügt. Mit der Methode setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) wird festgelegt, dass die Applikation beim Schließen des Fensters endet, sonst würde sie weiterlaufen und wäre lediglich unsichtbar.

Mit der Methode pack() wird die Größe der einzelnen Componenten bestimmt und dem Top-Level Container mitgeteilt. Zuletzt muss das JFrame mit der Methode setVisible sichtbar gemacht werden.

Um die Anwendung als Applet im Browser zu betrachten wird die Klasse RaufRunterApplet benötigt:

package raufrunter;

import java.awt.BorderLayout;
import javax.swing.JApplet;

public class RaufRunterApplet extends JApplet {

  public void init() {
    getContentPane().add(new RaufRunter(), BorderLayout.CENTER);
  }
}

Beim Start als Applet instanziiert der Appletviever (oder Browser) eine Instanz der Klasse RaufRunterApplet und ruft dort die init-Methode auf. In dieser Methode wird eine neue Instanz der Klasse RaufRunter erzeugt und der ContentPane des Applets hinzugefügt.

Das Applet wird dann in eine HTML-Seite eingebunden:

<HTML>
  <HEAD> <TITLE>RaufRunter-Applet</TITLE></HEAD>
  <BODY>
    <CENTER>
    <H1>RaufRunterApplet</H1>
    <APPLET width=200 height=150 
            code    ="raufrunter.RaufRunterApplet.class" 
            archive ="raufrunter.jar">
    </APPLET>
    </CENTER>
  </BODY>
</HTML>

Achtung: Da das Applet Swing-Klassen benutzt, kann es notwendig sein, ein aktuelles Java Plugin zu installieren.



RaufRunterApplet


prev up inhalt next