Java


Einleitung

Java Architektur

Sprachkonstrukte

In diesem Abschnitt fassen wir die wichtigsten Eigenschaften der Programmiersprache Java zusammen.

Java ist eine Programmiersprache mit den folgenden Merkmalen: einfach, objekt-orientiert, verteilt, interpretiert, sicher, architektur-neutral, portabel, multithreaded und dynamisch. Sie ist für parallele und verteilte Programmierung besonders geeignet, vor allem wegen der in die Sprache integrierten Thread- und Synchronisationskonstrukte, Sicherheitsmaßnahmen, dynamisch ladbaren Klassen und der seit Java 1.1 und Java 1.2 vorhandenen Techniken Remote Method Invocation (RMI) und Object Serialization.

Ein erstes Java-Beispiel

Das einfachste, immer wieder eingesetzte Programm druckt nur Hello World! und terminiert dann.

   public class HelloWorld {
      public static void main(String[] args) {
         System.out.println("Hello World!");
      }
   }

Ein solches Java-Programm wird in einen sogenannten Byte-Code kompiliert und dann mit Hilfe eines Java-Interpreters ausgeführt. Vor der Kompilation müssen jedoch einige Umgebungsvariablen gesetzt werden. Dies sind die Variablen CLASSPATH und PATH, die unter Unix/Linux in den Shells sh oder bash, wie folgt gesetzt werden.

   % set CLASSPATH="/usr/local/jdk/java/lib:."
   % set PATH="$PATH:/usr/local/jdk/java/bin"
   % export CLASSPATH PATH

Diese Zeilen können eingetippt oder in der Datei .bashrc dauerhaft eingetragen werden. Auf Windows-NT-Rechnern müssen diese Variablen im Systempanel entsprechend gesetzt werden. Dabei ist das Trennzeichen `:' durch `;' und das Pfadtrennzeichen `/' durch `\' zu ersetzen. In anderen Umgebungen müssen Sie die Umgebungsvariablen entsprechend anpassen, falls sie nicht schon durch die Installationsroutinen richtig eingestellt werden.

Die Kompilierung mit dem Byte-Code Compiler erfolgt durch javac.

   % javac HelloWorld.java
 

Die Ausführung erfolgt mit dem Interpreter java.

   % java HelloWorld

Das Ergebnis ist wie erwartet.

   Hello World!

Die Java-Programmstruktur

Klassen

Java-Programme werden mittels Klassen definiert. Jede öffentliche (d.h. als public deklarierte) Klasse muß in einer separaten Datei gespeichert werden. Der Name der Datei muß mit dem Namen der public-Klasse übereinstimmen (z.B. muß die Klasse public class Test in der Datei Test.java gespeichert werden).

Objekte

Ein Objekt einer Klasse, d.h. eine Instanz der Klasse, kann nur durch das Schlüsselwort new erzeugt werden.

   Date d = new Date();

Der Speicherbereich für das Objekt wird automatisch allokiert. Wenn das Objekt nicht mehr gebraucht wird (d.h. keine Variable referenziert mehr das Objekt), wird der Speicherbereich während eines Garbage-Collection-Vorganges wieder freigegeben (Speicherrecycling). Das heißt, daß im Gegensatz zu C/C++ kein expliziter `delete'-Operator benötigt wird.

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) 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 haben sich die genannten Packages leicht geändert und es sind die folgenden Packages hinzu gekommen:
   java.beans
   java.event
   java.math
   java.rmi
   java.sql
   java.text
   java.util.zip
Bei dem Java-1.2-API kommen neben vielen Erweiterungen und Verbesserungen vorhandener Pakete, unter anderem folgende Pakete hinzu:
   java.security
   java.awt.swing
   java.awt.accessability
   java.lang.ref
   java.lang.reflect
   java.util.jar
   javax.servlet

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:

An der Stelle /* 2 */ gilt:

Abbildung 1.2: Java-Sichtbarkeit
Sichtbarkeit public protected private default
Vererbung
gleiches Package ja ja nein ja
anderes Package ja ja nein nein
Instanz, Objekt
gleiches Package ja ja nein ja
anderes Package ja nein nein nein

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.

Primitive Datentypen

In Java sind die primitiven Datentypen architektur-unabhängig definiert. Eine Zusammenstellung befindet sich in Abbildung 1.3. Der Begriff `atomar' wird bei Mulit-threaded Programmen benötigt.

Abbildung 1.3: Java-Datentypen
Datentyp Inhalt Größe atomar
boolean true oder false 1 bit  ja
char Unicode Zeichen 16 bits ja
byte signed integer 8 bits ja
short signed integer 16 bits ja
int signed integer 32 bits ja
long signed integer 64 bits nein
float IEEE754 float 32 bits ja
double IEEE754 double 64 bits nein

Variablen und Methoden

Variablen und Methoden können in einer Klasse definiert werden. Ein Objekt, das von dieser Klasse instanziiert (erzeugt) wird, enthält diese Variablen und Methoden. Statische Variablen und Methoden sind dagegen mit einer Klasse direkt verbunden.

   public class Card {
     int number;
     static int base = 5;
     public static String version = "1.0";
   
     public Card(int n) {
       number = n;
     }
   
     public int getNumber() {
       return number;
     }
   
     public static int getBase() {
       return base;
     }
   
     public int getDiff() {
       return number - base;
     }
   
     public static void main(String[] args) {
       Card c = new Card(7);
   
       System.out.println(c.version+":"+
              c.getNumber()+"-"+c.getDiff()+"="+
              Card.getBase());
     }
   }
Die Ausgabe dieses Programms ist 1.0:7-2=5.

Arrays

Ein Array, d.h. einen Vektor oder eine Matrix, kann man ebenfalls durch new erzeugen.

   byte[] buffer = new byte[4096];
   byte[] data = new byte[4096];
   int[][] plot = new int[64][64];
   ...
   Date[] ds = new Date[16];

Auf die Elemente eines Arrays kann über ihren Index zugegriffen werden.

   for (int i=0; i < buffer.length; i++) 
       buffer[i] = data[i];
In der length Variablen eines Array Objekts steht die Information über die Länge bereit.

Schleifen und bedingte Anweisungen

Java hat die üblichen auch von C und C++ bekannten while-, do- und for-Schleifen-Konstrukte.

   while (condition) {
         statements
   }

   do {
        statements
   } while (condition);

   for (int i=0; i < end; i++) {
       statements
   }
break und continue können analog zu C/C++ in einer Schleife benutzt werden.

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

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
   }
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. 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) { ...; }

   }

Mehr zu Klassen und Objekten

Klassen definieren und Objekte erzeugen

Wir definieren eine einfache Klasse für Autos (Car). Man kann mit dieser Klasse ein Auto mit den Parametern Modell (model), Baujahr (year) und (Neu-)Preis (price) definieren. Die Klassen-Methoden getModel(), getYear() und getPrice() dienen dem Zugriff auf die Klassen-Parameter.

public class Car {
  String model;
  int year;
  int price;

  public Car(String m, int y, int p) {
    model = m;
    year = y;
    price = p;
  }

  public String getName() {
    return model+" [year="+year+"]";
  }

  public int getPrice() {
    return price;
  }

  public static void main(String[] args) {
    Car ford = new Car("ford bronco", 1992, 35000);
    Car vw   = new Car("vw golf", 1984, 25000);

    System.out.println(
       ford.getName()+" costs "+ford.getPrice());
    System.out.println(
       vw.getName()+" costs "+vw.getPrice());
  }
}

Mit dieser Klasse kann man zum Beispiel die Objekte ford und vw erzeugen. Dies ergibt dann folgende Ausgabe.

    ford bronco [year=1992] costs 35000
    vw golf [year=1984] costs 25000

Vererbung

Mit dem Schlüsselwort extends kann man eine Klasse von einer anderen Klasse ableiten. Als Beispiel einer abgeleiteten Klasse von Car sei die Klasse Gebrauchtwagen (UsedCar) definiert, die den zusätzlichen Parameter `gefahrene Kilometer' (mileage) hat.

public class UsedCar extends Car {
  int mileage;

  public UsedCar(String m, int y, int p, int k) {
    super(m, y, p);
    mileage = k;
  }

  public String getName() {
    return super.getName()+" (mileage="+mileage+")";
  }

  public int getMileage() {
    return mileage;
  }

  public int getPrice() {
    return 10000*price/(mileage+10000);
  }
}

Die Methode getMilage() dient wieder dem Zugriff auf die Klassen-Parameter. Der Konstruktor für UsedCar ruft mit super(m, y, p) den Konstruktor der Basisklasse auf, dann wird der Parameter mileage gesetzt. Die Methode getPrice() überschreibt die Methode mit dem gleichen Namen und der gleichen Signatur (d.h. der gleichen Art und Anzahl der Parameter) von der Basisklasse. getPrice() berechnet in dieser Klasse den Gebrauchtwagenpreis in Abhängigkeit von der gefahrenen Kilometerzahl.

Mit diesen Klassen kann man dann zum Beispiel in dem Hauptprogramm main die folgenden Beziehungen definieren und ausdrucken.

  public static void main(String[] args) {
    Car[] cars = new Car[4];
    cars[0] = new Car("ford bronco", 1992, 35000);
    cars[1] = new UsedCar("ford bronco", 1992, 
                          35000, 8000);
    cars[2] = new Car("vw golf", 1984, 25000);
    cars[3] = new UsedCar("vw golf", 1984, 
                          25000, 20000);

    for (int i=0; i<4; i++)
      System.out.println(cars[i].getName()
             +" costs "+cars[i].getPrice());
  }

Als Ausgabe erhält man zum Beispiel.

   java UsedCar

   ford bronco [year=1992] costs 35000
   ford bronco [year=1992] (mileage=8000) costs 19444
   vw golf [year=1984] costs 25000
   vw golf [year=1984] (mileage=20000) costs 8333

Interface

Eine Java-Klasse ist nur von einer anderen Klasse ableitbar. Java kennt keine Mehrfachvererbung! Aber mit dem Sprachkonstrukt interface kann eine Klasse mehrere Methodensignaturen erben. Ein Interface deklariert nur abstrakte Methoden.

Zum Beispiel kann man ein Interface Rank definieren, das das Vergleichen zweier Objekte erlaubt. compare() gibt eine positive ganze Zahl zurück, falls dieses Objekt (this) in der implementierten Ordnung vor dem anderen Objekt (obj) steht.

  public interface Rank {
    public int compare(Rank obj) 
           throws RankException;
  }
Ist die implementierte Ordnung nicht total, so wird für unvergleichbare Objekte eine RankException ausgelöst.
  public class RankException 
         extends RuntimeException {
  }

Eine Subklasse von Rectangle (aus java.awt), die dieses Interface unterstützt, kann man wie folgt definieren.

  public class RankedRect extends Rect implements Rank {
    public RankedRect(int w, int h) {
      super(w,h);
    }

    public int compare(Rank obj) 
           throws RankException {
      try {
        return area() - ((Rect)obj).area();
      }
      catch (ClassCastException e) {
        throw new RankException();
      }
    }
  }

In einer ähnlichen Weise kann man eine Subklasse von Car definieren.

  public class RankedCar extends Car implements Rank {
    public RankedCar(String m, int y, int p) {
      super(m,y,p);
    }

    public int compare(Rank obj) {
      try {
        return getPrice()-((Car)obj).getPrice();
      }
      catch (ClassCastException e) {
        throw new RankException();
      }
    }
  }

Diese beiden Klassen können behandelt werden, als ob sie vom Typ Rank wären. Zum Beispiel als Argument in einer Methode foo(Rank obj). Eine Klasse kann mehrere Interfaces implementieren. Bei der Instanziierung von Klassen, die ein Interface implementieren, kann man die Struktur, die nicht von dem Interface stammt, ignorieren.

   Rank r = new RankedCar(model, year, price);

Dann ist aber nur noch die Verwendung der Methode r.compare(.) möglich und nicht mehr r.getModel(). Um dennoch getModel() zu verwenden, muß erst ein Cast (eine Typenanpassung)   auf RankedCar gemacht werden:

   ( (RankedCar) r ).getModel()

Abstrakte Klassen

Man kann eine Klasse definieren, die keine vollständige Implementierung der deklarierten Methoden enthält. Diese kann man sich als Mischform zwischen einem Interface und einer richtigen Klasse vorstellen. Ein Teil der Methoden wird implementiert, und für einen anderen Teil der Methoden werden nur die Spezifikationen (das Interface) festgelegt.

Eine solche Klasse wird als abstrakte Klasse bezeichnet und muß mit dem Schlüsselwort abstract gekennzeichnet werden.

  public abstract class Cell {
      int size;
     
      public int getSize() {
             return size;
      }
     
      public abstract void interact(Cell neighbor);
  }

Abstrakte Klassen können nicht instanziiert werden (d.h. es kann kein Objekt aus einer abstrakten Klasse erzeugt werden). Eine Subklasse, die die fehlende Implementation definiert, kann instanziiert werden.

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.


© Universität Mannheim, Rechenzentrum, 1998-2007.

Heinz Kredel
Last modified: Tue Aug 19 17:20:29 CEST 2008