3. Programmieren von Applications

Das dritte Kapitel erklärt Besonderheiten der Sprache anhand von Praxisbeispielen. Es wurde versucht, möglichst viele Spracheigenschaften auf engstem Raum zu verdeutlichen, daher sind die Beispiele teilweise sehr komplex und sollen nur als Hilfe beim selbständigen Programmieren dienen.

[ 3.1 ], [ 3.2 ], [ 3.3 ], [ 3.4 ], [ 3.5 ], [ 3.6 ], [ 3.7 ], [ © ]

3.1. ein erstes kleines Programm

Dieses Programm dient nur der Einführung und schreibt etwas an die Standardausgabe.

hallo.java


/**
 * gibt Text an die Konsole aus.
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 15 Jan 97;  update: 06 Apr 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
class hallo {
  public static void main(String argv[]) {
    System.out.println("Dies ist ein Test.");
    System.out.println("3 * 4 = "+3*4);
  }
}

Bei den ersten 6 Zeilen handelt es sich um (besondere) Kommentare. Genaueres erfahren Sie dazu beim dritten Beispiel bzw. im Kapitel 2.3.
Danach beginnt ein neuer Block, die öffentliche Klasse "hallo". In dieser Klasse wird nun die öffentliche Funktion main definiert, welche beim Starten der Klasse mittels "java" automatisch aufgerufen wird. Auf die Parameter, die der Funktion übergeben werden (das argv-Feld), wird später eingegangen.
System.out ist ein PrintStream, der automatisch mit der Standardausgabe (Konsole) verbunden ist. Ein PrintStream kennt die Methode println (siehe API), die als Parameter in diesem Fall eine Zeichenkette (String) erhält. Diese wird ausgegeben. In der nächsten Zeile wird eine Zeichenkette und eine Zahl (Rechenergebnis) auf den Bildschirm geschrieben. Danach wird das Programm verlassen.
Geben Sie das Programm mit einem Editor ein und speichern Sie es unter dem Namen "hallo.java". Eine Quelldatei sollte immer den gleichen Namen haben, wie die darin definierte Klasse, in den meisten Fällen ist dies auch unumgänglich.
Starten Sie jetzt mit "javac hallo.java" den Compilerlauf. Wenn sich keine Tipfehler eingeschlichen haben, sollten Sie sich bald darauf wieder in der Kommandozeile befinden, wo sie das übersetzte Programm ("hallo.class") durch Eingabe von "java hallo" starten können. Achten Sie auf Groß- und Kleinschreibung!
Experimentieren Sie jetzt etwas mit dem Programm, indem Sie z.B. die Zeichenkette durch eine Rechenaufgabe ersetzen, z.B.: System.out.println(3+5). Ebenfalls durch den Plus-Operator lassen sich auch mehrere Zeichenketten verbinden, was dasselbe bewirkt, wie mehrere print-Befehle mit je einem Argument.
Sie können dem Objekt System.out natürlich auch andere Aufträge (Methoden) geben, die ein PrintStream versteht (siehe java.io.PrintStream).

3.2. Besonderheiten von String-Objekten

Dieses kleine Programm zeigt Ihnen, was Sie bei Vergleichen mit Strings beachten müssen. Benutzen Sie immer die "equals"-Methode, da der "=="-Operator die Objekte und nicht deren Inhalt vergleicht.

equal.java


/**
 * Zeigt Besonderheiten im Zusammenhang mit String-Objekten
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 19 Apr 97;  update: 19 Apr 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
final class equal {

  public static void main(String argv[]) {
    String a="test";
    String b="test";
    String c=new String("test");
    String d=new String("test");
    // Alle folgenden Anweisungen geben wahr oder falsch an die Konsole aus.
    System.out.println( "a==b             " +(a==b) );                // true;
    System.out.println( "c==d             " +(c==d) );                // false;
    System.out.println( "a==c             " +(a==c) );                // false;
    System.out.println( "a==\"test\"        " +(a=="test") );         // true;
    System.out.println( "c==\"test\"        " +(c=="test") );         // false;
    System.out.println();
    System.out.println( "\"test\"==\"test\"   " +("test"=="test") );  // true;
    System.out.println();
    System.out.println( "a.equals(b)      " +c.equals(d) );           // true;
    System.out.println( "c.equals(d)      " +c.equals(d) );           // true;
    System.out.println( "a.equals(c)      " +a.equals(c) );           // true;
    System.out.println( "a.equals(\"test\") " +a.equals("test") );    // true;
    System.out.println( "c.equals(\"test\") " +c.equals("test") );    // true;
  }

}

3.3. ein kleiner Directory-Anzeiger

Anhand dieses Programmes sollen Besonderheiten von Java, wie z.B. DocComments, Inner classes und Interfaces erklärt werden.

ls.java


import java.io.*;

/**
 * Inhalt des aktuelles Pfades anzeigen, Erweiterung kann angegeben werden.
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 07 Mar 97;  update: 07 Mar 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
class ls {
  
  static String ext=null; // Erweiterung der zu akzeptierenden Dateinamen
  
  /**
   * Inner class, die einen primitiven Dateinamenfilter implementiert
   */
  class EvalExt implements FilenameFilter {

    /**
     * Dateinamen akzeptieren oder ablehnen
     * @param dir  bearbeiteter Pfad
     * @param name Dateiname
     * @return true=aufnehmen, false=ablehnen
     */
    public boolean accept(File dir, String name) {
      if (ext==null)
        return true;
      if ( name.endsWith(ext) )
        return true;
      return false;
    }

  }

  
  /**
   * Hauptprogramm
   * @param argv Kommandozeilenparameter
   */
  public static void main(String argv[]) {
    if (argv.length==1) {
      ext=argv[0];
      System.out.println("liste alle Dateien mit der Endung \'"+ext+"\'.");
    } else if (argv.length<1) {
      System.out.println("liste den Inhalt des aktuellen Pfades.");
    } else if (argv.length>1) {
      System.out.println("zeigt alle oder nur ausgewählte Dateien.");
      System.out.println("syntax: ls [Erweiterung]");
      return;
    }
    File find=new File(".");
    String files[];
    ls inner=new ls();
    EvalExt Filter=inner. new EvalExt();
    files=find.list(Filter);
    if (files.length<1)
      System.out.println("  keine Einträge");
    else {
      for (int i=0; i<files.length; i++) {
        String current=files[i];
        File dummy=new File(current);
        System.out.println(current+"\t"+dummy.length()+" Bytes");
      }
    }
  }
  
}

Das Programm beginnt mit einem Import-Statement, welches alle Klassen unter java.io einbindet. Import ist eine aus der Programmiersprache Objective-C (NeXTSTEP) entnommene Erweiterung der #include-Directive von C++, die automatisch darauf achtet, daß keine Klasse mehrfach eingebunden wird, was "? already defined"-Meldungen vorbeugt.
Die folgenden Zeilen enthalten eine besondere Art des Kommentars, nämlich den in der Sprachdefinition von Java enthaltenen DocComment. Wie normale Kommentare (// und /* */) wird auch er vom Compiler ignoriert (bis auf den @deprecated-Tag, bei dem der Compiler eine Warnung ausgibt, siehe dazu die Tool-Dokumentation), aber mit dem in JDK enthaltenen Tool javadoc kann man sich auf diese Weise schnell eine API-Dokumentation basteln (lassen), denn javadoc sucht speziell nach Kommentaren in /** */ und erzeugt aus diesen HTML-Dokumente.
Als nächstes wird die Klasse ls definiert und in ihr die Variable ext. Die Definition von ext ist mit dem Modifier static versehen, was bedeutet, daß es sich um keine Instanz- sondern um eine Klassenvariable handelt, d.h. es gibt sie nicht einmal pro Instanz sondern nur einmal pro Klasse.
Bei der Programmausführung wird nun zuerst wie bei C nach der Methode main gesucht, der in dem Zeichenkettenfeld argv alle Kommandozeilenparameter übergeben werden. Hierbei ist neben den Modifiern "public static" zu beachten, daß der erste Parameter im Gegensatz zu C den Index 0 hat und nicht 1. "void" ist der Rückgabetyp der Methode.
Die Feldvariable "length" enthält die Anzahl der Elemente in "argv". Wurden keine Parameter übergeben, werden alle Dateien angezeigt, bei einem Parameter werden nur Dateien angezeigt, die mit diesem Text enden und bei mehr als einem Parameter wird eine Information zur Benutzung ausgegeben und dann das Programm beendet.
System.out ist ein PrintStream (siehe java.io.PrintStream), der standardmäßig mit der Konsole (Bildschirmausgabe) verbunden ist. Über seine println-Methode kann man leicht Zeichenketten, Zahlen und anderes ausgeben. Verschiedene Argumente können mit dem Plus-Operator verbunden werden.
Mit "typ name=new typ-Konstruktor(parameter)" legt man eine Instanz einer Klasse an. In diesem Fall wird ein neues File-Objekt mit dem Namen find erzeugt. Der Konstruktor ist "public File(String path)", als Pfad wird ".", also der aktuelle Pfad übergeben. Danach wird das neue Feld files angelegt, daß später die Einträge im Directory aufnehmen soll.
Die nächsten Zeilen sorgen sicher für etwas Verwirrung. Es gibt aber keine andere Möglichkeit, als daß die aktuelle Klasse eine Instanz von sich selbst erzeugt, um die innere Klasse evalExt (weiter vorn im Quellcode) instantiieren zu können. Wenn es sich bei der aufrufenden Methode nicht um eine static-Funktion handelt, geht es auch ein bißchen einfacher. Die erzeugte Instanz der Klasse evalExt wird nun der Methode list unserer Fileinstanz find übergeben, welche nun alle Dateien im aktuellen Pfad sucht und bei jeder den Filenamenfilter in evalExt fragt, ob die Datei aufgenommen werden soll.
Nun noch etwas genauer zur evalExt-Klasse. Hinter der Klassendefinition befindet sich noch die Erweiterung implements und dahinter der Name eines Interfaces (in diesem Fall java.io.FilenameFilter). Interfaces sind eine ebenfalls aus Objective-C übernommene Art der Mehrfachvererbung. Sie enthalten Vorgaben, die eine umsetzende Klasse erfüllen muß. So enthält z.B. FilenameFilter eine abstrakte Methode mit dem Namen accept. Da es zu dieser unvollständigen Methode keine Implementation gibt, muß die umsetzende (implementierende) Klasse eine liefern, was evalExt auch tut. Wenn der ext-String leer ist, wird jede Datei akzeptiert, ansonsten nur Dateinamen, die mit dem Text in ext enden.
Nun weiter im Hauptprogramm. Werden keine Einträge zurückgeliefert, bricht das Programm mit einer diesbezüglichen Meldung ab, ansonsten werden alle Dateinamen mit ihrer Dateilänge ausgegeben.

3.4. ein UNIX Wordcount Utility

wc.java


import java.io.*;
import java.util.*;

/**
 * Liefert Anzahl der eingegebenen Wörter
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 07 Mar 97;  update: 07 Mar 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
class wc {

  public static void main(String argv[]) {
    String srcName=null;
    int Lines=0, Words=0;
    if (argv.length==1) {
      srcName=argv[0];
      System.out.println("Zähle Wörter in \'"+srcName+"\'.");
    } else {
      System.out.println("WC liefert die Anzahl der Wörter in einer Textdatei.");
      System.out.println("syntax: wc Textdatei");
      return;
    }
    try {
      BufferedReader inp=new BufferedReader(new FileReader(srcName));
      String line=null;
      while ( (line=inp.readLine())!=null ) {
        Lines++;
        StringTokenizer st=new StringTokenizer(line);
        while (st.hasMoreTokens()) {
          st.nextToken();
          Words++;
        }
      }
      System.out.println("Die Datei enthält "+Words+" Wörter in "+Lines+" Zeilen.");
    } catch (IOException e) {
      System.out.println("Lesefehler oder Datei nicht gefunden!");
    }
  }
}

Das kleine Programm erfordert als Parameter eine beliebige Textdatei, deren Wort- und Zeilenanzahl es dann ausgibt. Für das Lesen der Datei wird erst einmal das Package java.io eingebunden. Der Compiler findet selbst heraus, welche Klassen des Paketes benötigt werden. Für die Zerlegung der Zeilen in Wörter wird der StringTokenizer aus java.util benötigt.
Zuerst wird jetzt eine neue Zeichenkette mit dem Namen srcName angelegt und die Variablen Lines (Zeilenanzahl) und Words (Wörter) werden mit 0 initialisiert. Das ist eigentlich nicht nötig, da der Compiler Integer-Variablen automatisch den Wert 0 zuweist.
Danach wird die Kommandozeile im Feld argv analysiert (siehe ls-Beispiel). Nur genau ein Parameter, nämlich der Name der Textdatei wird akzeptiert, alles andere führt zu einem Programmabbruch, vorher wird noch eine Beschreibung ausgegeben.
Das try-Statement leitet jetzt einen neuen Block ein, der mit einem oder mehreren catch-Statements endet. Wird innerhalb des Blockes eine Exception (Ausnahme) ausgelöst, so werden die Befehle im catch-Block ausgeführt. So kann man flexibel auf Situationen wie Lesefehler, nicht gefundene Dateien, o.ä. reagieren. Der finally-Block wird immer ausgeführt, auch wenn das Programm an irgend einer Stelle vorher schon lange beendet wurde.
Im try-Block wird ein neuer Eingabestrom namens inp erzeugt. Das sieht komplizierter aus als es ist. BufferedReader verlangt in seinem Konstruktor einen FileReader-Typ als Argument, welcher wiederum einen Dateinamen (String) als Argument erwartet. So muß man die Erzeugung des Objektes etwas verschachteln.
Danach wird ein String erzeugt, der die aktuelle Zeile aufnehmen soll. Nun wird die while-Schleife solange abgearbeitet, wie die readLine-Methode von inp einen nichtleeren String liefert. Gleichzeitig wird das Ergebnis (die gelesene Zeile) in line gespeichert. Diesen "Nebenwirkungseffekt" hat Java von C geerbt.
In der Schleife wird die Anzahl der Zeilen mit jeder gelesenen Zeile erhöht und ein StringTokenizer mit dem Namen st angelegt, der als Argument die aktuelle Zeile erhält. Nun wird in einer neuen while-Schleife solange die Wortanzahl erhöht, wie es mehr Token (durch Delimiter wie z.B. das Leerzeichen von einander getrennte Wörter) gibt.
Wurde das Dateiende erreicht, wird das Ergebnis ausgegeben und das Programm wird nach Abarbeitung des finally-Blockes beendet.

3.5. eine primitive Liste

Hier finden Sie ein klassisches Beispiel für objektorientierte Programmierung. Die Klasse "Liste" verwaltet eine Liste, über die nur über entsprechende Methoden zugegriffen werden kann.

list.java


/**
 * simuliert eine primitive Liste
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 09 Apr 97;  update: 09 Apr 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
class list {

  static Liste l;
  
  public static void main(String argv[]) {
    l=new Liste(5);
    evaluate( "Entferne ein Element", l.remove() );
    System.out.println("Schreibe Zufallswerte in die Liste.");
    int maxItem=(int)Math.pow(2,10);
    for ( int i=0; i<6; i++ )
      evaluate( "\tFüge Element hinzu", l.add( (int)(Math.random()*maxItem) ) );
    evaluate( "Entferne ein Element", l.remove() );
    System.out.println("Zeige Inhalt der Liste ("+l.length()+" Elemente).");
    for ( int i=0; i<l.length(); i++ )
      System.out.println( "\tElement an Stelle "+i+" = "+l.get(i) );
  }
  
  static void evaluate(String text, boolean status) {
    System.out.print(text+", ");
    if (status)
      System.out.print("erfolgreich");
    else
      System.out.print("unmoeglich");
    System.out.print( ", Elementanzahl: "+l.length() );
    int last=l.get( l.length()-1 );
    if (last==-1)
      System.out.println( ", letztes Element: keins" );
    else
      System.out.println( ", letztes Element: "+last );
  }
  
}


/**
 * Klasse, die die Liste verwaltet
 * benutzt von: klasse
 */
class Liste {
  
  int []array;
  int index;
  
  /**
   * erzeugt neues Listenobjekt
   * @param max h&ouml;cht m&ouml;gliche Anzahl von Elementen
   */
  public Liste(int max) {
    array=new int[max];
    index=0;
    System.out.println("Lege leere Liste an.");
  }
  
  /**
   * f&uuml;gt ein neues Element am Ende der Liste ein
   * @param item einzuf&uuml;gendes Element
   * @return erfolreich oder nicht
   */
  public boolean add(int item) {
    if (index<array.length) {
      array[index++]=item;
      return true;
    }
    return false;
  }
  
  /**
   * liefert Element an gegebener Position
   * @param pos Nummer des zu liefernden Elements
   * @return Element oder bei Fehler -1
   */
  public int get(int pos) {
    if ( (pos>index) || (pos<0) )
      return -1;
    return array[pos];
  }
  
  /**
   * liefert Element an gegebener Position
   * @return erfolreich oder nicht
   */
  public boolean remove() {
    if (index<1)
      return false;
    index--;
    return true;
  }
  
  /**
   * liefert Größe der Liste
   * @return Anzahl der Elemente in der Liste
   */
  public int length() {
    return index;
  }
  
}

Die Listenklasse kann Elemente hinzufügen, entfernen, auslesen und die Anzahl der Elemente bestimmen. Die "evaluate"-Methode dient lediglich zur Vereinfachung der Bildschirmausgabe. Im Hauptprogramm wird eine Instanz dieser Klasse erzeugt und dann wird die Funktionalität der Klasse etwas getestet. Das erste "remove" führt zu einem Fehler, da die Liste noch keine Elemente enthält, die man entfernen könnte. Dann werden 6 Zufallszahlen zwischen 0 und 2¹⁰ hinzugefügt. Das letzte wird wieder entfernt, die Anzahl der Elemente wird ausgegeben und diese aufgelistet.

3.6. Lohnberechnung

lohn.java


import java.io.*;

/**
 * Berechnet verschiedene Lohnarten
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 29 Mar 97;  update: 06 Apr 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
class lohn {
  
  static String dummy=null;
  static int y;
  
  public static void main(String argv[]) {
    System.out.println("Das Programm berechnet Zeit-, Praemien- und Akkordlohn.");
    while (true) {
      System.out.println();
      System.out.println("(0) Ende\t(1) Zeitlohn\t(2) Prämienlohn\t(3) Akkordlohn");
      Eingabe i=new Eingabe();
      do {
        y=i.getInt("Ihre Wahl");
        if (y==0)
          return;
      } while ( (y<1) || (y>3) );
      switch(y) {
      case 1  :new ZeitLohn(); break;
      case 2  :new PremLohn(); break;
      case 3  :new AkkLohn();  break;
      }
    }
  }
  
}


/**
 * abstrakte Lohnklasse
 */
abstract class SuperLohn {
  
  private Eingabe i;
  
  /**
   * Initialisierung der benötigten Daten
   */
  protected SuperLohn() {
    i=new Eingabe();
    System.out.println();
  }
  
  /**
   * Ausgabe des Ergebnisses
   * @param res auszugebendes Ergebnis
   */
  protected void status(float res) {
    System.out.println("Der zu zahlende Monatslohn ist "+res+" DM.");
    System.out.println();
  }
  
  /**
   * für alle Lohnklassen gleiche Eingaben
   * @return Tage pro Monat * Stunden pro Tag
   */
  protected float monatsLohn() {
    float z=input("Anwesenheit pro Tag in Stunden", 8);
    float d=input("Arbeitstage pro Monat", 21);
    System.out.println();
    return z*d;
  }
  
  /**
   * fordert Eingaben an und wertet diese aus
   * @param label auszugebende Beschreibung der Eingabe
   * @param def Vorgabewert
   * @return eingegebener Wert, wenn ungültig dann Vorgabewert
   */
  protected float input(String label, float def) {
    float dummy=i.getFloat(label+" ["+def+"] ");
    if (dummy>0)
      return dummy;
    else {
      System.out.println("\tbenutze default ("+def+")");
      return def;
    }
  }
  
}


/**
 * Berechnung des Zeitlohns
 */
class ZeitLohn extends SuperLohn {
  /**
   * führt Datenabfragen und Berechnungen f&uuml;r diese Lohnart aus
   */
  public ZeitLohn() {
    super();
    System.out.println("Zeitlohn = Anwesenheit * Stundenlohn");
    System.out.println();
    float g=input("Lohnsatz in DM pro Stunde", 15);
    status( monatsLohn()*g );
  }
}


/**
 * Berechnung des Praemienlohns
 */
class PremLohn extends SuperLohn {
  /**
   * führt Datenabfragen und Berechnungen f&uuml;r diese Lohnart aus
   */
  public PremLohn() {
    System.out.println("Bonus = Bonussatz * zusaetzliche Stueckzahl");
    System.out.println();
    float s=input("Soll-Anzahl in Stueck", 10);
    float i=input("tatsaechlich hergestellte Stueck", 14);
    float b=input("Bonushoehe in Prozent von Stundenlohn", 10);
    float l=input("Lohnsatz in DM pro Stunde", 15);
    float bon;
    if (i>s)
      bon=(i-s)*l*b/100;
    else
      bon=0;
    System.out.println("Bonus = "+bon+" DM");
    System.out.println();
    System.out.println("Stundenlohn = Tariflohn + Bonus");
    l+=bon;
    System.out.println("Stundenlohn = "+l+" DM");
    System.out.println();
    status( monatsLohn()*l );
  }
}


/**
 * Berechnung des Akkordlohns
 */
class AkkLohn extends SuperLohn {
  /**
   * führt Datenabfragen und Berechnungen f&uuml;r diese Lohnart aus
   */
  public AkkLohn() {
    System.out.println("Leistungsgrad = Vorgabezeit : Istzeit");
    System.out.println();
    float v=input("Vorgabezeit in Minuten", 20);
    float s=input("Istzeit in Minuten", 18);
    float lg=v/s;
    System.out.println("Leistungsgrad = "+lg);
    System.out.println();
    System.out.println("Akkordrichtsatz = Tariflohn + Akkordzuschlag");
    System.out.println();
    float az=input("Akkordzuschlag in Prozent", 3);
    float tl=input("Tariflohn in DM pro Stunde", 15);
    float ar=tl*(1+az/100);
    System.out.println("Akkordrichtsatz = "+ar+" DM");
    System.out.println();
    System.out.println("Stundenlohn = Akkordrichtsatz * Leistungsgrad");
    float sl=ar*lg;
    System.out.println("Stundenlohn = "+sl+" DM");
    System.out.println();
    status( monatsLohn()*sl );
  }
}


/**
 * Eingaben von der Konsole
 */
class Eingabe {
  
  /**
   * verlangt die Eingabe einer durch Enter abgeschlossenen Zeichenkette
   * @param label auszugebende Beschreibung der Eingabe
   * @return Eingabe, wenn ung&uuml;ltig dann null
   */
  public String getString(String label) {
    System.out.print(label+": ");
    StringBuffer ein=new StringBuffer();
    int a;
    try {
      while ( (a=System.in.read())!='\r' )
        ein.append((char)a);
      System.in.skip(System.in.available());
    } catch (IOException e) {
      return null;
    }
    return ein.toString();
  }
  
  /**
   * verlangt die Eingabe einer durch Enter abgeschlossenen Integer-Zahl (4 Stellen)
   * @param label auszugebende Beschreibung der Eingabe
   * @return Eingabe, wenn ung&uuml;ltig dann null
   */
  public int getInt(String label) {
    try {
      String st=getString(label);
      if ( (st.length()<1) || (st.length()>4) )
        return -1;
      Integer x=new Integer(st);
      return x.intValue();
    } catch (Exception e) {
      return -1;
    }
  }
  
  /**
   * verlangt die Eingabe einer durch Enter abgeschlossenen Fließkommazahl
   * @param label auszugebende Beschreibung der Eingabe
   * @return Eingabe, wenn ung&uuml;ltig dann null
   */
  public float getFloat(String label) {
    try {
      String st=getString(label);
      Float x=new Float(st);
      return x.floatValue();
    } catch (Exception e) {
      return -1;
    }
  }
  
}

Die Klasse Lohn ist das Hauptprogramm, übersetzen sie also das gesamte Programm mit "javac lohn.java" und starten Sie es dann mit "java lohn". Die benötigten Klassen werden mitübersetzt, auch wenn sie sich in anderen Quelldateien mit entsprechendem Namen befinden. Dann müssen sie allerdings als public deklariert werden.
Das Programm enthält eine abstrakte Klasse "SuperLohn". Diese unvollständige Klasse enthält Funktionen, die alle Lohnarten benötigen und als Subklassen von ihr erben. Die Superklasse selbst kann nicht instantiiert werden.
Alle Eingaben werden über die Klasse Eingabe abgewickelt. Die input-Methode in SuperLohn ist eine für den speziellen Zweck angepaßte Eingabefunktion, die im Fehlerfall einen Vorgabewert zurückliefert. Die Klassen sind online dokumentiert, so daß sich mit javadoc eine API-Dokumentation erstellen läßt. Dazu müssen allerdings alle Klassen public deklariert werden und sich in jeweils eigenen Quelldateien befinden.

3.7. eine Appletcation mit einem Menü

hi.html


<HTML>
<HEAD>
<TITLE>Hi l&auml;uft als Applet</TITLE>
</HEAD>

<BODY>
<P><H3 ALIGN=CENTER>Achtung!</H3>
Dieses Applet benutzt JDK1.1-spezifischen Code und ben&ouml;tigt einen
entsprechenden Browser. Starten Sie diese HTML-Datei mit dem <I>appletviewer</I>
aus dem JDK, mit HotJava oder mit <I>java</I> als Application.</P>
<APPLET CODE="hi.class" WIDTH=80 HEIGHT=60 ALT="Hier sollte ein Applet stehen!">
Mit einem Java-f&auml;higen Browser k&ouml;nnten Sie jetzt ein Applet sehen.
</APPLET>
</BODY></HTML>

Obenstehende HTML-Datei soll nicht weiter erläutert werden. Sie dient dazu, hi.class als Applet zu starten. Wenn sie mit dem appletviewer geladen wird, kommt ohnehin nur der im 2. Kapitel besprochene Applet-Tag zum Tragen.

hi.java


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

/**
 * Beispiel einer Appletcation mit Men&uuml;s und Texteingabe
 * known bug: exception beim Beenden als Applet (System.exit nicht erlaubt).
 * [ Java Tutorial Beispiel ]
 * @version        1.00;  started: 15 Jan 97;  update: 06 Apr 97
 * @author         Dirk Sch&ouml;nfu&szlig;
 */
class hi extends Applet {
  
  TextArea txt;
  
  class EvtHandler implements ActionListener  {
    int id;
    
    public EvtHandler() {
      id=0;
    }
    
    public void actionPerformed(ActionEvent e) {
      if ( e.getActionCommand()=="Ende" )
        System.exit(0);
      else if ( e.getActionCommand()=="Info" ) {
        id++;
        if (id<2)
          txt.append("\nDieser Menuepunkt tut gar nichts.");
        else
          txt.append("\nJetzt haben Sie schon "+id+" mal hier rumgeklickt!");
      }
    }
  }
  
  public void someCode() {
    EvtHandler evt=new EvtHandler();
    MenuBar menu=new MenuBar();
    Menu mDatei = new Menu("Datei");
    MenuItem dx;
    dx=new MenuItem("Info");
    dx.addActionListener(evt);
    mDatei.add( dx );
    dx=new MenuItem("Ende");
    dx.addActionListener(evt);
    mDatei.add( dx );
    menu.add(mDatei);
    Frame frMain = new Frame("Hallo!");
    frMain.setMenuBar(menu);
    txt=new TextArea("Willkommen!", 20, 10, TextArea.SCROLLBARS_NONE );
    frMain.add(txt);
    frMain.setSize(400, 300);
    frMain.show();
  }
  
  public void init() {
    someCode();
  }
  
  public static void main(String argv[]) {
    hi x=new hi();
    x.init();
  }
  
}

Obenstehendes Programm kann sowohl als Applet als auch als Application ausgeführt werden. Die dazu verwendete Technik mag etwas verwirren (die Klasse erzeugt eine Instanz von sich selbst), aber es ist der einzig mögliche Weg.
"hi.java" ist das einzige Beispielprogramm welches sich ein wenig mit dem "Abstract Window Toolkit" (AWT), der Grafikschnittstelle der Java-Plattform, beschäftigt. Besonderheiten des Programmes sind weiterhin die Verwendung einer "inner class" (EvtHandler) und des neuen Event-Modells im Java-Sprachstandard 1.1.

«« [ Inhalt ] »»

Copyright für Texte, Programme und Design 1997 by Dirk Schönfuß
WWW: http://rcswww.urz.tu-dresden.de/~schoenfu
e-mail: schoenfu@rcs.urz.tu-dresden.de