Hallo GUI (2): Anwendungen (Frames) und Applets
Der Rahmen für ein Fensterprogramm
Nun wird es Zeit, sich den Programmrahmen näher anzusehen,
den der Java-Editor selbstständig erzeugt hat,
als wir auf das Frame-Symbol geklickt haben:
import java.awt.*;
// Bibliotheken, in denen die AWT-Klassen ...
import java.awt.event.*;
// ... und die Ereignisklassen deklariert sind.
/**
// Dokumentationskommentar
* Beschreibung
// gehört zu jeder ordentlichen Klasse,
* @version 1.0 vom %DATUM%
// insbesondere, wenn in Bibliothek aufgenommen
* @author %AUTOR%
*/
public class MiniGUI extends Frame {
// Die Klasse Frame ist im AWT-Toolkit deklariert
// Anfang Attribute
// An dieser Stelle werden die Komponenten der
// Ende Attribute
// Benutzeroberfläche und globale Variablen deklariert
public MiniGUI(String title) {
// Der Konstruktor ist die Methode, die bei
// Frame-Initialisierung
// aufgerufen wird, um ein Objekt zu erzeugen. Hier
super(title);
// werden Eigenschaften des Programmframes gesetzt,
addWindowListener(new WindowAdapter() { // z.B. der Fenstertitel,
...
public void windowClosing(WindowEvent evt) { System.exit(0);
}
});
int frameWidth = 300;
// ... die Breite ...
int frameHeight = 300;
// ... und Höhe des Programmfesters.
setSize(frameWidth, frameHeight);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
int x = (d.width - getSize().width) / 2;
// Dann wird die aktuelle Bildschirmgröße ermittelt
int y = (d.height - getSize().height) / 2;
setLocation(x, y);
// Programmfenster wird auf dem Bildschirm postiert
Panel cp = new Panel(null);
add(cp);
// Das Panel ist die Zeichenfläche für Komponenten
// Anfang Komponenten
// An dieser Stelle fügt der Java-Editor
// deine Baukastenelemente ein und setzt die
// Ende Komponenten
//
im Objektinspektor festgelegten Eigenschaften
// Einige Elemente enthalten Listener, die auf
// bestimmte Ereignisse warten. Diese werden
// hier mit Methodenaufrufen kombiniert.
setResizable(false);
setVisible(true);
}
// Anfang Methoden // An dieser Stelle fügt der Java-Editor
// die Methoden ein, auf die die
// Ende Methoden // Bedienungselemente reagieren
public static void main(String[] args) {
// In der Main-Methode wird normalerweise
new MiniGUI("MiniGUI");
// nur ein Objekt der Programmklasse erzeugt.
}
}
Und das Ganze als Applet:
import java.awt.*; // Bibliotheken, in denen die AWT-Klassen ...
import java.awt.event.*; // ... und die Ereignisklassen deklariert sind.
import java.applet.Applet;
// Klassen, die mit dem Browser kommunizieren.
/**
* Beschreibung
// Dokumentationskommentar
* @version 1.0 vom %DATUM% // gehört zu jedem ordentlichen Programm
* @author %AUTOR%
// insbesondere, wenn in Bibliothek aufgenommen
*/
public class MeinApplet extends Applet {
// Anfang Attribute
// An dieser Stelle werden die Komponenten der
// Ende Attribute
// Benutzeroberfläche und globale Variablen deklariert
public void init() {
// Die init()-Methode wird vom Browser aus
gestartet.
Panel cp = new Panel(null);
// In der init-Methode werden die Komponenten des
cp.setBounds(0, 0, 300, 300);
// Applets mit Methodenaufrufen versehen.
add(cp);
// Anfang Komponenten
// Ende Komponenten
}
// Anfang Methoden
// Hier werden die Methoden eingefügt, die
// Ende Methoden
// die Komponenten ausführen sollen.
}
Das Applet besitzt keinen Konstruktor. An seine Stelle tritt die init()-Methode. Das Applet besitzt auch keine Main-Methode. Gestartet wird es aus einer HTML-Seite heraus, deren Grundgerüst man sich vom Javaeditor erzeugen lassen kann:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>CmZoll2-Applet</title>
<meta http-equiv="Content-Type" content="text/html;charset=ISO-8859-1">
</head>
<body>
<h1>MeinApplet-Applet</h1>
<hr>
<applet code="MeinApplet.class" width="300" height="300">
</applet>
<hr>
</body>
</html>
So kann es auch übers Internet ausgeführt werden. Während der Programmerstellung wäre der Aufruf über eine HTML-Seite zu umständlich. Deswegen ruft der Javaeditor zur Ausführung des Applets den so genannten Appletviewer der Java-Entwicklungsumgebung auf. Entscheidend sind eigentlich nur die beiden rot hervorgehobenen Zeilen. Wenn Sie selbst eine HTML_Seite gestalten, müssen Sie lediglich diese Zeilen übernehmen, um das Applet einzubinden.
Handliches Päckchen.
Der Java-Compiler erzeugt aus Ihren *.java-Dateien Bytecode-Dateien mit der Erweiterung *.class. diese haben Sie bisher nicht direkt aufgerufen, sondern über den Java-Editor gestartet. Nun werden sie von der HTML-Seite aufgerufen.
Manchmal produziert der Compiler aus einem Programm ganze Reihe von *,class-Dateien, so dass die Übersicht schwer fällt. Macht nichts: Rufen Sie im Javaeditor den Menübefehl Start -> JAR-Datei -> Erzeugen auf.
Der Javaeditor verpackt auf diese Anweisung hin alle Klassen ihres Programms in ein handliches Päckchen. AR-Dateien (Java-Archive) sind gezippte-Dateien, denen ein "Manifest" beigegeben ist, das Informationen über die enthaltenen Klassen beinhaltet.Wenn Ihr Programm eine Anwendung (Frame) ist, können Sie die JAR-Datei durch Anklicken direkt in Windows starten.
Auch Applets können Sie so verpacken und aus der HTML_Seite heraus starten. Sie müssen nur den Aufruf ein klein wenig verändern. Im Allgemeinen brauchen Sie, damit ein Applet aus einem JAR-Archiv heraus funktioniert, lediglich in der aufrufenden HTML-Seite eine Zeile zu verändern:
Aus <applet code="MeinApplet.class" width="300" height="300">
</applet>
wird <applet code="MeinApplet.class" archive="MeinApplet.jar"
width="300" height="300"> </applet>
Aufgaben: