Einführung

Einfache Applikationen zu denen auch dieser Java Taschenrechner gehört, lassen sich heut zu Tage relativ bequem und schnell programmieren. Die entsprechenden API's (Application Programming Interface) stellen jedem Programmierer alle notwendigen Funktionen zur Verfügung welche es unter anderem erlauben Fenster und Dialogfelder auf dem Bildschirm zu zeichnen. Dazu enthält die API Definitionen zur Interaktion der einzelnen Softwarekomponenten untereinander. Versucht wird eine Abstraktion zwischen einer High-Level und einer Low-Level Programmiersprache zu erreichen mit Hilfe derer Low-Level Prozesse, wie das Bilden einer Matrix zur Darstellung von Text schnell realisiert werden können.

Hintergrund

In Java existieren drei wesentliche API's zur Erstellung von grafischen Benutzerschnittstellen. Zum einen das AWT (Abstract Window Toolkit), zum anderen Swing und zuletzt das SWT (Standard Widget Toolkit). Die AWT Klassenbibliotheken von Sun lieferten die ersten Frameworks und GUI Routinen für Java Programmierer. Zudem war AWT das erste Entwicklungssystem für Benutzerschnittstellen in den Java Foundation Classes (JFC). Jedoch zeigten sich schnell einige konzeptionelle Fehler beim Design von AWT. Die geringe Abstraktion über die unterstehende native Benutzerschnittstelle führte dazu das es zu Darstellungsproblemen auf verschiedenen Betriebssytemen kam. Während z.B. auf Windows das Programm erwartungsgemäß aussah und funktionierte, konnte es auf Linux ganz anders sein und umgekehrt. In den 90'ern machten sich einige Programmierer einen Spaß daraus indem Sie meinten das Motto von Sun wäre "write once, test everywhere", also "einmal schreiben, überall testen". Dies aber widersprach der Philosophie der Plattformunabhängigkeit von Java.

Zwischen 1997 und 98 führte Sun Swing ein, welches komplett in Java geschrieben war und mehr Möglichkeiten offenbarte. In der zweiten JDK Version wurden die AWT Widgets (engl. Steuerelemente) größtenteils von denen aus dem Swing Toolkit abgelöst. Swing vermeidet die Probleme von AWT indem es seine eigenen Widgets zeichnet. Das bedeutet das Swing-Komponenten direkt von Java gerendert werden und nicht von nativen Betriebssystemkomponenten abhängig sind. Dadurch funktionieren alle Swing-Komponenten auf allen Plattformen, unabhängig davon ob die Plattform eine entsprechende Komponente zur Verfügung stellt oder nicht.
Mittlerweile sprechen viele weitere Gründe für die Nutzung von Swing gegenüber AWT. Darunter die Performance, Vollständigkeit der Klassenbibliotheken und die Entwicklung der Bibliotheken.

Das Problem der optischen Darstellung von Java Programmen mittels Swing, welches darin resultiert das Java Programme nicht so aussehen wie native Programme führte dazu, das IBM 2001 für die Entwicklungsumgebung Eclipse SWT entwickelte. Dabei wurde versucht die Probleme von AWT zu vermeiden indem versucht wird native Widgets durch möglichst dünne Wrapper einzubinden. Das Standard Widget Toolkit Framework greift mittels JNI auf die nativen Komponenten zu. Wenn eine Komponente auf der Plattform nicht verfügbar ist, emuliert SWT diese Komponente. Mittlerweile gibt es verschiedene Meinungen zu den beiden API's. Welches Konzept letztenendes das Bessere ist, lässt sich genauso wenig beantworten, wie die Frage nach dem besten Betriebssystem.

Konzepte von Swing

Ein wichtiger Aspekt der modernen Softwareentwicklung ist das sogenannte Model-View-Controller Schema, ein bedeutendes Architekturmuster welches die wesentlichen Aufgabengebiete in separate und miteinander in Wechselwirkung stehende Komponenten unterteilt. Nämlich das Modell selbst, die Ansicht und den Controller. Während sich der Controller um die Interaktion mit dem Benutzer kümmert, liefert das Modell z.B. Daten und teilt der Ansicht eventuelle Änderungen im Abauf mit. Die Ansicht kümmert sich um die Darstellung der Daten.

Über diese internen Prozesse in unseren Applikationen brauchen wir im Allgemeinen nicht nachzudenken. Wesentlicher Punkt ist, das jede Benutzerfläche eine Wrapper-Klasse besitzt, welche das Modell und die Ansicht speichert und bei Bedarf Abfragen und Antworten ausführt. Zum Beispiel beim Ausfüllen eines Textfeldes. Bei Swing wurde versucht dieses Konzept eins zu eins umzusetzen.

Erste Schritte

Nachdem wir nun ein wenig über die drei Java API's und die Implementation des Model-View-Controller Konzeptes in Swing gelernt haben, wollen wir uns der Programmierung unseres Taschenechners zuwenden. Wir benutzen dazu die kostenlose integrierte Entwicklungsumgebung (IDE) NetBeans 6.0 in der englischen Version. Selbstverständlich erhalten sie NetBeans auch in deutsch. Alternativ dazu kann auch die bekannte Entwicklungsumgebung Eclipse SDK oder ein schlichter Editor verwendet werden. Zunächst starten wir unsere Entwicklungsumgebung und generieren mit Hilfe des Assistenten ein neues Java Projekt mit dem Namen Calculator. Das Tutorial bezieht sich auf das JDK in der Version 1.6.

Vielleicht kennen Sie Formular-Editoren zur Entwicklung der Benutzeroberfläche, wie den Resource Editor in Visual Studio mit welchem per Drag & Drop z.B. Interface Dialogs erzeugt werden können. Das JDK kennt Formular-Editoren als solches nicht. Es gibt zwar in den großen IDE's auch Layout-Werkzeuge, wie den in NetBeans 6.0 neu eingeführten Matisse GUI-Builder, die Funktionen in dieser Richtung unterstützen, aber in der Regel wird in Java der entsprechende Code separat geschrieben. Mit der Entwicklung von Netbeans hat sich der GUI-Builder allerdings sehr verbessert, so dass mittlerweile auch oft zum GUI-Builder gegriffen wird. Auch wenn Sie zum GUI-Builder greifen ist es wichtig zu wissen, was der vom GUI-Builder automatisch erzeugte Code bewirkt.

Lassen Sie uns nun manuell eine neue Java-Klasse generieren. Diese nennen wir entsprechend ebenfalls Calculator. Mit Hilfe des Package Explorers können wir nun unsere Projektdateien überblicken. Öffnen sie die Datei Calculator.java falls diese noch nicht zu sehen sein sollte. Dies erreichen sie indem sie im Package Explorer die Baumstruktur öffnen und die Datei doppelklicken. Die Entwicklungsumgebung hat bereits das Grundgerüst für unseren Taschenrechner erzeugt. Dieses sieht wie folgt aus:

public class Calculator 
{
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        // TODO code application logic here
    }
 
}

Frame erzeugen

In Java werden Fenster die nicht Teil eines übergeordneten Fensters sind Frames genannt. Die Programmierung dieser Frames, also im Allgemeinen von Benutzeroberflächen in Java, geschieht wie schon erwähnt größtenteils über die Swing API. Anhand eines vorangestellten J, wie z.B. JButton oder JFrame, kann man Swing Klassen übrigens von AWT-Klassen unterscheiden.

Wir erzeugen nun zunächst einmal einen leeren Frame welches das Basisfenster unseres Taschenrechners werden soll. Dazu importieren wir die Swing-Klassen mittels import javax.swing.* und erzeugen eine von JFrame abgeleitete Subklasse namens CalculatorFrame in welcher wir unter anderem den Titel unserer Titelleiste definieren.

import javax.swing.*;
 
public class Calculator 
{
   public static void main(String[] args) 
   {
      CalculatorFrame frame = new CalculatorFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      // Frame sichtbar machen
      frame.setVisible(true);
   }
}
 
/**
 * Leeren Frame ohne Größe erzeugen.
 */
class CalculatorFrame extends JFrame
{
   public CalculatorFrame()
   {
      setTitle("Calculator");   // Name der Titelleiste  
   }
}

In unserer Subklasse CalculatorFrame haben wir ein CalculatorFrame-Objekt erzeugt mit welchem wir über die Methode setTitle() den Titelnamen angeben. Desweiteren definieren wir in main() was passieren soll wenn das Frame vom Benutzer geschlossen wird. In diesem Fall soll sich unser Programm schließen. Dies erreichen wir über die Anweisung frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE). Als letztes müssen wir das noch unsichtbare Frame "sichtbar" machen, indem wir die Methode setVisible() mit true aufrufen lassen. Fertig! Nun haben wir das Grundgerüst unseres Taschenrechners, nämlich unser Frame programmiert. Unser Frame besitzt zwar noch keine Dimension bzw. die Größe 0 x 0 Pixel, aber das soll uns zu dem Zeitpunkt nicht allzu sehr stören. Probehalber können Sie dem Frame aber eine bestimmte Fenstergröße mittels setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT) zuweisen.

Panel erzeugen

Mit der Klasse JFrame haben wir unserem Taschenrechner einen Rahmen gegeben, einen sogenannten Container. In Java dienen diese Container im Allgemeinen dazu Komponenten wie Teile der Benutzeroberfläche "aufzunehmen". Für Ausgaben oder Menüleisten werden allerdings nicht Frames benutzt sondern die so genannten Panel. Panels werden durch die Klasse JPanel implementiert und sind selbst Container und Oberflächen. Diese Panels werden in das Frame eingefügt. Das Frame selbst besteht eigentlich aus mehreren übereinander liegenden Layern, nämlich dem Root Pane, dem Layered Pane, dem Glass Pane und dem Content Pane.

Für uns entscheidend ist das Content Pane in welches wir zunächst einmal ein Panel einfügen. Dazu erzeugen wir wiederum mittels Vererbung eine Klasse mit dem Namen CalculatorPanel. Auch diese Klasse stellt eine von der Superklasse JPanel abgeleitete Subklasse dar.

import javax.swing.*;
 
public class Calculator 
{
   public static void main(String[] args) 
   {
      CalculatorFrame frame = new CalculatorFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   }
}
 
class CalculatorFrame extends JFrame
{
   public CalculatorFrame()
   {
      setTitle("Calculator");
      CalculatorPanel panel = new CalculatorPanel();
      add(panel);
   }
}
 
/**
 * Panel Grundfläche für die Rechnertasten und Ergebnisanzeige
 * anlegen
 */
class CalculatorPanel extends JPanel
{
   public CalculatorPanel()
   {
      panel = new JPanel();
   }
 
   private JPanel panel;
}

Der Aufruf von add(Panel) erfolgt seit dem JDK 1.5 automatisch auf dem Content Pane. In früheren Versionen müssen sie dies mittels getContentPane().add(Panel) realisieren.

Layout zeichnen

Für den Taschenrechner benötigen wir ein sogenanntes Layout. Das Layout bestimmt, wie alle Komponenten in einem Frame angeordnet werden, also wie unser Taschenrechner später aussehen wird. Der Matisse GUI-Builder verwendet einen eigenen Layoutmanager (GroupLayout), der seit Version 6 Teil der Java Platform Standard Edition ist, und kann das Layout in das null-Layout konvertieren. Sofern Sie für das Formular kein explizites Layout programmieren, werden alle Komponenten (Buttons, Textfelder, Labels, etc.) zentriert und gleichmäßig im Panel angeordnet. Dies geschieht mit Hilfe des Flow-Layout-Managers, welcher während des Programmablaufs dynamisch die Komponenten anordnet. Java besitzt mehrere Layout-Manager, darunter auch den Border-Layout-Manager. Der Border-Layout-Manager ermöglicht die feste Platzierung einzelner Komponenten im Content Pane des JFrame's.

Unser Taschenrechner soll ein homogenes Layout erhalten, in welchem die Zellen mit den Buttons stehts gleichmäßig groß sein sollen. Dies erreichen wir mit Hilfe des Grid-Layout's welches die Komponenten rasterförmig, wie in einer Tabelle anordnet. Dazu rufen wir im Konstruktor des Grid-Layout-Objekts die Anzahl der Zeilen und Spalten auf.

import java.awt.*;
import javax.swing.*;
 
public class Calculator
{
   public static void main(String[] args)
   {
      CalculatorFrame frame = new CalculatorFrame();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   }
}
 
class CalculatorFrame extends JFrame
{
   public CalculatorFrame()
   {
      setTitle("Calculator");
      CalculatorPanel panel = new CalculatorPanel();
      add(panel);
   }
}
 
class CalculatorPanel extends JPanel
{
   public CalculatorPanel()
   {
      setLayout(new BorderLayout());  // Layout-Manager festlegen
 
      panel = new JPanel();
      // Angabe der Anzahl von Spalten und Zeilen im Konstruktor
      panel.setLayout(new GridLayout(4, 4)); 
      // Panel Komponenten im Centerblock platzieren           
      add(panel, BorderLayout.CENTER);      
   }
 
   private JPanel panel;
}