Java

Packages

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.

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 

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.

Zugriff und Sichtbarkeit

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:

• falls A und B im gleichen Package sind, sind pb, pt, df sowie a.pb, a.pt, a.df sichtbar
• falls A und B in verschiedenen Packages sind, sind pb, pt und a.pb sichtbar

An der Stelle /* 2 */ gilt:

• falls A und C im gleichen Package sind, sind a.pb, a.pt, a.df sichtbar
• falls A und C in verschiedenen Packages sind, ist nur a.pb sichtbar

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.

Konstanten

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).

Final-Klassen

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.

Ausnahmebehandlung

Eine Exception (Ausnahmefehler) 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.

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ß Ausnahmen 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
   }

Zum Weiterleiten von Ausnahmen kann man das throws-Schlüsselwort benutzen. 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 Exception gebildet.

   class MyException extends Exception {
 
      public MyException() { ...; }
      public MyException(String msg) { ...; }

   }

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!"); 
  } 
}