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.
import java.util.*;
import java.awt.*;
import java.awt.event.*;
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(0,1)); // einspaltiges Gridlayout
rauf = new JButton("Addiere"); // Knopf rauf anlegen
runter = new JButton("Subtrahiere"); // Knopf runter anlegen
schieber = new JSlider(0,100,42); // Slide von 0 bis 100
ergebnis = new JLabel("42 ",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(42); // 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.
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. Da der JSlider nur zu Visualisierung des aktuellen Zahlenwerts benötigt wird, muss auf benutzerdefiniertes Zerren am Slider nicht reagiert werden.
import java.awt.*;
import java.awt.event.*;
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.
import java.awt.BorderLayout;
import javax.swing.JFrame;
public class RaufRunterApp {
public static void main(String args[]) {
JFrame rahmen = new JFrame("RaufRunter-Applikation");
rahmen.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:
import java.awt.BorderLayout;
import javax.swing.JApplet;
public class RaufRunterApplet extends JApplet {
public void init() {
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>
<P>
<APPLET
width=200
height=150
code=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.