Nächste Seite: Klassen und Objekte Aufwärts: Programmieren in Java Vorherige Seite: Objektorientierte Programmierung Inhalt Index

Unterabschnitte

Ein Streifzug durch Java

Ein erster Eindruck von Aussehen, Benutzung und Möglichkeiten von Java.

Applets und Applikationen

Zwei Einsatzbereiche:

Applets: kleine meist grafikbasierte Anwendungen, die unter der Kontrolle eines Web-Browsers ablaufen.
Applikationen: normale Anwendungsprogramme.

Java-Programme werden interpretiert:

$\psfig {figure=bilder/compil.ps}$

Im JDK ( Java Development Kit) von Sun sieht die Übersetzung und Ausführung von Applikationen so aus:


    javac Diesel.java      
    javac Motor.java
    java Diesel

falls Diesel das Hauptprogramm enthält.

Wichtige Regel:

Der Name der Datei (Übersetzungseinheit) ohne das ``.java'' muß gleich dem Namen der in der Datei definierten öffentlichen Klasse sein.

Jede Klasse in einer ``.java''-Datei führt beim Übersetzen zu einer eigenen ``.class''-Datei.

Dadurch:

Automatisierung des Übersetzungsprozesses:

Wenn Diesel Motor benutzt, etwa durch


   class Diesel extends Motor
   { ...
   }

führt das Kommando


   javac Diesel.java

automatisch auch zur Übersetzung von Motor (wenn nötig).

Applets leben in Web-Seiten. Die Applet-Zwischencode-Datei ( Bytecode) wird im HTML-Text angegeben:


   <html>
   <head>
   <title> Motor Applet </title>
   </head>
   <body>
   <applet code=Motor.class 
           width=260 
           height=260>
   </applet>
   </body>
   </html>

Der Interpretierer ist im Browser integriert und wird von diesem aufgerufen.

Andere Möglichkeit:

Der appletviewer aus dem JDK:


    appletviewer slider.html

Hello World


// Datei HelloWorld.java
class HelloWorld
{  public static void main(String[] args)
   { System.out.println("Hello, world");
   }
}

!

Übersetzung und Ausführung:


    javac HelloWorld.java
    java HelloWorld

!

Definition der Klasse HelloWorld. Keine Attribute. Eine Methode.

!

main ist ein spezieller Methodenname, der das Hauptprogramm kennzeichnet.

!

Der Parameter ist ein Array von Strings. Es enthält die Kommandozeile.

!

Die einzige Anweisung ist ein Methodeaufruf. Methode: println von Objekt out aus der Klasse System.

Variablen und Ablaufstrukturen

Hier ist Java sehr C-ähnlich:


class Fibonacci
{  public static void main(String[] a)
   {  int lo = 1;
      int hi = 1;
      System.out.println(lo);
      while (hi < 500)
      { System.out.println(hi);
        hi = lo + hi;
        lo = hi - lo;
      }
   }
}

!: Lokale Variablen werden deklariert und evtl. initialisiert.
!: Uninitialisierte Variablen gelten als undefiniert und führen bei Benutzung zu Compiler-Fehlermeldungen.
!: Java hat 8 eingebaute Grundtypen mit definierter Größe.
!: while-Schleife ohne Besonderheiten.
!: println hier für int, d.h. println ist eine überladene Methode.

Kommentare

Drei Kommentar-Stile

Zeilenkommentare: vom // bis zum Zeilenende
Klammerkommentare: zwischen /* und */.
Dokumentations-Kommentare: zwischen /** und */. Dokumentations-Kommentare unterstützen die automatische Erzeugung von Programmdokumentation. Ein Werkzeug namens javadoc extrahiert solche Kommentare und erzeugt daraus HTML Dokumentation.

Beispiel:


/**
  * Konstruktor mit Größenangabe
  */
  schraubenschlüssel(int sz) 
  { ....
  }

Benannte Konstanten

Bekannte Vorteile gegenüber literalen Konstanten:

Der Name dient der Dokumentation, wofür der Wert gut ist.
Die Definition findet sich an einer zentralen Stelle, was die Wartung stark vereinfacht.

In Java bekommt man benannte Konstanten durch finale Klassenvariablen:


class ZylinderZahl
{ final static EINZYLINDER = 1;
  final static ZWEIZYLINDER = 2;
  final static DREIZYLINDER = 3;
}

static bedeutet: dies ist ein Attribut der Klasse (nicht von individuellen Objekten)

final bedeutet: dieses Attribut erhält hier seinen endgültigen Wert.

Benutzung außerhalb von ZylinderZahl wird qualifiziert mit dem Klassennamen:


   if (zyl == ZylinderZahl.EINZYLINDER)
   { ....
   }

Klassen und Objekte

Java-Klassen beinhalten zwei Arten von Elementen:

Attribute: speichern den Zustand von Objekten (heißen auch Fields).
Methoden: beinhalten den Code einer Klasse.


   class Motor()
   { public int rpm;  // rounds per minute
     public void on() // Motor anmachen
     { ...
     }
   }

Es gibt neben public noch 4 Stufen der Sichtbarkeit von Attributen und Methoden:

: private
: protected
: public
: default: Paket-Sichtbarkeit

Erzeugen von Objekten

Objekt-Erzeugung

immer dynamisch
immer auf dem Heap

Zugriff immer über Referenzen ( Referenzsemantik).

Garbage Collection (GC): automatische Entsorgung von Objekten, die nicht mehr gebraucht werden.

In Java läuft der Garbage Collector im Hintergrund immer mit.

Klassenvariablen = Statische Attribute

Normalerweise beschreiben Attribute die Eigenschaften von Objekten. Heißen daher auch Instanzvariablen .

Manchmal sollen sich alle Objekte einer Klasse auch ein Attribut teilen. Ein solches Attribut beschreibt dann Eigenschaften der Klasse.


   class WerkstattKunde
   { public static int KundenZahl;
     ...
   }

Kundenzahl ist Eigenschaft der Klasse. Alle Objekte der Klasse WerkstattKunde teilen sich dieses Attribut.

Methoden und Parameter

$\psfig {figure=bilder/method.ps}$

Methodenaufruf

$\psfig {figure=bilder/invok.ps}$

Selbstreferenz `this`

Jede Methode erhält mit this eine implizite Referenz auf das Objekt, für das die Methode aufgerufen wurde.

Situation, wo man diese Selbstreferenz braucht:


   public void on ()
   { this.glüh();  // 'glüh()' reicht auch
     super.on();
     // geht nicht ohne 'this':
     läuft.addtolist(this);
   }

Klassenmethoden = Statische Methoden

Analog zu klassenweiten Attributen: Klassenmethoden.

Arbeiten auf Eigenschaften der Klassen, nicht auf individuellen Objekteigenschaften.


 class WerkstattKunde
   { public static void incKundenZahl()
     { KundenZahl++;
     }
   }

Arrays

Der zweite nicht-primitive Datentyp in Java neben Objekten.

Wie bei Objekten gilt:

Referenzsemantik
Dynamische Erzeugung mit new
Automatische Entsorgung durch Garbage Collection


   Motor Prüfstand[] = new Motor[10];

Jedes Array hat ein konstantes length-Attribut, das die Anzahl der Array-Elemente angibt:


   for (index = 0; 
        index < Prüfstand.length(); 
        index++)
      asu.motor_check(Prüfstand[index]);

In Java findet grundsätzlich Bereichsprüfung für Array-Zugriffe statt.

String Objekte

Strings sind eigentlich keine in Java eingebaute Klasse sondern kommen aus der Bibliothek ( java/lang/String).

Trotzdem ( !) gibt es in Java

Literale für String-Konstanten ("Hello, world")
Automatische String-Objekt-Erzeugung für solche Literale
Einen eingebauten Operator + zur Konkatenation.


   class WerkstattKunde
   { WerkstattKunde (String name)
     { String kname = "knd_" 
                      + name 
                      + "_"
                      + String.valueOf
                          (KundenZahl);
       ...
     }
   }

Wichtig: Strings sind unveränderlich ( immutable).

Änderbare gibt es in der Klasse StringBuffer.

Erweitern von Klassen: Vererbung

Eine Klasse, die eine andere erweitert, erbt die Attribute und Methoden der Oberklasse.


class Diesel extends Motor
{ public Diesel(String n)
  { super(n);  // Oberklassenkonstruktor
  }
  public void on()
  { System.out.print("Diesel ");
    glueh();
    super.on(); // Oberklassen-on()
  }
  private void glueh()
  { System.out.print("vorglühen");
  }
}

Möglichkeiten der Klassenerweiterung:

Neue Attribute mit neuen Namen hinzufügen.
Oberklassenattribute durch neue gleichnamige verdecken.
Neue Methoden mit neuen Namen hinzufügen.
Oberklassenmethoden durch neue gleichnamige mit anderer Signatur überladen.
Oberklassenmethoden durch neue mit gleicher Signatur überschreiben.

Wörterbuch

erweitern	extend
verstecken	hide
überladen	overload
überschreiben	override

Schnittstellen (interfaces)

Reine Beschreibung des Entwurfs von Objekten. Vollständig abstrahiert von der Implementierung.

Entspricht abstrakten Klassen (ohne Attribute) in anderen OO-Sprachen.

Der Entwerfer von Schnittstellen spezifiziert, welche Methoden von Klassen, die die Schnittstelle implementieren, bereitgestellt werden.


   interface Ersetzbar
   { // für ersetzbare Objekte läßt sich
     // eine Ersatzteilnummer ermitteln:
     int ersatzteilnummer(String Name);
   }

Java-Klassen können mehrere Schnittstellen implementieren:


   class Motor 
   implements Ersetzbar, Identifizierbar
   { ...
   }

Schnittstellen können wie Klassen verwendet werden:


   // Bestelle beim Großhändler alle
   // benötigten Ersatzteile
   pubic static void 
     ersatzteilorder(Ersetzbar[] kaputt)
   { ...
   }

Schnittstellen können andere Schnittstellen erweitern (auch mehrere):


   interface DruckbarUndSpeicherbar
     extends Druckbar, Speicherbar
   { boolean aktuelleversiongedruckt();
   }

Interfaces erweitern die Möglichkeiten der Polymorphie:

Die Obertypen einer Klasse T umfassen

1.: den Typ, den T erweitert ( extends)
2.: die Typen, die T implementiert ( implements)
3.: die Obertypen der Typen aus [1.] und [2.].

Ein Objekt vom Typ T darf überall dort verwendet werden, wo Obertypen von T zulässig sind.

Ausnahmen (Exceptions)

Begriffe:

Exception: ein Objekt, das signalisiert, daß eine außergewöhnliche Bedingung eingetreten ist.
throw an exception: eine außergewöhnliche Bedingung signalisieren.
catch an exception: auf die Ausnahme reagieren (wie auch immer).

Wenn eine Ausnahme nicht im Block behandelt wird, wo sie erzeugt wird, propagiert sie in den umfassenden Block, dann in die aufrufenden Methode, usw. bis zur main-Methode.

Wird sie auch dort nicht behandelt, erzeugt der Java-Interpretierer eine Fehlermeldung und beendet die Ausführung.

Beispielprojekt: Fakultätsprogramm

Ziel:

Fakultätsprogramm mit Argumenteingabe auf der Kommandozeile.
Behandeln der folgenden Fehlersituationen:
- Kein Argument
- Kein ganzzahliges Argument
- Negatives Argument
- Zu großes Argument

Wir lernen:

Ausnahmebehandlung
Kommandozeilenverarbeitung
Stringverarbeitung

Wir brauchen:

Eine Klasse fac für die Fakultätsfunktion.
Eine Klasse facmain für Kommondozeilenverarbeitung, Fehlerbehandlung und Programmsteuerung.

Die Fakultätsberechnung


/** Fac.java
  * Implementiert die Fakultätsfunktion
  * rekursiv.
  * Arg./Erg.: long (64bit signed integer)
  * Überprüft Fehler
  */

public class Fac 
{ static final long maxarg = 20;
  public static  long fac (long x) 
  throws IllegalArgumentException
  { 
    if (x < 0)
      throw new IllegalArgumentException
                ("negativ: " + x);
    if (x > maxarg)
      throw new IllegalArgumentException
                ("zu groß: " + x);
    if ( x == 0)
      return 1;
    else return x * fac(x-1);
  }
}

Das Fakultäts-Hauptprogramm


/** facmain.java
  * Fakultätsprogramm mit 
  * Kommandozeilen-Eingabe
  */
public class Facmain
{
  public static void main (String[] args)
  { // Versuche, die Fakultät zu berechnen
    try
    { int x = Integer.parseInt(args[0]);
      System.out.println(x + "! = " 
                         + Fac.fac(x));
    }

    catch 
    (ArrayIndexOutOfBoundsException e)
    { System.out.println("Argument fehlt!");}

    catch 
    (NumberFormatException e)
    { System.out.println
       ("Argument ist keine ganze Zahl!");}

    catch
    (IllegalArgumentException e)
    { System.out.println
         ("Ungültiges Argument: "
           + e.getMessage());}
  }
}

Pakete (Packages)

Java benutzt Pakete zur Organisation des Namensraumes.

Ein Paket

enthält Java-Klassen und Unter-Pakete
hat einen Namen
kann in Java-Programmen importiert werden

Die Paket-Hierarchie führt in voll-qualifizierter Schreibweise zu langen Typnamen:


   java.util.Date today = 
        new java.util.Date();

import-Klauseln bringen Schreiberleichterung:


   import java.util.Date; // eine Klasse 
   import java.applet.*   // alles
   ...
   Date today = new Date();

Die Zugehörigkeit zu einem Paket spezifiziert man in der 1. Anweisung einer Übersetzungseinheit:


   package werkstatt.buchhaltung;

Ohne package-Anweisung gehört eine Klasse zu einem anonymen Default-Paket. Das ist praktisch für kleine Tests oder während der Entwicklung.

Java legt nicht fest, wie Pakete organisiert werden. Die meisten Java-Umgebungen bilden die Paket-Hierarchie auf die Directory-Struktur des Filesystems ab.

Java findet Klassen dann

im aktuellen Arbeitsverzeichnis
im dafür vorgesehenen Systemverzeichnis
relativ zur Umgebungsvariable CLASSPATH

UNIX:


 setenv CLASSPATH .:/home/peter/werkstatt

WINDOWS:


 setenv CLASSPATH .;c:\javaprogs\werkstatt

CLASSPATH kann statt Verzeichnissen auch zip-Dateien angeben:


 setenv CLASSPATH .:/home/jtools/cls.zip

Nächste Seite: Klassen und Objekte Aufwärts: Programmieren in Java Vorherige Seite: Objektorientierte Programmierung Inhalt Index

Peter Pfahler, 1997