Was sind Packages?

Ein Java Programm besteht ausschließlich aus Klassen, dazugehörigen Methoden, Variablen und Objekte. Viele Klassen sind schon vordefiniert und können von den Java-Programmierern verwendet und erweitert werden. Die Klassen sind in Klassenbibliotheken nach Themenbereichen zusammengefasst. Diese Bibliotheken heißen "Packages". z.B. gibt es für die Grafikprogrammierung ein Package "AWT" (=Abstract Window Toolkit). Packages können auch geschachtelt sein, z.B. enthält das Package "AWT" das untergeordnete Package "AWT.image". Wichtig ist, dass jede Klasse nur zu einem Package gehören darf.

Wie werden Packages in Klassen eingebunden?

Packages werden über die Import-Anweisung eingebunden:

import java.awt.*;
import java.applet.Applet;

Mit dem * werden alle Klassen, die es in dem Package awt gibt importiert. Es ist auch möglich, nur eine bestimmte Klasse aus einem Package einzubinden: mit java.applet.Applet wird nur die Applet-Klasse des applet-Packages eingebunden.

Wie können eigene Packages erzeugt werden?

Der Programmierer kann nicht nur die bestehenden Packages importieren, er hat auch die Möglichkeit neue Packages anzulegen. Die Package-Deklaration legt den Namen des Packages fest, dem die deklarierten Klassen oder Interfaces angehören sollen. Sie steht immer am Anfang einer Übersetzungseinheit, das bedeutet in der Regel am Anfang einer oder selten auch mehr als einer Klassen- oder Interfacedeklaration.

package einPackage;

public class Fakultaet
{static public long fakultaet(long n)
{...
}
}

Das Java-Programm Fakultaet.java muß in einem Verzeichnis namens "einPackage" liegen. Nun können weitere Klassen deklariert werden, die ebenfalls in dem neuen Package liegen.

Wie bei den bereits vorgefertigten Packages des JDK, können auch eigene Packages von anderen Klassen importiert werden:

import einPackage.Fakultaet;
public class Fakultaettest1
{...}

Welche Packages sind im JDK enthalten?

Hier sind nicht alle, aber die wichtigsten Packages aufgeführt:

Welche Arten von Java-Programmen gibt es?

Ein Applet ist, wie der Name bereits andeutet, eine Mini-Applikation, ein kleines Programm, das für die Ausführung in einem Web-Browser oder in einem Appletviewer bestimmt ist. Applets unterliegen strengen Sicherheitsbestimmungen: Da Applets im WWW übertragen werden und der Anwender nicht sicher sein kann, ob das Applet Schaden anrichten wird, können Applets nicht auf das lokale Dateisystem zugreifen. Außerdem dürfen sie nur mit dem Server, von dem sie geladen wurden, kommunizieren und keine Verbindung zu anderen Servern aufnehmen und dürfen auf dem lokalen Rechner keine Programme starten. Die meisten Browser unterstützen das sogenannte "Sandkasten"-Verfahren: Applets können lediglich in einem sicheren beschränkten Raum agieren, der "Sandbox". Mit der Java 2- Version wurde das unflexible Sandbox-Verfahren zugunsten eines flexibleren Sicherheitsmechanismus aufgegeben. Das heißt, Browser gewähren, je nach Aktualität ihrer Java-Virtual-Machine, unterschiedliche Rechte. Neben dem Sandbox-Verfahren besteht die Möglichkeit, Applets mittels javakey und jar zu signieren und ihnen dadurch erweiterte Rechte einzuräumen.

Applets enthalten im Gegensatz zu Applikationen keine Main()-Methode - Denn ein Applet ist keine Java-Anwendung, sondern eine Java-Klasse, die von einer bereits laufenden Java-Anwendung, wie etwa einem Web-Browser, geladen und ausgeführt wird. Der Browser erzeugt nach dem Laden des Applets ein Applet-Objekt und ruft bestimmte Methoden auf. In einem Applet muß das applet-Package importiert werden und die neu geschriebene Klasse erweitert die im Package enthaltene Klasse "Applet".

Wie sieht ein einfaches Applet aus?

import java.applet.*;
import java.awt.*;


public class EinfachesBsp extends Applet {
public void paint (Graphics g {
g.drawString("Hello World", 25, 50);
}
}

"extends Applet" gibt bekannt, dass nun ein Applet erzeugt wird, und daß die Applet-Klasse, enthalten im Applet-Package, erweitert wird.

Wie wird ein Applet in ein HTML-Dokument eingebunden?

<applet codebase="applets/Bsp" name="Applet1" code="EinfachesBsp.class" width=200 height=100> </applet>

Die Attribute "codebase" und "name" sind optional.

Codebase
gibt in absolutem oder relativem Pfad das Verzeichnis an, in dem das Applet steht. Wenn das Attribut Codebase fehlt, wird das Verzeichnis, in dem die HTML-Datei liegt, als Basis-Verzeichnis angesehen.
Name
vergibt einen Namen für das Applet-Objekt. Über den Namen können verschiedene gleichzeitig laufende Applets miteinander kommunizieren.

Ein Applet kann flexibel auf bestimmte Angaben im HTML-Dokument reagieren:

Parameterwerte, wie Farben, Fontgrößen etc. können innerhalb des <applet>-Elementes definiert werden. Das Applet kann dann auf diese Angaben zugreifen und sie benutzen:

So sieht eine Parameter-Definition im HTML-Dokument aus:

<applet code="EinfachesBsp2.class" width=200 height=100>
<param name = text value = "Was ist ein Applet?">
<param name = rot value=255>
<param name = gruen value = 100>
<param name= blau value= 220>
</applet>

So greift ein Applet auf die Paramterangaben zu:

import java.applet.Applet;
import java.awt.*;

public class EinfachesBsp2 extends {Applet {
private Font f = new Font("SansSerif", Font.BOLD + Font.NORMAL, 12);
private String s;

public void init() {
setBackground(Color.white);

s = getParamter("text");

String r = getParameter("rot"); g = getParamter("gr,n"); b = getParameter("blau");

Color c;
c = new Color(Integer.parseInt(r), Integer.parseInt(g), Integer.parseInt(b));
setForeground(c);
setFont(f);
}

public void paint(Graphics g)
{g.drawString(s, 10, 60);
}
}

Die Parameternamen werden Variablen im Applet zugewiesen. Die Variablen wurden zuvor deklariert, sind also von einem bestimmten Datentyp. Erst durch die Zuweisung erhalten die Parameternamen einen bestimmten Datentyp, wie hier im Beispiel "string".

Wie führt der Browser ein Applet aus?

Wie bereits beschrieben, legt der Browser ein Objekt der Applet-Klasse an. Anschließend ruft er folgende Methoden auf, die alle in der Klasse Applet deklariert sind und individuell überschrieben werden können.

init()
Initialisierung der Appletklasse, wird automatisch aufgerufen, nachdem das Applet geladen wurde. Sie darf entfallen, falls keine Initialisierung notwendig ist. Die Methode erfüllt ähnliche Aufgaben, wie der Konstruktor in einer Anwendung: Sie initialisiert, lädt Grafiken, erzeugt weitere notwendige Objekte und vieles mehr.

Die Deklaration in Applet sieht so aus:

public void init() {}

start()
Wird unmittelbar nach init ausgeführt.

Die Deklaration in der Klasse Applet:

public void start() {}

stop()
stop() wird aufgerufen,

1. wenn die Seite, auf der das Applet eingebunden ist, verlassen wird und

2. unmittelbar vor der destroy-Methode

Die Deklaration in der Klasse Applet:

public void stop() {}

destroy()
wird aufgerufen, bevor das Applet-Objekt gelöscht wird.

Deklaration in der Klasse Applet:

public void destroy(){}

paint()

Paint ist für die Ausgabe des Applets zuständig. Sie wird beim ersten Start des Applets aufgerufen, oder wenn sich am grafischen Aufbau irgend etwas verändert. Als Parameter wird ein Objekt der Klasse Graphics übergeben.

Die Deklaration in der Superklasse Component ist:

public void paint (Graphics g){}

<4>Applikationen

Applikationen sind eigenständige Java-Programme, die unabhängig von einem Apppletviewer oder einem Browser laufen.

Eine Applikation kann aus einer oder mehreren Klassen bestehen, die jeweils in separaten .class Dateien abgelegt werden. Wie bei einem Applet auch, wird der Code in den Byte-Code kompiliert. Anschließend kann der Bytecode von einem JavaInterperter ausgeführt werden. Der Interpreter java ist im JDK enthalten. Der Programmaufruf sieht als Kommandozeileneintrag so aus:

java Klassenname

Genau eine Klasse enthält die Methode main() und damit den Startpunkt des Programms. Die main()-Methode hat immer folgenden Prototyp:

public static void main(String args[])

Die main()-Methode muss immer public und static sein und darf keinen Rückgabewert haben, muß also das Schlüsselwort "void" enthalten. Als Parameter wir ein Array von Strings übergeben.

Public definiert das Zugriffsrecht:

Die Methode ist öffentlich, alle Klassen, die auf das Objekt der public-Methode zugreifen können, dürfen auch auf die Methode selbst zugreifen.

Das Schlüsselwort "Static" definiert, daß die Methode eine Klassenmethode ist, wird teilweise auch statische Methode genannt. Es sind Methoden, die nicht für die Objekte einer Klasse bestimmt sind, sondern für die Klasse selbst: Beispiel für eine typische Klassenmethode: Eine Methode, die ermittelt, wie viele Objekte zur Laufzeit zu einer bestimmten Klasse gehören.

Wie sieht eine einfache Applikation aus?

public class simple {

public static void main(String args[ ]) {
System.out.println("Dies ist eine sehr einfache Java-Applikation!");
}
}

Servlets

Der Begriff Servlet ist in Anlehnung an die Bezeichnung Applet entstanden. Während Applets vom Client ausgeführt werden, werden Servlets vom Webserver aufgerufen. Im Prinzip werden Servlets, wie CGI-Skripte auch, zum Erstellen dynamischer HTML-Seiten benutzt. Z.B. können Datenbank-Abfragen in einem HTML-Dokument an den Browser des Anwenders weitergegeben werden. Servlets sind in der Regel sicherer, schneller und einfacher als CGI-Skripte. In dem Package javax.servlet sind viele nützliche Servlet-Klassen und -Methoden enthalten.

Wie werden Servlets aufgerufen?

Der Aufruf eines Servlets, geschieht genau bei CGI-Skripten auch, z.B. über ein HTML-Formular:

<html>
<head>
...</head>
<body>
...
<form action = "http://xyz/servlet/Anfrage" method=post>
Person: <input type=text name=Name>
Suche nach:
<input type=radio name=Anfrage value=Biographie>Daten</input>
<input type=radio name=Anfrage value=Werke>Werke</input>
<input type=submit value=abschicken></input>
</form>
...

Die Werte der einzelnen Formular-Elemente werden vom Browser jeweils durch & getrennt, übertragen. Die Anfrage nach einer Auflistung aller Werke von Charles Dickens überträgt der Browser z.B. so:

Name=C.Dickens&Anfrage=Werke

Neben method=post gibt es auch die Möglichkeit, Formulare mit method=get an den Server abzuschicken. Post ist die neuere und bessere Alternative. Get bewirkt, dass die Anfrage direkt an den Url in "action" mit einem Fragezeichen vorweg drangehängt wird. Bei sehr langen Anfragen kann es Probleme geben, da die Dateilänge auf dem Server-System z.B. auf 255 Zeichen begrenzt sein kann.

So sieht die Anfrage mit get aus:

http://xyz/servlet/Anfrage?name=C.Dickens&Anfrage=Werke

Wird post verwendet, sendet der Browser die Anfrage in zwei Schritten. Zunächst kontaktiert er den im action-Attribut angegebenen Server. Dann werden in einem nächsten Schritt die Anfragedaten übermittelt.

Wie führt der Server ein Servlet aus?

Während des Lebenszyklus eines Servlets ruft der Webserver implizit folgende drei Methoden auf:

init()
Dient der Initialisierung der Servlet-Klasse.

public void init(ServletConfig config) throws ServletException;

service()
Wird für jede Anfrage an das Servlet erneut aufgerufen; jeder Aufruf wird in einem eigenen Thread ausgeführt. Die Deklaration ist:

public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException;

destroy

Wird aufgerufen, wenn das Servlet entfernt werden soll.

public void destroy();

Wie sieht ein einfaches Servlet aus?

Ein Servlet implementiert man am einfachsten als Subklasse der abstrakten Klasse HttpServlet des Packages javax.servlet.http. Der Grund: es existiert bereit eine Service-Methode, die prüft welche Übertragungsmethode, also get oder post, der Client benutzt und abhängig davon die Methoden doGet oder doPost aufruft. In der Regel reicht es aus, wenn der Programmierer eine der Methoden doGet oder doPost implementiert.

So sieht die vorgegebene Deklaration aus: z.B.

protected void doPost(HttpServletRequest req, HttpServletResponse resp)
trows ServletException, IOException;

<ber den Paramter req (request) wird auf die Anfrage zugegriffen und über den Parameter res (response) wird das Ergebnis abgeschickt.

So könnte der Programmierer die doPost-Methode überschreiben:

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class AnfrageServlet extends HttpServlet {
String NAME = "Name"; ANFRAGE="Anfrage", WERKE="Werke", GEBDATUM="Gebdatum";

Autor[]tab = {
new Autor("C.Dickens", "David Copperfield", "1812"),
new Autor("A.Christie", "16.50 ab Paddington", "1891");
};

public void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
String[] namen = req.getParamterValues(NAME);
anfragen=req.getParamterValues(ANFRAGE);

String name=namen[0], frage = anfragen[0];
int index = 0;


static class Autor {
String name werke, gebdatum;
Autor (String name, String Werke, String gebdatum) {
this.name= name;
this.werke= werke;
this.gebdatum= gebdatum;
}

while ((index < tab.length) && (!name.equals(tab[index].name)))
index++;

res.setContentType("text/html");
PrintWriter rout = res.getWriter();
rout.println("<html>\n" + "<head>\n" + "<title> Autoren </title>\n"
+ "</head>\n" + "<body>\n" + "<h1>Autorenangaben</h1>");<br> if (index == tab.length)<br> rout.println("Autor" + name + "nicht in der Datenbank enthalten.");

else if (frage.equals(GEBDATUM))
rout.println("Geburtsdatum von " + name + ": " + tab[index].daten);

else if (frage.equals(WERKE))
rout.println("Erfindung von "+ name + ";" + tab[index].erfindung);
rout.println("</body>\n</html>\n");
}
}
}

Erklärung:

Die vorhandenen Informationen über die Autoren werden in je einem Objekt der neu erstellten Klasse "Autor" abgelegt. Die einzelnen Autorenobjekte werden in einem Array vom Typ "Autor" mit dem Namen "tab" abgelegt.

Der Autorenname nach dem gesucht ist, kann über req.getParamterValues(NAME) angesprochen werden. In diesem Beispiel wird der gesuchte Autorenname einem Array of String, der "namen" heißt, übergeben.

Das erste Stringobjekt des Arrays wird in der Stringvariablen name gespeichert.

Der Umweg über einen Array of Strings ermöglicht es, daß der Benutzer nach mehreren Personen gleichzeitig suchen kann. Einze Zählvariable index wird mit 0 initialisiert. Nun wird, solange wie der Index kleiner als die Länge des Arrays "tab" ist, folgendes gemacht:

Der String name, also der 1. Name, nach dem gesucht ist, wird mit dem Namen verglichen, der an erster Stelle des "tab" Arrays steht.

Nehmen wir einmal an, der Benutzer hat nach C.Dickens gesucht. Das heißt, dass nun die beiden Strings "C.Dickens" (Benutzereingabe) und "C.Dickens" (Name des ersten Personeneintrags im Person-Array "tab") auf Ungleichheit verglichen werden. Die beiden Strings sind gleich, die While-Bedingung ist damit nicht erf,üllt und die Anweisung, die Zählvariable um 1 zu erhöhen, wird nicht ausgeführt.

Da nun bereits der gesuchte Autoreneintrag gefunden wurde, wird nun mittels getWriter ein PrintWriter-Objekt erzeugt und die -Ausgabe erzeugt:

Wenn die Zählvariable bis zur maximalen Größe um 1 inkrementiert wurde, ist der gesuchte Autor nicht gespeichert. Wenn z.B. nach dem nicht vorhandenen Oscar Wilde gesucht wird:

Die Bedingung der While-Schleife wird mit folgenden Werten betreten:
Erster Teil der Bedingung:
0 (Wert der Zählvarialben) < 2 (Die Länge des Person-Arrays "tab", der aus den beiden Indizes 0 und 1 besteht., also insgesamt 2 Elemente hat)
d.h. erster Teil der Bedingung ist erfüllt

Zweiter Teil der Bedingung
O.Wilde ist ungleich C.Dickens
Bedingung ist ebenfalls erfüllt.

d.h. der Index wird von 0 auf 1 erhöht und die Schleife wird erneut durchlaufen:

Erster Teil der Bedingung:
1 < 2 d.h. Bedingung ist erfüllt

Zweiter Teil der Bedingung:
O.Wilde ist ungleich C.Dickens
Bedingung ist ebenfalls erfüllt.
d.h. der Index wird von 1 auf 2 erhöht und die Schleife wird erneut angesteuert.

Erster Teil der Bedingung
2 < 2 d.h. nicht erfüllt, also wird die Schleife nicht mehr durchlaufen.

Mit der if-Bedingung if (index == tab.length) wird dieser Fall abgefangen, dass der Index bis zur maximalen Größe erhöht wurde und kein Treffer vorhanden ist: Die Ausgabe lautet, dass kein Eintrag über diesen Autor existiert..

Eine weitere Verzweigung der Bedingung prüft, welche Angaben der Benutzer sehen möchte: die Werke der Person oder das Geburtsdatum. Und die entsprechenden Objektvariablen werden in HTML-Elemente eingebettet und so wieder an den Browser des Benutzers übergeben.

Was sind JavaBeans?

Ein Bean ist eine in Java geschriebene, wiederverwendbare Softwarekomponente, die über eine normierte Schnittstelle verfügt (Design Time Interface), über die Entwicklungsumgebungen abfragen können, welche Eigenschaften und Ereignisse unterstützt werden:

Beans können durch visuelle Bearbeitungsmethoden zur Entwicklungszeit modifiziert werden. Jede Java-Klasse, die bestimmten Eigenschaften- und Ereignis-Interface-Konventionen folgt, ist bereits ein JavaBean! JavaBeans werden häufig geschrieben, um graphische Elemente zu definieren, die das AWT ergänzen, z.B. TabellenControls oder spezielle Texteingabefelder.

Fertige JavaBeans-Komponenten werden von vielen Firmen, wie z.B. Corel, IBM, und Novell entwickelt und kommerziell vertrieben.

Beans zeichnen sich durch folgende Merkmale aus:

Einsehbarkeit (introspection)
Ein Entwicklungstool muss einsehen können, wie ein Bean arbeitet

Anpassbarkeit (customization)
Ein Entwickler muss mit einem Entwicklungstool das Verhalten und das Aussehen eines Beans anpassen können.

Ereignisse (events)
Ereignisse ermöglichen es JavaBeans, miteinander zu kommunizieren und sich zu verbinden.

Eigenschaften (properties)
erlauben es Entwicklern, Beans anzupassen und zu programmieren.

Dauerhaftigkeit (persistence)
Ein Java-Bean muss so angelegt sein, dass er dauerhaft wieder verwendet werden kann.

Was sind Enterprise JavaBeans?(EJB)

Enterprise JavaBeans ist eine Anfang 1998 von Sun vorgestellte neue API für die Java Plattform. EJB weiten das JavaBeans Komponentenmodell für die Belange von verteilten Geschäftsapplikationen aus. Ein EJB repräsentiert eine nicht-visuelle Business-Komponente (Entität), die sich auf einem Applikationsserver befindet. Clients können auf den Applikationsserver und die EJBs zugreifen.

In einem EJB werden logistische und andere betriebliche Abläufe und Zusammenhänge implementiert. Der Entwickler der EJB konzentriert sich vollständig auf die Implementierung der geschäftsspezifischen Logik. Notwendige technische Mechanismen, wie ein Transaktionsmodell, persistente Speicherung und Sicherheitsvorkehrungen werden an die Komponentenumgebung, in der Regel den EJB-Applikationsserver, delegiert.

Was sind Interfaces?

Interfaces sind Schnittstellen in Java, die eine Art eingeschränkte Mehrfachvererbung in Java erlauben. In Java ist im Gegensatz zu C++ keine Mehrfachvererbung erlaubt. D.h. eine Klasse kann nur eine Superklasse besitzen: Zeichnung.

Die Mehrfachvererbung in C++ führte oft zu Fehlern, da eine untergeordnete Klasse alle Eigenschaften und Methoden der Superklassen erbt, was oft nicht erwünscht war. Aus diesem Grund ist die Mehrfachvererbung in Java nicht erlaubt.

Trotzdem ist es manchmal nützlich, eine Methode zu definieren, die von unterschiedlichen Klassen benutzt werden kann - von Klassen, die in keiner Vererbungsbeziehung miteinander stehen. Die Verbindung dieser Klassen mit der gemeinsam benutzten Methode ist Aufgabe des Interfaces.

Wie wird ein Interface deklariert?

Ein Interface ähnelt im Aufbau einer abstrakten Klasse:

public interface Drawable {

public void setColor(Color c);
public void setPsition(double x, double y);
public void draw(DrawWindow dw);
}

Allerdings darf ein Interface ausschließlich abstrakte Methoden enthalten, während eine abstrakte Klasse auch Nicht-abstrakte Methoden verwenden darf.

Das heißt, der Methodenrumpf, der eigentliche Inhalt der Methode, wird erst in den jeweiligen Klassen festgelegt, die das Interface benutzen. In jeder Klasse können also die Inhalte der Methoden unterschiedlich sein - lediglich die Methodennamen und die Paramter sind identisch.

Wie wird ein Interface in einer Klasse implementiert?

So wird ein Interface in einer Klasse implementiert:

public class DrawableRectangle ectends Rectangle implements Drawable{

private Color c;
private double x, y;


//Konstruktor, Paramter sind identisch mit dem Interface
public DrawableRectangle(double w, double h) {super(w, h);}

//Namen der Interface-Methode werden aufgegriffen und die Methodenrümpfe mit Inhalt gefüllt.
public void setColor(Color c) {this.c = c; }
public void setPosition(double x, double y) {this.x = x,; this.y = y;}
public void draw(DrawWindow dw) {dw.drawRect(x, y, w, h, c);
}
}

Durch Interfaces wird also lediglich ein gemeinsamer Name für den Methodenkopf festgelegt. In jeder Klasse, die das Interface benutzt, kann der Inhalt der Methode anders aussehen.

Quellen

Dietrich, Ernst-Wolfgang. (1999): Java - Von den Grundlagen bis zu Threads und Netzen, München: Oldenbourg Verlag

Flanagan, David (1998): Java in a Nutshell. O'Reilly Cambridge, Köln u.a.; 2.Auflage

ix - Magazin f,r Professionelle Informationstechnik, heise Verlag, Ausgabe 6 1999 (Juni 1999) S. 22 "Java wird schneller"

Menge, Rainald (1999): Java calling - Entwicklerkonferenz JavaOne in San Francisco, erschienen in c't magazin für Computertechnik, Heise Verlag, Ausgabe 14 (05.07.-18.7.99)

Piemont, Claudia (1999): Komponenten in Java - Einsatz und Entwicklung von JavaBeans mit VisualAge for Java; Heidelberg:dpunkt-Verlag.

Schader, Martin; Schmidt-Thieme, Lars (1999): Java Eine Einführung. Berlin, Heidelber u.a.: Springer Verlag, 2. aktualisierte und verbesserte Auflage

Schmidt, Jürgen: Java, die zweite - Neue Version des Java Development Kit; aus c't 1998, Heft 26, S. 36