Packages
Umfang der JDKs
Sichtbarkeit
Ausnahmen
Ein Package (Paket) enthält eine oder mehrere Klassen, die sich einen Geltungsbereich (Namespace) für Klassen teilen. Klassennamen brauchen nur innerhalb eines Packages eindeutig zu sein. Dies vermeidet mögliche Namenskonflikte zwischen verschiedenen Klassen, die von der lokalen Festplatte oder über das Netz dynamisch geladen werden.
Um eine Java-Datei einem Paket zuzuordnen, kann man an den Anfang der Datei eine package-Anweisung schreiben.
package game;
Dies definiert das Package game, das die in der Datei definierten Klassen enthält. Falls die Datei keine package-Anweisung enthält, werden die in der Datei definierten Klassen dem standardmäßigen namenlosen Package zugeordnet.
Wenn man in einer Datei Klassen eines anderen Packages benutzen will, muß man den Klassennamen komplett mit Package-Namen angeben. Will man z.B. die Klasse Date im java.util-Package benutzen, so wird dies wie im unten angeführten Beispiel getan.
java.util.Date d = new java.util.Date(); System.out.println("today is: "+d);
Die vollen Packagenamen können weggelassen werden, wenn die import-Anweisung benutzt wird.
import java.util.Date; ... Date d = new Date(); System.out.println("today is: "+d);
Man kann auch mit * alle Klassennamen eines Packages oder alle Methoden und Variablen einer Klasse importieren.
import java.util.*; ... Date d = new Date(); System.out.println("today is: "+d); ... Vector v = new Vector(); v.addElement("hello"); v.addElement("bye");
Das Package java.lang enthält die Basisklassen für Java und wird immer importiert. Deswegen kann man z.B. Object, System, Integer usw. ohne ihren Package-Namen java.lang benutzen.
Das Java-API (Application Programming Interface) (JDK-1.0) besteht aus den Klassen, die in den folgenden acht Packages definiert sind:
java.applet java.awt java.awt.image java.awt.peer java.io java.lang java.net java.util
Bei dem Java-1.1-API (JDK-1.1) haben sich die genannten Packages leicht geändert und es sind die folgenden Packages hinzu gekommen:
java.beans Komponenten java.event java.math java.rmi java.sql java.text java.util.zip
Bei dem Java-2-API (JDK-1.2) kommen neben vielen Erweiterungen und Verbesserungen vorhandener Pakete, unter anderem folgende Pakete hinzu:
java.security java.awt.swing java.awt.accessability java.lang.ref interact with CG java.lang.reflect java.util.jar javax.swing javax.servlet org.omg.CORBA
Bei dem Java-2-API (JDK-1.3) kommen neben Erweiterungen zum JDK-1.2 und Verbesserungen vorhandener Pakete, unter anderem folgende Pakete hinzu:
java.geom 2D Grafik javax.naming JNDI javax.sound org.omg.CORBA_2_3
Bei dem Java-2-API (JDK-1.4) kommen neben Erweiterungen zum JDK-1.3 und Verbesserungen vorhandener Pakete, unter anderem folgende Pakete hinzu:
java.nio new I/O javax.xml XML org.w3c W3C DOM org.xml SAX org.ietf.jgss security javax.net.ssl javax.imageio
Bei dem Java-2-API (JDK-1.5) kommen neben Erweiterungen zum JDK-1.4 und Verbesserungen vorhandener Pakete, unter anderem folgende Pakete hinzu:
java.lang.annotation Unterstüzung für Code-Annotationen java.swing neue Themes java.util.concurrent neue Multi-Threading Erweiterungen javax.rmi.ssl SSL für RMI javax.security.sasl SASL Unterstützung javax.sql.rowset Ergebnis Bearbeitung in JDBC javax.sound mehr Soundtreiber com.sun.jmx management extensions com.sun.org.apache XML und HTTP Erweitrungen war zT in org.apache com.sun.corba aktuelle CORBA Version und ErweiterungenWeiter wurde sich die Java Sprache in 1.5 wesentlich erweitert:
Generische Datentypen
Autoboxing
List<Integer> list = new ArrayList<Integer>();
int i; Integer j; i = j; // i = j.intValue(); j = i; // j = new Integer(i);
neue Schleifen, falls Iteratoren vorhanden
List<Integer> list = ... for (Integer j: list) { System.out.println("j = " + j); }statt
List list = ... for (Iterator it = list.iterator(); it.hasNext(); ) { System.out.println("j = " + it.next() ); }
Aufzählungstypen Enum
enum Farben { rot, gruen, blau };statt
public static final int rot = 1; public static final int gruen = 2; public static final int blau = 3;
Unterstützung von 'deklarativem Programmieren' durch Code-Annotationen
Argumentlisten variabler Länge
public void method( Object... args ) { if ( args.length >= 1 ) { System.out.println( "args[0] = " + args[0] ); } }
Import statischer Methoden
import static java.lang.Math.*; double r = cos( PI );statt
import java.lang.Math; double r = Math.cos( Math.PI );
Bemerkungen:
Die Zahlen wurden im wesentlichen mit grep pattern cat.java|wc
ermittelt.
Die Datei cat.java
wurde mit
find src-dir -name "*.java" |xargs cat > cat.java
erzeugt.
Daneben gibt es in den jeweiligen JDKs noch viele class-Dateien ohne java-Dateien, wo also der Source-Code nicht bekannt ist.
Eine als public deklarierte Klasse ist in allen Packages zugreifbar. Auf eine nicht als public deklarierte Klasse kann nur innerhalb desselben Package zugegriffen werden.
Zur Verdeutlichung der Konzepte betrachten wir folgende Beispiele:
public class A { public int pb; protected int pt; private int pv; /*default*/ int df; } public class B extends A { A a = new A(); /* 1 */ } public class C { A a = new A(); /* 2 */ }
An der Stelle /* 1 */ gilt folgendes:
An der Stelle /* 2 */ gilt:
Auf public-Felder (Variablen oder Methoden) kann in allen Packages und Subklassen zugegriffen werden, solange die Klasse selbst zugreifbar ist. Auf protected-Felder kann in Subklassen der Klasse und in allen Klassen im gleichen Package zugegriffen werden. private-Felder sind dagegen nur in derselben Klasse zugreifbar. Diese Beziehungen sind nochmal in Abbildung 1.2 zusammengefaßt.
Konstante Variablen können mit dem Schlüsselwort final deklariert werden. Diese können dann nicht mehr geändert werden.
public final static String DEFAULT = "dpunkt";
Im Gegensatz zu C oder C++ gibt es keinen Preprozessor, der Konstanten substituieren kann (z.B. kein #define).
Von Klassen, die mit dem Schlüsselwort final deklariert sind, können keine Klassen abgeleitet werden. Dies dient zum einen dazu, unerwünschte Ableitungen zu verhindern, wie zum Beispiel bei system-nahen Klassen java.lang.System. Und sie dienen zum anderen dazu, dem Compiler Hinweise für die Optimierung zugeben, denn es müssen dann keine Vorkehrungen zum Überschreiben dieser Methoden getroffen werden.
Ein Ausnahmefehler (Exception) ist ein Signal, das irgendeinen Fehler andeutet. Man kann eine Exception durch throw auslösen und durch catch abfangen. Ein neues Exception-Objekt wird wie üblich mit new erzeugt.
Java unterscheidet im Wesentlichen drei Arten von Ausnahmen,
die alle von der Klasse java.lang.Throwable
abgeleitet sind:
Falls eine Exception nicht in der Methode abgefangen wird, wird sie in die Methode weitergeleitet, die diese Methode aufgerufen hat. Dies ermöglicht bessere und einfachere Fehlerbehandlung. Jede Methode in Java muß Exceptions entweder explizit abfangen oder weiterleiten. Zum Abfangen kann man try und catch wie folgt benutzen.
try { // open a file ... // read data ... } catch (IOException e) { System.out.println("Couldn't write"); // do the clean up, e.g. closing the file }
Die vollständige Syntax dieser Anweisungsfolge ist:
try { // statements possibly generating // Exception_1 or Exception_2 } catch (Exception_1 e) { // statements handling Exception_1 } catch (Exception_2 e) { // statements handling Exception_2 } ... finally { // statements cleaning up for all the cases }Der finally-Block wird unabhängig vom Auftreten von Ausnahmen zum Schluß ausgeführt.
Zum Weiterleiten von Ausnahmen kann man das throws-Schlüsselwort benutzen. throws wird zwischen dem Methodenkopf und dem Methodenrumpf zusammen mit einer Aufzählung aller in Frage kommenden Ausnahmen eingefügt. Zum Auslösen von Ausnahmen verwendet man das throw-Schlüsselwort.
public void getInputData() throws MyException { ... if (notOK) { throw new MyException(); } ... }
Zur Definition einer Ausnahme wird eine Subklasse von java.lang.Exception gebildet.
class MyException extends Exception { public MyException() { ...; } public MyException(String msg) { ...; } }
java.lang.Exception ist eine direkte Subklasse von java.lang.Throwable:
public class Exception extends Throwable implements Serializable Exception() Exception(String message) Exception(String message, Throwable cause) Exception(Throwable cause) Throwable getCause() Throwable initCause(Throwable cause) String getMessage() void printStackTrace()
Beispiele:
public class Ausnahmen { public void exception() throws NumberFormatException { int n = 0; try { // versuche irgendwelche Methodenaufrufe, die // Ausnahmen produzieren koennen } catch (IndexOutOfBoundsException e1) { // Fehlerbehandlung // meist Ausgabe einer Fehlermeldung // das Programm arbeitet dann weiter // nach dem letzten catch-Block } catch (Exception e2) { // hier werden alle Ausnahmen abgefangen // die nicht schon vorher behandelt // wurden } finally { // dieser Block ist optional, er wird nach // jedem Verlassen des try-Blocks ausgefuehrt } if (n < 0) throw new NumberFormatException("Die Variable n enthaelt"+ " einen Wert kleiner als 0!"); } }
© Universität Mannheim, Rechenzentrum, 1998-2004.
Heinz Kredel Last modified: Mon Jan 17 23:55:40 CET 2005