Logo Logo
InfoHome Themen Projekte Links Software
Themen
JavaHamster
BlueJ
Java
Sprachelemente
Abstrakte Datentypen
Swing
Composite Pattern
AWT > Swing
GUI-Grundstruktur
Farben und Fonts
Layout-Manager
Komponenten 1
Komponenten 2
Komponenten 3
Container
Observer Pattern
Ereignisverarbeitung
MVC-Pattern
Game Of Life
Threads
Aufgaben
Sortieren
HTML
XHTML
CSS
XML
Datenbanken
MySQL
Theoretische Informatik
PHP
Kara
Lego-Roboter
Algorithmen

Ein leeres Swing-Fenster

Unsere erste Swing-Oberfläche besteht lediglich aus einem leeren Fenster.

emptyframe.png

import javax.swing.*;

public class FrameOhneInhalt {

public static void main(String[] args) {
// Default-"Look and Feel" setzen
JFrame.setDefaultLookAndFeelDecorated(true);
// Erzeuge ein Fenster-Objekt
JFrame fenster = new JFrame();
// Setze den Titel des Fensters
fenster.setTitle("Mein erstes Swing Fenster");
// Setze die Größe des Fensters
fenster.setSize(300,150);
// Stelle das Fenster dar
fenster.setVisible(true);
// Setze das Verhalten des Fensters beim Schließen
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Zu beachten ist, dass bei der Verwendung von Swing-Klassen (hier JFrame) diese zunächst importiert werden müssen. Das Paket javax.swing enthält eine Menge an "leicht-gewichtigen" ("leightweight") Komponenten.

In der Praxis hat sich ein etwas anderes Vorgehen für die Erstellung der grafischen Oberfläche einer Applikation durchgesetzt:

import javax.swing.*;

public class FrameOhneInhalt2 extends JFrame {

// Konstruktor für unseren Frame
public FrameOhneInhalt2() {
// Hier werden später die Komponenten hinzugefügt
}

public static void main(String[] args) {
// Default-"Look and Feel" setzen
JFrame.setDefaultLookAndFeelDecorated(true);
// Erzeuge ein Fenster-Objekt
FrameOhneInhalt2 fenster = new FrameOhneInhalt2();
// Setze den Titel des Fensters
fenster.setTitle("Frame ohne Inhalt");
// Setze die Größe des Fensters
fenster.setSize(400,250);
// Stelle das Fenster dar
fenster.setVisible(true);
// Setze das Verhalten des Fensters beim Schließen
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Hier wird mit einer abgeleiteten, eigenen Frame-Klasse gearbeitet. Im Konstruktor dieser neuen Klasse werden später alle Komponenten der grafischen Oberfläche erzeugt und verschachtelt, also in Container verpackt. Im Hauptprogramm erzeugt man dann einfach ein Objekt der eigenen Frame-Klasse. Der Vorteil dieses Ansatzes besteht darin, dass die Applikation nun im Aufbau einem Applet (also einem Java-Programm, das man auf Internetseiten stellen und vom Webbrowser ausführen lassen kann) gleicht und man leicht aus dem einen das andere gewinnen kann.

Frame mit Inhalt

framewithlabel.png

Nun wollen wir unserem Frame als Inhalt die Swing-Komponente JLabel (ein Textfeld) hinzufügen. Ein direktes Hinzufügen von Komponenten zum JFrame ist jedoch nicht möglich. Innerhalb des JFrame ist ein bestimmter Bereich (content pane - der hellgraue Bereich innerhalb des JFrames) als Container für andere Komponenten vorgesehen.

Sämtliche Objekte der grafischen Oberfläche (auch der oben genannte Container für die Komponenten des JFrames) werden als Datenfelder der eigenen Frame-Klasse angelegt und im Konstruktor erzeugt. Die Methode getContentPane() stellt die Verbindung zum Frame-eigenen Container her. Das eigentliche Hinzufügen des JLabels geschieht schließlich mit Hilfe der Methode add(), die am Container-Objekt aufgerufen wird (vgl. Funktions-Projekt).

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

public class FrameMitText extends JFrame {

Container c; // Container dieses Frames
JLabel beschriftung; // Label, das im Frame erscheinen soll

// Konstruktor für unseren Frame
public FrameMitText() {
// Bestimme die Referenz auf den eigenen Container
c = getContentPane();
// Setze Layout
c.setLayout(new FlowLayout());
// Erzeuge das LabelObjekt mit Übergabe des Labeltextes
beschriftung = new JLabel("Label-Text im Frame");
// Hintergrundfarbe setzen
beschriftung.setBackground(new Color(0,0,0));
beschriftung.setForeground(new Color(255,255,255));
beschriftung.setOpaque(true);
// Füge das Label dem Frame hinzu
c.add(beschriftung);
}

public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
FrameMitText fenster = new FrameMitText();
fenster.setTitle("Frame mit Text im Label");
fenster.setSize(400,250);
fenster.setVisible(true);
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Die Klasse Container gehört zum AWT-Paket. Deswegen sind hier zwei import-Anweisungen nötig.

Applet-Version

Um aus unserer ersten kleinen Applikation mit grafischer Oberfläche eine Applet-Version zu machen, sind nur wenige Änderungen nötig. Zunächst einmal erbt unsere Klasse nun nicht mehr von JFrame, sondern von JApplet. Da unser Java-Programm selbst nicht für die Erzeugung eines Objekts unserer Klasse zuständig sein wird, müssen wir keinen Konstruktor programmieren. Der Block, der für die Erzeugung der Komponenten sorgt, wird nun in einer Methode names init untergebracht, die beim Start des Applets automatisch aufgerufen wird. Eine main-Methode gibt es nicht.

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

public class AppletMitText extends JApplet {

Container c; // Container dieses Frames
JLabel beschriftung; // Label, das im Frame erscheinen soll

// Konstruktor für unseren Frame
public void init() {
// Bestimme die Referenz auf den eigenen Container
c = getContentPane();
// Setze Layout
c.setLayout(new FlowLayout());
// Erzeuge das LabelObjekt mit Übergabe des Labeltextes
beschriftung = new JLabel("Label-Text im Frame");
// Füge das Label dem Frame hinzu
c.add(beschriftung);
}

}

Neben der Methode init, haben für Applets die Methoden start, stop und destroy eine besondere Bedeutung, da sie in bestimmten "Lebensabschnitten" des Applets automatisch aufgerufen werden.

  • public void init()
    wird aufgerufen, wenn das Applet erstmals geladen wird und dient zur Initialisierung des Applet-Objekts (sozusagen als Ersatz für den Konstruktor). Hier sollten alle benötigten Objekte (z.B. Swing-Komponenten oder Listener-Objekte) erzeugt werden.
  • public void start()
    wird aufgerufen, wenn das Applet gestartet wird (unmittelbar nach init und jedes mal, wenn die HTML-Seite, in die das Applets eingebettet ist, neu geladen wird). Hier sollten alle notwendigen Aktionen bzw. Prozesse gestartet werden (quasi ein main-Ersatz).
  • public void stop()
    wird aufgerufen, wenn das Applet vorübergehend angehalten wird (jedes Mal, wenn die HTML-Seite, in die das Applet eingebettet ist, nicht mehr angezeigt wird und unmittelbar vor destroy). Hier sollten alle Aktionen, die bei nicht angezeigtem Applet nicht benötigt werden, vorübergehend (bis zum nächsten start-Aufruf) angehalten werden.
  • public void destroy()
    wird aufgerufen, wenn das Applet zerstört wird (weil der Browser beendet wird). Hier sollten alle Aktionen und Prozesse des Applets endgültig beendet werden.

Diese Methoden sind mit leerem Rumpf implementiert, so dass sie prinzipiell immer aufgerufen werden können. In Subklassen wie oben werden dann die benötigten Methoden überschrieben.

Einbettung in HTML

Die Einbettung in eine HTML-Seite geschieht über das applet-Tag.

<applet width="300" height="150" code="AppletMitInhalt.class">
Hier sollte eigentlich ein Java-Applet laufen...
</applet>
  • code="AppletMitInhalt.class"
    legt den Namen der auszuführenden Java-Datei fest. HIER DARF KEIN PFAD STEHEN
  • width="300"
    legt die Breite der Applet-Fläche fest.
  • height=150"
    legt die Höhe der Applet-Fläche fest.

Sollte aufgrund eines Fehlers das Applet in einem Browser nicht angezeigt werden können, so wird lediglich der Text zwischen den Applet-Tags angezeigt. Ein Teil dessen, was im Frame-Beispiel in der main-Methode steckte, findet sich also innerhalb des Applet-Tags in der HTML-Datei wieder. Wenn die Datei AppletMitInhalt.class nicht im selben Verzeichnis wie die aufrufende HTML-Seite gespeichert ist, muss man den Pfad zur .class Datei mit Hilfe des codebase Attributs im Applet-Tag angeben.

» drucken: pdf | html

© 2004-2024 M. Blanke · Ursulaschule · Kleine Domsfreiheit 11-18 · 49074 Osnabrück