:JAVA: Hello World mit BlueJ :JAVA: Hello World mit BlueJBeispiele mit BlueJ 1.3.0 und Mac OS 10.2.8
Bevor es richtig los geht, noch ein paar Hinweise zu Namens- und Datei-Konventionen:
Erstelle ein Projekt "HelloKons", soweit noch nicht geschehen.
Alle Programme in Java sind Klassen-Objekte, also erst mal eine "New Class" erstellen (auf New Class klicken).
Die neue Klasse soll "KonsClass" heißen. BlueJ erzeugt damit eine Quell-Datei "KonsClass.java".
 |
||||
 |
||||
| Auf OK klicken.
Hier ist nun die neue Klasse-> |
||||
|
Schraffiert bedeutet, daß sie noch nicht compiliert wurde, d.h. daß noch keine Datei KonsClass.class erzeugt wurde. |
||||
Nun die Klasse editieren: Mit Doppelklick auf die Klasse im Editor öffnen, den Quelltext abändern (einfach hier kopieren und im Editor einfügen):
/**
* @author Oliver Mezger
* @version 18.10.03
*/
public class KonsClass{
private int x; // interne Variable der Klasse
public KonsClass(){ // Konstruktor der Klasse
System.out.println("KonsClass konstruieren");
x = 0;
}
public void setX(int y){ // Methode zum Setzen von x
System.out.println("setX");
x = y;
}
public int getX(){ // Methode um den Wert von x auszulesen
System.out.println("getX");
return x;
}
public static void main(String[] args){ // Startfunktion
System.out.println("main aufgerufen!");
KonsClass kc = new KonsClass(); // Objekt erzeugen
System.out.println("KonsClass Objekt erzeugt!");
System.out.println(kc.getX());
kc.setX(4711); // die interne Variable auf 4711 setzen
System.out.println(kc.getX());
System.out.println("main am Ende!");
}
}
Download BlueJ-Projekt: HelloKons.zip
Auf "Compile" klicken, die Schraffur verschwindet. Nun mit rechter Maustaste auf die Klasse klicken und "void main(args)" auswählen:
 |
Es wird nun gefragt, mit welchen Argumenten die main-Methode aufgerufen werden soll.
Einfach "OK" klicken! |
In einem Terminalfenster erscheinen nun die Ausgaben... | ||||
main aufgerufen! KonsClass konstruieren KonsClass Objekt erzeugt! getX 0 setX getX 4711 main am Ende! |
||||||
 |
||||||
Es handelt sich hier um ein "Henne-Ei-Problem" wäre main nicht static gäbe es diese Methode erst wenn eine Instanz erzeugt worden wäre.
Nun wird aber in main gerade erst eine Instanz mit "new KonsClass()" erzeugt. Der Ausweg ist der Modifizierer "static", damit ist main auch ohne Instanz vorhanden. Man nennt solche Attribute und Methoden Klassen-Attribute und Klassen-Methoden.
Ohne "static" sind die Attribute und Methoden erst in einer Instanz existent und heisen daher Instanz-Attribute bzw. Instanz-Methoden.
In BlueJ können Objekte von Klassen auch manuell erzeugt werden, mit der rechten Maustaste auf die Klasse klicken und "new KonsClass()" auswählen:
 |
Ein "Objekt konsClas1" vom Typ "KonsClass" wurde erzeugt.
Mit der rechten Maustaste auf dieses Objekt klicken und "Inspect" auswählen: |
||||
| Die Methode "int getX()" aufrufen.
Die Methode "void setX(y)" aufrufen und den Wert 1234 übergeben. "Inspect" aufrufen. Mit "Remove" die Klasse wieder entfernen. |
|||||
 |
 |
||||
 |
|||||
Konsole ist ja nett, aber wir wollen Graphik und Buttons, also ein GUI (Graphical User Interface)! Es gibt nun zwei Möglichkeiten - AWT oder Swing?
Diese Klassen stellen Buttons und Co unter Zuhilfenahme der jeweiligen Plattform-Komponenten des Betriebssystems dar (Peer-Ansatz). Damit sieht ein Button unter Windows wie ein Windows-Button und unter Mac wie Mac-Button aus. Damit beschränkt sich die AWT auf diejenigen GUI-Komponenten, die von allen unterstützen Betriebssystemen dargestellt werden können.
Vorteil für uns: Keine grossen Probleme mit alten IE auf Windows (man kann den Opa auch mit Orginal-Sun-JavaVM-Plugin nachrüsten) und ist etwas einfacher..
Die Swing-Komponenten sind vollständig in Java implementiert und vom jeweiligen Betriebssystem unabhängig (lightweight). Auf allen Rechnern ergibt sich dadurch ein einheitliches Aussehen. SwingKlassen sind am 'J' erkennbar: JApplet, JFrame, JButton usw..
Eine Application ist eine vollständige Anwendung mit allen Rechten und Möglichkeiten. Ein Applet ist als ein in den Browser ladbares Miniprogramm gedacht das dort in einer sicheren Umgebung (Sand-Box) läuft (soll nicht auf lokale Dateien des Rechners zugreifen können). Ein Applet kann allerdings auch in einem Applet-Viewer gestartet werden, und hat dann praktisch alle Rechte einer Application.
Es gibt die Möglichkeit, Hybrid-Applets zu schreiben, die auch ohne Applet-Viewer als Application gestartet werden können.
Bisher haben sich die Ausgaben der Klasse auf das Terminalfenster (Konsole) beschränkt. Nun soll eine Klasse "FrameClass" erzeugt werden,
die über in eigenes Fenster (Frame) verfügt.
Erzeuge ein neues Projekt "HelloFrame" mit der Klasse "FrameClass":
/* @author Oliver Mezger
* @version 12.11.03
*/
import java.awt.*; // die nötigen Komponenten müssen importiert werden
import java.awt.event.*;
public class FrameClass extends Frame{ // unsere FrameClass erweitert Frame (Vererbung)
public FrameClass(String title){ // Konstruktor der Klasse
super (title); // den Konstruktor der Elternklasse Frame aufrufen
System.out.println("Konstruktor aufgerufen!");
add ("North", new Button ("Hello World Button"));
setSize (250,150); // die Grösse des Frames setzen
setVisible(true); // der Frame soll sichtbar sein
addWindowListener(new WindowAdapter(){ // Objekt soll beendet werden können
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public void paint(Graphics g){ // diese Methode wird immer aufgerufen wenn gezeichnet werden soll
g.setColor(Color.yellow);
g.fillRect(20, 70, 200, 50);
g.setColor(Color.black);
g.drawString("Sample AWT-Frame", 50, 100);
}
public static void main(String[] args){ // Startfunktion
System.out.println("main aufgerufen!");
new FrameClass("Banane"); // Objekt erzeugen
System.out.println("FrameClass Objekt erzeugt!");
System.out.println("main am Ende!");
}
}
Download BlueJ-Projekt: HelloFrame.zip
Das Programm erzeugt das Frame mit dem Titel "Banane" und eine Ausgabe auf dem Terminalfenster:
 |
||
main aufgerufen! Konstruktor aufgerufen! FrameClass Objekt erzeugt! main am Ende! Man beachte, daß main beendet ist und das Frame weiter besteht! |
||
Das Applet kann im Applet-Viewer oder auf eine Web-Seite betrachtet werden.
Hier nun die Beschreibung der wesentlichen Komponenten, Kommentare von BlueJ wurden entfernt:
import java.applet.Applet;
import java.awt.*;
public class ApplClass extends Applet{
private int x;
public void init(){}
public void start(){}
public void paint(Graphics g){
g.setColor(Color.white);
g.fillRect(0, 0, 200, 100);
g.setColor(Color.black);
g.drawString("Sample Applet", 20, 20);
g.setColor(Color.blue);
g.drawString("created by BlueJ", 20, 40);
}
public void stop(){}
public void destroy(){}
public String getAppletInfo(){
return "Title: BlueJ Applet Demo\n" + "Author: Bruce Quig\n" +
"A simple applet that draws two strings.";
}
public String[][] getParameterInfo(){
String paramInfo[][] = {
{"firstParameter", "1-10", "description of first parameter"},
{"secondParameter", "boolean", "description of second parameter"}
};
return paramInfo;
}
}
Download BlueJ-Projekt: HelloApplet.zip
| public void init () {....} | wird nur dann aufgerufen, wenn der Browser zum ersten Mal die Appletklasse lädt. |
|---|---|
| public void start () {....} | wird nach der init-Methode aufgerufen, wenn das Applet sichtbar wird. |
| public void stop () {....} | wird aufgerufen, wenn sich das Applet nicht mehr auf dem Bildschirm befindet. |
| public void destroy () {....} | wird dann aufgerufen, wenn das Applet nicht mehr benötigt wird. Dies geschieht normalerweise beim Verlassen der HTML-Seite, spätetens jedoch beim Verlassen des Browsers. |
| public void paint (Graphics g) {....} | wird aufgerufen, wenn das Appletzeichengebiet neu dargestellt werden muss. Dies ist der Fall beim ersten Start des Applets, beim Verschieben des Browser-Fensters, bzw. wenn das Applet vom Hintergrund in den Vordergrund gebracht wird. Die paint-Methode hat als Parameter ein Grafikobjekt (Klasse Graphics). Daher muss vorher das entsprechende Package (java.awt.Graphics) importiert werden. |
| public void update () {....} | wird als erstes aufgerufen, wenn der Bildschirm neu aufzubauen ist. Diese Methode löscht das Gebiet des Applets und ruft die paint-Methode auf. |
Eine HTML-Seite ist ein Text, der mit sogenannten Tags versehen wird. Diese werden in spitze Klammern gesetzt und von den Browsern entsprechend interpretiert. Jeder Tag muss geöffnet und mit der gleichen Bezeichnung mit Schrägstrich (Slash) wieder geschlossen werden. Es ergibt sich folgender Aufbau:
<html>
<head>
<title>Fensterüberschrift</title>
</head>
<body>
Hier steht nun der Inhalt der Seite.
Einbau des Applets
<applet CODEBASE="Verzeichnisname des Applets" CODE="Name des Applets.class" width=300 height=300>
</applet>
</body>
</html>
Befinden sich die HTML-Seite und das Applet im gleichen Verzeichnis, so kann CODEBASE entfallen. Mit width und height wird die Größe des Fensters, in dem das Applet dargestellt wird, festgelegt.
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class ApplClass extends Applet{
public ApplClass(){ // Konstruktor
}
public void paint(Graphics g){
g.setColor(Color.white);
g.fillRect(0, 0, 200, 100);
g.setColor(Color.black);
g.drawString("Sample Applet", 20, 20);
g.setColor(Color.blue);
g.drawString("created by OLLY", 20, 40);
}
public static void main(String[]args){
Frame f = new Frame("Testi");
f.add(new ApplClass());
f.setSize(200,200);
f.setVisible(true);
f.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}
ApplClass.jar kann auch als Application ausgeführt werden. Wer will kann es "unZippen" und die Dateien anschauen...
<applet archive="ApplClass.jar" code="ApplClass.class" width="300" height="200"></applet>
Swing funktioniert deutlch anders als AWT, da hier gemalt werden soll, ist es notwendig ein JPanel in das JFrame einzubauen (auf JFrame soll nicht gezeichnet werden).
/* @author Oliver Mezger
* @version 12.11.03
*/
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class SwingFrame extends JPanel { // die Zeichenflaeche als Traeger der Komponenten ein JPanel
public static void main(String[] args){ // Startfunktion
System.out.println("main aufgerufen!");
JFrame frame = new JFrame("Banane"); // Objekt erzeugen
System.out.println("JFrame Objekt erzeugt!");
frame.getContentPane().add(new SwingFrame()); // das JPanel im JFrame hinzufuegen, fuellt den sichtbaren Bereich voll aus
frame.setSize(250,150); // Groesse des JFrame setzen
frame.setVisible(true);
frame.addWindowListener(new WindowAdapter(){ // Objekt soll beendet werden können
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
System.out.println("main am Ende!");
}
public SwingFrame(){ // Konstruktor der Klasse (JPanel Kind)
System.out.println("Konstruktor aufgerufen!");
add ("North", new JButton ("Hello World Button")); // einen JButton zum JPanel hinzufuegen
}
public void paintComponent(Graphics g){ // diese Methode wird immer aufgerufen wenn gezeichnet werden soll
g.setColor(Color.yellow);
g.fillRect(20, 70, 200, 50);
g.setColor(Color.black);
g.drawString("Sample Swing-Frame", 50, 100);
}
}
Download BlueJ-Projekt: HelloSwingFrame.zip
 |
Eine weitere Betrachtung von Swing erscheint mir momentan nicht sinnvoll, da zunächst nur die Komplexität des Quelltextes zunimmt ohne direkten Nutzen für die Applikation.
|
Hello World in Applet (Swing)
Hybrid-Anwendung (Swing)