Contents

Chapter 1
Einführung

1.1  Ziel der Vorlesung

1.2  Programmieren

1.2.1  Disziplinen der Programmierung

• Spezifikation: Bevor eine Programmieraufgabe bewerkstelligt werden kann, muß das zu lösende Problem spezifiziert werden. Dieses kann informell durch eine natürlichsprachliche Beschreibung bis hin zu mathematisch beschriebenen Funktionen geschehen. Gegen die Spezifikation wird programmiert. Sie beschreibt das gewünschte Verhalten des zu erstellenden Programms.
• Modellieren: Bevor es an die eigentliche Codierung geht, wird in der Regel die Struktur des Programms modelliert. Auch dieses kann in unterschiedlichen Detaillierungsgraden geschehen. Manchmal reichen Karteikarten als hilfreiches Mittel aus, andernfalls empfiehlt sich eine umfangreiche Modellierung mit Hilfe rechnergestützter Werkzeuge. Für die objektorientierte Programmierung hat sich UML als eine geeignete Modellierungssprache durchgesetzt. In ihr lassen sich Klassendiagramme, Klassenhierarchien und Abhängigkeiten graphisch darstellen. Mit bestimmten Werkzeugen wie Together oder Rational Rose läßt sich direkt für eine UML-Modellierung Programmtext generieren.
• Codieren: Die eigentliche Codierung ist in der Regel der einzige Schritt, der direkt Code in der gewünschten Programmiersprache von Hand erzeugt. Alle anderen Schritte der Programmierung sind mehr oder weniger unabhängig von der zugrundeliegenden Programmiersprache.
Für die Codierung empfiehlt es sich, Konventionen zu verabreden, wie der Code geschrieben wird, was für Bezeichner benutzt werden, in welcher Weise der Programmtext eingerückt wird. Entwicklungsabteilungen haben zumeist schriftlich verbindlich festgeschriebene Richtlinien für den Programmierstil. Dieses erleichtert, den Code der Kollegen im Projekt schnell zu verstehen.
• Testen: Beim Testen sind generell zu unterscheiden:
  • Entwicklertests: Diese werden von den Entwicklern während der Programmierung selbst geschrieben, um einzelne Programmteile (Methoden, Funktionen) separat zu testen. Es gibt eine Schule, die propagiert, Entwicklertests vor dem Code zu schreiben (test first). Die Tests dienen in diesem Fall als kleine Spezifikationen.
  • Qualitätssicherung: In der Qualitätssicherung werden die fertigen Programme gegen ihre Spezifikation getestet (black box tests). Hierzu werden in der Regel automatisierte Testläufe geschrieben. Die Qualitätssicherung ist personell von der Entwicklung getrennt. Es kann in der Praxis durchaus vorkommen, daß die Qualitätsabteilung mehr Mitarbeiter hat als die Entwicklungsabteilung.
• Optimieren: Sollten sich bei Tests oder in der Praxis Performanzprobleme zeigen, sei es durch zu hohen Speicherverbrauch als auch durch zu lange Ausführungszeiten, so wird versucht, ein Programm zu optimieren. Hierzu bedient man sich spezieller Werkzeuge (profiler), die für einen Programmdurchlauf ein Raum- und Zeitprofil erstellen. In diesem Profil können Programmteile, die besonders häufig durchlaufen werden, oder Objekte, die im großen Maße Speicher belegen, identifiziert werden. Mit diesen Informationen lassen sich gezielt inperformante Programmteile optimieren.
• Verifizieren: Eine formale Verifikation eines Programms ist ein mathematischer Beweis der Korrektheit bezüglich der Spezifikation. Das setzt natürlich voraus, daß die Spezifikation auch formal vorliegt. Man unterscheidet:
  • partielle Korrektheit: wenn das Programm für eine bestimte Eingabe ein Ergebnis liefert, dann ist dieses bezüglich der Spezifikation korrekt.
  • totale Korrektheit: Das Programm ist partiell korrekt und terminiert für jede Eingabe, d.h. liefert immer nach endlich langer Zeit ein Ergebnis.
Eine formale Verifikation ist notorisch schwierig und allgemein nicht automatisch durchführbar. In der Praxis werden nur in ganz speziellen kritischen Anwendungen formale Verifikationen durchgeführt, z.B. bei Steuerungen gefahrenträchtiger Maschinen, so daß Menschenleben von der Korrektheit eines Programms abhängen können.
• Wartung/Pflege: den größten Teil seiner Zeit verbringt ein Programmierer nicht mit der Entwicklung neuer Software, sondern mit der Wartung bestehender Software. Hierzu gehören die Anpassung des Programms an neue Versionen benutzter Bibliotheken oder des Betriebssystems, auf dem das Programm läuft, sowie die Korrektur von Fehlern.
• Debuggen: Bei einem Programm ist immer damit zu rechnen, daß es Fehler enthält. Diese Fehler werden im besten Fall von der Qualitätssicherung entdeckt, im schlechteren Fall treten sie beim Kunden auf. Um Fehler im Programmtext zu finden, gibt es Werkzeuge, die ein schrittweises Ausführen des Programms ermöglichen (debugger). Dabei lassen sich die Werte, die in bestimmten Speicherzellen stehen, auslesen und auf diese Weise der Fehler finden.
• Internationalisieren (I18N)¹: Softwarefirmen wollen möglichst viel Geld mit ihrer Software verdienen und streben deshalb an, ihre Programme möglichst weltweit zu vertreiben. Hierzu muß gewährleistet sein, daß das Programm auf weltweit allen Plattformen läuft und mit verschiedenen Schriften und Textcodierungen umgehen kann. Das Programm sollte ebenso wie mit lateinischer Schrift auch mit Dokumenten in anderen Schriften umgehen können. Fremdländische Akzente und deutsche Umlaute sollten bearbeitbar sein. Aber auch unterschiedliche Tastaturbelegungen bis hin zu unterschiedlichen Schreibrichtungen sollten unterstützt werden.
Die Internationalisierung ist ein weites Feld, und wenn nicht am Anfang der Programmerstellung hierauf Rücksicht genommen wird, so ist es schwer, nachträglich das Programm zu internationalisieren.
• Lokalisieren (L12N): Ebenso wie die Internationalisierung beschäftigt sich die Lokalisierung damit, daß ein Programm in anderen Ländern eingesetzt werden kann. Beschäftigt sich die Internationalisierung damit, daß fremde Dokumente bearbeitet werden können, versucht die Lokalisierung, das Programm komplett für die fremde Sprache zu übersetzen. Hierzu gehören Menueinträge in der fremden Sprache, Beschriftungen der Schaltflächen oder auch Fehlermeldungen in fremder Sprache und Schrift. Insbesondere haben verschiedene Schriften unterschiedlichen Platzbedarf; auch das ist beim Erstellen der Programmoberfläche zu berücksichtigen.
• Portieren: Oft wird es nötig, ein Programm auf eine andere Plattform zu portieren. Ein unter Windows erstelltes Programm soll z.B. auch auf Unix-Systemen zur Verfügung stehen.
• Dokumentieren: Der Programmtext allein reicht in der Regel nicht aus, damit das Programm von Fremden oder dem Programmierer selbst nach geraumer Zeit gut verstanden werden kann. Um ein Programm näher zu erklären, wird im Programmtext Kommentar eingefügt. Kommentare erklären die benutzten Algorithmen, die Bedeutung bestimmter Datenfelder oder die Schnittstellen und Benutzung bestimmter Methoden.
Es ist zu empfehlen, sich anzugewöhnen, Quelltextdokumentation immer auf Englisch zu schreiben. Es ist oft nicht abzusehen, wer einmal einen Programmtext zu sehen bekommt. Vielleicht ein japanischer Kollege, der das Programm für Japan lokalisiert, oder der irische Kollege, der, nachdem die Firma mit einer anderen Firma fusionierte, das Programm auf ein anderes Betriebssystem portiert, oder vielleicht die englische Werksstudentin, die für ein Jahr in der Firma arbeitet.

1.2.2  Was ist ein Programm

pragmatische Antwort

mathematische Antwort

sprachwissenschaftliche Antwort

operationale Antwort

1.2.3  Klassifizierung von Programmiersprachen

Hauptklassen

• imperativ (C, Pascal, Fortran, Cobol): das Hauptkonstrukt dieser Sprachen sind Befehle, die den Speicher manipulieren.
• objektorientiert (Java, C++, C#, Eiffel, Smalltalk): Daten werden in Form von Objekten organisiert. Diese Objekte bündeln mit den Daten auch die auf diesen Daten anwendbaren Methoden.
• funktional (Lisp, ML, Haskell, Scheme, Erlang, Clean): Programme werden als mathematische Funktionen verstanden und auch Funktionen können Daten sein. Dieses Programmierparadigma versucht, sich möglichst weit von der Architektur des Computers zu lösen. Veränderbare Speicherzellen gibt es in rein funktionalen Sprachen nicht und erst recht keine Zuweisungsbefehle.
• Skriptsprachen (Perl, AWK): solche Sprachen sind dazu entworfen, einfache kleine Programme schnell zu erzeugen. Sie haben meist kein Typsystem und nur eine begrenzte Zahl an Strukturierungsmöglichkeiten, oft aber eine mächtige Bibliothek, um Zeichenketten zu manipulieren.
• logisch (Prolog): aus der KI (künstlichen Intelligenz) stammen logische Programmiersprachen. Hier wird ein Programm als logische Formel, für die ein Beweis gesucht wird, verstanden.

Ausführungsmodelle

• kompiliert (C, Cobol, Fortran): in einem Übersetzungsschritt wird aus dem Quelltext direkt das ausführbare Programm erzeugt, das dann unabhängig von irgendwelchen Hilfen der Programmiersprache ausgeführt werden kann.
• interpretiert (Lisp, Scheme): der Programmtext wird nicht in eine ausführbare Datei übersetzt, sondern durch einen Interpreter Stück für Stück anhand des Quelltextes ausgeführt. Hierzu muß stets der Interpreter zur Verfügung stehen, um das Programmm auszuführen. Interpretierte Programme sind langsamer in der Ausführung als übersetzte Programme.
• abstrakte Maschine über byte code (Java, ML): dieses ist quasi eine Mischform aus den obigen zwei Ausführungsmodellen. Der Quelltext wird übersetzt in Befehle nicht für einen konkreten Computer, sondern für eine abstrakte Maschine. Für diese abstrakte Maschine steht dann ein Interpreter zur Verfügung. Der Vorteil ist, daß durch die zusätzliche Abstraktionsebene der Übersetzer unabhängig von einer konkreten Maschine Code erzeugen kann und das Programm auf auf allen Systemen laufen kann, für die es einen Interpreter der abstrakten Maschine gibt.

javac Test.java 

java Test

Übersetzen eines erste Javaprogramms

class FirstProgram{
  public static void main(String [] args){
    System.out.println("hello world");
  }
}

class Answer {
  public static void main(String [] args){
    System.out.println(42);
  }
}

1.2.4  Arbeitshypothese

Beim Programmieren versuchen wir, zwischen Daten und Programmen zu unterscheiden. Programme manipulieren Daten, indem sie sie löschen, anlegen oder überschreiben.

Chapter 2
Objektorientierte Programmierung mit Java

2.1  Grundkonzepte der Objektorientierung

2.1.1  Objekte und Klassen

Objektorientierte Modellierung

• Personen, die Bücher ausleihen wollen.
• Bücher, die ausgeliehen werden können.
• Tatsächliche Ausleihvorgänge, die ausdrücken, daß ein Buch bis zu einem bestimmten Zeitraum von jemanden ausgeliehen wurde.
• Termine, also Objekte, die ein bestimmtes Datum kennzeichnen.

Klassen in Java

In Java steht genau eine Klassendefinition⁴ in genau einer Datei. Die Datei hat dabei den Namen der Klasse mit der Endung .java.

class Minimal {
}

Beachten Sie, daß Groß- und Kleinschreibung in Java relevant ist. Alle Schlüsselwörter wie class werden stets klein geschrieben. Klassennamen starten per Konvention immer mit einem Großbuchstaben.

Objekte

new Minimal();

"hallo "+"welt"

2.1.2  Felder und Methoden

Felder

Beispiel:
Im Folgenden schreiben wir eine Klasse mit zwei Feldern:

class ErsteFelder {
  Minimal meinFeld;
  String  meinTextFeld;
}

Beispiel:
In der folgenden Klasse definieren wir nicht nur, daß die Objekte der Klasse zwei Felder eines bestimmten Typs haben, sondern weisen auch gleich schon Werte, d.h. konkrete Daten diesen Feldern zu.

class ErsteFelder2 {
  Minimal meinFeld = new Minimal();
  String  meinTextFeld = "hallo";
}

Methoden

Beispiel:
Als Beispiel definieren wir eine Klasse, in der es eine Methode addString gibt, die den Ergebnistyp String und zwei Parameter vom Typ String hat:

class StringUtilMethod {
  String addStrings(String leftText, String rightText){
    return leftText+rightText;
  }
}

Beispiel:
Wir können mit den bisherigen Mitteln eine kleine Klasse definieren, die es erlaubt, Personen zu repräsentieren, so daß die Objekte dieser Klasse eine Methode haben, um den vollen Namen der Person anzugeben:

class PersonExample1 {
  String vorname;
  String nachname;

  String getFullName(){
    return (vorname+" "+nachname);
  }
}

Beispiel:
Folgende kleine Beispielklasse enthält zwei Methoden zum Setzen neuer Werte für ihre Felder:

class PersonExample2 {
  String vorname;
  String nachname;

  void setVorname(String newName){
    vorname = newName;
  }
  void setNachname(String newName){
    nachname = newName;
  }
}

Konstruktoren

class Person1 {
  String vorname;
  String nachname;

  Person1(String derVorname, String derNachname){
    vorname  = derVorname;
    nachname = derNachname;
  }  

  String getFullName(){
    return (vorname+" "+nachname);
  }
}

Beispiel:
Wir erzeugen ein Personenobjekt mit dem für die entsprechende Klasse geschriebenen Konstruktor:

class TestePerson1 {

  public static void main(String [] _){
    new Person1("Nicolo","Paganini");
  }
}

lokale Felder

class FirstLocalFields{
  public static void main(String [] args){
    String str1 = "hello";
    String str2 = "world";
    System.out.println(str1);
    System.out.println(str2);
    String str3 = str1+" "+str2;
    System.out.println(str3);
  }
}

Zugriff auf Eigenschaften eines Objektes

class GetPersonName{
  public static void main (String [] args){
    Person1 p = new Person1("August","Strindberg");

    String name = p.vorname;
    System.out.println(name);
  }
}

class CallFullNameMethod{
  public static void main (String [] args){
    Person1 p = new Person1("August","Strindberg");

    String name = p.getFullName();
    System.out.println(name);
  }
}

• Personen mit Namen, Vornamen, Straße, Ort und Postleitzahl.
• Bücher mit Titel und Autor.
• Datum mit Tag, Monat und Jahr.
• Buchausleihe mit Ausleiher, Buch und Datum.

{\bf \alph{unteraufgabe})} Schreiben Sie geeignete Konstruktoren für diese Klassen.
{\bf \alph{unteraufgabe})} Schreiben Sie für jede dieser Klassen eine Methode public String toString() mit dem Ergebnistyp. Das Ergebnis soll eine gute textuelle Beschreibung des Objektes sein.⁷
{\bf \alph{unteraufgabe})} Schreiben Sie eine Hauptmethode in einer Klasse Main, in der Sie Objekte für jede der obigen Klassen erzeugen und die Ergebnisse der toString-Methode auf den Bildschirm ausgeben.

2.1.3  der this-Bezeichner

class UseThis {
  String aField ;
  UseThis(String aField){
    this.aField = aField;
  }
}

2.2  statische Eigenschaften

class StaticTest {
  static void printThisText(String text){
    System.out.println(text);
  }
}

class CallStaticTest {
  public static void main(String [] args){
    StaticTest.printThisText("hello");
  }
}

Chapter 3
Imperative Konzepte

3.1  Primitive Typen, die klassenlose Gesellschaft

3.1.1  Zahlenmengen in der Mathematik

• natürliche Zahlen \mathdsN: Eine induktiv definierbare Menge mit einer kleinsten Zahl, so daß es für jede Zahl eine eindeutige Nachfolgerzahl gibt.
• ganze Zahlen \mathdsZ: Die natürlichen Zahlen erweitert um die mit einem negativen Vorzeichen behafteten Zahlen, die sich ergeben, wenn man eine größere Zahl von einer natürlichen Zahl abzieht.
• rationale Zahlen \mathdsQ: Die ganzen Zahlen erweitert um Brüche, die sich ergeben, wenn man eine Zahl durch eine Zahl teilt, von der sie kein Vielfaches ist.
• reelle Zahlen \mathdsR: Die ganzen Zahlen erweitert um irrationale Zahlen, die sich z.B. aus der Quadratwurzel von Zahlen ergeben, die nicht das Quadrat einer rationalen Zahl sind.
• komplexe Zahlen \mathdsC: Die reellen Zahlen erweitert um imaginäre Zahlen, wie sie benötigt werden, um einen Wurzelwert für negative Zahlen darzustellen.

3.1.2  Zahlenmengen im Rechner

3.1.3  natürliche Zahlen

• 2: Dualsystem
• 8: Oktalsystem
• 10: Dezimalsystem
• 16: Hexadezimalsystem¹⁰

Beispiel:
Die Zahl 10 in Bezug auf unterschiedliche Basen dargestellt:

3.1.4  ganze Zahlen

Vorzeichen und Betrag

Beispiel:
In der Darstellung durch Vorzeichen und Betrag werden bei einer Wortlänge von 8 Bit die Zahlen 10 und -10 durch folgende Bitmuster repräsentiert: 00001010 und 10001010.

Beispiel:
Versuchen wir, das gängige Additionsverfahren für 10 und -10 in der Vorzeichendarstellung anzuwenden, so erhalten wir:

Einerkomplement

Beispiel:
Bei einer Wortlänge von 8 Bit werden die Zahlen 10 und -10 durch folgende Bitmuster dargestellt: 00001010 und 11110101.

Zweierkomplement

Beispiel:
Bei einer Wortlänge von 8 Bit werden die Zahlen 10 und -10 durch folgende Bitmuster dargestellt: 00001010 und 11110110.

class TestInteger {
  public static void main(String [] _){
    System.out.println(2147483647+1);
    System.out.println(-2147483648-1);
  }
}

Frage eines Softwaremenschen an die Hardwarebauer

3.1.5  Kommazahlen

Festkommazahlen

Fließkommazahlen

• die Mantisse für die darstellbaren Ziffern. Die Mantisse charakterisiert die Genauigkeit der Fließkommazahl.
• der Exponent, der angibt, wie weit die Mantisse hinter bzw. vor dem Komma liegt.

• float: 32 Bit Fließkommazahl nach IEEE 754. Kleinste positive Zahl: 2^-149. Größte positive Zahl: (2-2^-23)*¹²⁷
• double: 64 Bit Fließkommazahl nach IEEE 754. Kleinste positive Zahl: 2^-1074. Größte positive Zahl: (2-2^-52)*¹⁰²³

Beispiel:
Der folgende Test zeigt, daß bei einer Addition von zwei Fließkommazahlen die kleinere Zahl das Nachsehen hat:

class DoubleTest{
  public static void main(String [] args){
    double x = 325e200;
    double y = 325e-200;
    System.out.println(x);
    System.out.println(y);
    System.out.println(x+y);
    System.out.println(x+100000);
  } 
}

sep@linux:~/fh/prog3/examples/src> java DoubleTest
3.25E202
3.25E-198
3.25E202
3.25E202
sep@linux:~/fh/prog3/examples/src>

Beispiel:
Das folgende kleine Beispiel zeigt, inwieweit und für den Benutzer oft auf überraschende Weise die Fließkommadarstellung zu Rundungen führt:

class Rounded {
  public static void main(String [] args){
    System.out.println(8f);
    System.out.println(88f);
    System.out.println(8888f);
    System.out.println(88888f);
    System.out.println(888888f);
    System.out.println(8888888f);
    System.out.println(88888888f);
    System.out.println(888888888f);
    System.out.println(8888888888f);
    System.out.println(88888888888f);
    System.out.println(888888888888f);
    System.out.println(8888888888888f);

    System.out.println(1f+1000000000000f-1000000000000f);
  } 
}

sep@linux:~/fh/prog3/examples/src> java Rounded
8.0
88.0
8888.0
88888.0
888888.0
8888888.0
8.8888888E7
8.888889E8
8.8888893E9
8.8888885E10
8.8888889E11
8.8888889E12
0.0
sep@linux:~/fh/prog3/examples/src>

3.1.6  Der Typ: boolean

class Testbool{
  boolean boolFeld;

  Testbool(boolean b){
    boolFeld = b;
  }

  boolean getBoolFeld(){
    return this.boolFeld;
  }

  public static void main(String [] args){
    Testbool t = new Testbool(true);
    System.out.println(t.getBoolFeld());
    t = new Testbool(false);
    System.out.println(t.getBoolFeld());
  }
}

3.2  Operatoren

• Präfix: Der Operator wird vor den Operanden geschrieben, also z.B. (* 2 21). Im ursprünglichen Lisp gab es die Prefixnotation für Operatoren.
• Postfix: Der Operator folgt den Operanden, also z.B. (21 2 *). Forth und Postscript sind Beispiele von Sprachen mit Postfixnotation.
• Infix: Der Operator steht zwischen den Operanden. Dieses ist die gängige Schreibweise in der Mathematik und für das Auge die gewohnteste. Aus diesem Grunde bedient sich Java der Infixnotation: 42 * 2.

Die Grundrechenarten

class PunktVorStrich{
  public static void main(String [] args){
    System.out.println(2 + 20 * 2);
    System.out.println((2 + 20) * 2);
  }
}

class Square{
  static int square(int i){
    return i*i;
  }
}

Vergleichsoperatoren

class Vergleich{

  public static void main(String[] args){
    System.out.println(1+1 < 42);
    System.out.println(1+1 <= 42);
    System.out.println(1+1 >  42);
    System.out.println(1+1 >= 42);
    System.out.println(1+1 == 42);
    System.out.println(1+1 != 42);
  }
}

Bool'sche Operatoren

class TestboolOperator{
  public static void main(String [] args){
    System.out.println(true && false);
    System.out.println(true || false);
    System.out.println(!true || false);
    System.out.println(true || true && false);
  }
}

class TestboolOperator2{
  static boolean implication(boolean a, boolean b){
    return !a || b;
  }

  public static void main(String [] args){
    System.out.println(implication(true, false));
  }
}

3.3  Zusammengesetzte Befehle

3.3.1  Bedingungsabfrage mit: if

class FirstIf {

  static void firstIf(boolean bedingung){
    if (bedingung) {
      System.out.println("Bedingung ist wahr");
    } else {
      System.out.println("Bedingung ist falsch");
    }
  }
 
  public static void main(String [] args){
     firstIf(true || false);
  }

}

class FirstIf2 {

  static void firstIf(boolean bedingung){
    if (bedingung) System.out.println("Bedingung ist wahr");
    else System.out.println("Bedingung ist falsch");
  }
 
  public static void main(String [] args){
     firstIf(true || false);
  }

}

class ElseIf {

  static String lessOrEq(int i,int j){
    if (i<10)  return "i kleiner zehn";
    else if (i>10)  return "i größer zehn";
    else if (j>10)  return "j größer zehn";
    else if (j<10)  return "j kleiner zehn";
    else return "j=i=10";
  }
 
  public static void main(String [] args){
     System.out.println(lessOrEq(10,9));
  }

}

class Summe{
  static int summe(int i){
    if (i==1)  {
      return 1;
    }else {
      return summe(i-1) + i;
    }
  }
}

• Eine Methode click(), die den internen Zähler um eins erhöht.
• Eine Methode reset(), die den Zähler wieder auf den Wert 0 setzt.
• Eine Methode, die den aktuellen Wert des Zählers ausgibt.

3.3.2  Iteration

Schleifen mit: while

• die Bedingung
• und den Schleifenrumpf.

class WhileTest {
  public static void main(String [] args){
    int i = 0;
    while (i < 10){
      i = i+1;
      System.out.println(i);    
    }
  }
}

class Summe2 {
  public static int summe(int n){

    int erg = 0 ;              // Feld für Ergebnis.
    int j   = n ;              // Feld zur Schleifenkontrolle.

    while (j>0){               // j läuft von n bis 1.     
      erg = erg + j;           // akkumuliere das Ergebnis.
      j = j-1;                 // verringere Laufzähler.
    }

    return erg;
  }
}

class Bottom {
   static public void bottom(){
     while (wahr()){};
   }

   static boolean wahr(){return true;}

   public static void main(String [] _){bottom();}
}

class DoTest {
  public static void main(String [] args){
    int i = 0;
    do {
      System.out.println(i);    
      i = i+1;
    } while (i < 10);
  }
}

class VorUndNach {

  public static void main(String [] args){

      while (falsch()) 
         {System.out.println("vorgeprüfte Schleife");};

      do {System.out.println("nachgeprüfte Schleife");} 
      while (false);
  }

  public static boolean falsch(){return false;}
}

Schleifen mit: for

• eine Initialisierung der relevanten Schleifensteuerungsvariablen (init),
• ein Prädikat als Schleifenbedingung (pred)
• und einen Befehl, der die Schleifensteuerungsvariable weiterschaltet (step).

class ForTest {
  public static void main(String [] args){

    for (int i=0; i<10; i=i+1){
      System.out.println(i);    
    }  

  }
}

class Summe3 {
  public static int summe(int n){

    int erg = 0 ;                   // Feld für Ergebnis

    for (int j = n;j>0;j=j-1){      // j läuft von n bis 1     
      erg = erg + j;                // akkumuliere das Ergebnis
    }

    return erg;
  }
}

class Summe4 {
  public static int summe(int n){

    int erg = 0 ;              // Feld für Ergebnis.
    int j   = n;              // Feld zur Schleifenkontrolle

    for (;j>0;){               // j läuft von n bis 1     
      erg = erg + j;           // akkumuliere das Ergebnis.
      j = j-1;                 // verringere Laufzähler  
    }

    return erg;
  }
}

Vorzeitiges Beenden von Schleifen

class BreakTest {
  public static void main(String [] args){
    int i = 0;
    while (true){
      if (i>9) {break;};
      i = i+1;
      System.out.println(i);    
    }
  }
}

class ForBreak {
  public static void main(String [] args){
    int i = 0;
    for (;;){
        if (i>9) break;
        System.out.println(i);
        i=i+1; 
    }  
  }
}

class ContTest{
  public static void main(String [] args){
     for (int i=1; i<1000;i=i+1){           
        if (!(i % 17 == 0 || i % 19 == 0) )
   //wenn nicht die Zahl durch 17 oder 19 ohne Rest teilbar ist
            continue;
	System.out.println(i);  
     }
  }
}

Kritik an Javas Schleifenkonstrukten

for x in 0 to 9 do
  System.out.println(x)
end for

for $x in 0 to 9
return <zahl>{$x}</zahl>

<autoren>{
  for $autor in $buchliste/buch/autor 
  return $autor 
  sortBy (./text())
}</autoren>

• [1,2..10] erzeugt die Liste der Zahlen 1 bis 10
• [2,4..100] erzeugt die Liste der geraden Zahlen bis 100
• [x*x | x<-[1,2..]] erzeugt die unendliche Liste der Quadratzahlen entsprechend dem mathematischen Ausdruck: {x²|x Î \mathdsN}

let sieb (x:xs)=(x:sieb [y|y<-xs,mod y x /= 0]) in sieb [2,3..]

3.3.3  Rekursion und Iteration

class StackTest {
  public static void main(String [] args){
    System.out.println(count1(0));
    System.out.println(count2(0));
  }

  public static int count1(int k){
    int j = 2;
    for (int i= 0;i<1000000000;i=i+1){
      j=j+1;
    }  
    return j;
  }

  public static int count2(int i){
      if (i<1000000000) return count2(i+1) +1; else return 2;
  }

}

3.4  Ausdrücke und Befehle

3.4.1  Bedingungen als Befehl oder als Ausdruck

class CondExpr {
  public static void main(String [] _){
    System.out.println(true?1:2);
    System.out.println(false?3:4);
  }
}

sep@linux:~/fh/prog1/examples/classes> java CondExpr
1
4
sep@linux:~/fh/prog1/examples/classes>

3.4.2  Auswertungsreihenfolge und Seiteneffekte von Ausdrücken

Reihenfolge der Operanden

class Minus {

  static public int sub(int x,int y){
    int erg = x-y;
    System.out.println("eine Subtraktion mit Ergebnis: "
                       +erg+" wurde durchgeführt.");
    return erg;
  }
}

class Operatorauswertung {

   public static void main(String [] args){
     System.out.println(Minus.sub(23,1)*Minus.sub(4,2));
   }
}

sep@swe10:~/fh/prog1/beispiele> java Operatorauswertung 
eine Subtraktion mit Ergebnis: 22 wurde durchgeführt.
eine Subtraktion mit Ergebnis: 2 wurde durchgeführt.
44
sep@swe10:~/fh/prog1/beispiele> 

Auswertung der Methodenargumente

public class Reihenfolge{

    /**
       Returns second argument.
       @param x ignored  argument.
       @param y returned argument.
       @return projection on second argument.
     **/
  public static int snd(int x,int y){return y;}

    /**
       Returns the constants 1 and prints its argument.  
       @param  str The String that is printed as side effect.
       @return constantly 1. 
    **/
  public static int eins(String str){
    System.out.println(str); return 1;
  }

  public static void main(String [] args){
    //<bluev>test, in which order arguments are evaluated.</bluev>
    snd(eins("a"),eins("b"));
}}

Terminierung

class TerminationTest {
    /**
      Nonterminating method.
      @return never returns anything.
     **/
  public static int bottom( ){while(wahr()){};return 1; }

    /**
       Returns the constants 1 and prints its argument.  
       @param  str The String that is printed as side effect.
       @return constantly 1. 
    **/
  public static int eins(String str){
    System.out.println(str); return 1;
  }

    /**
       Constantly true method.
       @return constantly the value true.
    **/
  public static boolean wahr( ){return true; }

    /**
       Method mimicking conditional expression.
       @param pre The boolean condition.
       @param a1 The positive alternative.
       @param a2 The negative alternative.
       @return in case of pre the second otherwise third argument
     **/
  public static int wenn(boolean pre,int a1,int a2 ){
    return pre?a1:a2; }

  public static void main(String [] args){

    //test, whether both alternatives of conditional
    //expression are evaluated or just one.

    //this will terminate:
    System.out.println(      false?bottom():eins("b")   );
    
    //this won't terminate:
    System.out.println(wenn( false,bottom(),eins("b") )  );
  }
}

3.4.3  Auswertung der bool'schen Operatoren

true ÚA = true und false ÙA = false

class LazyBool {

  static boolean booleanExpr(){
    System.out.println("in booleanExpr");
    return true;
  }

  static public void main(String [] _){
    System.out.println(true || booleanExpr());
    System.out.println(false && booleanExpr());
  }

}

sep@linux:~/fh/prog1/examples/classes> java LazyBool
true
false
sep@linux:~/fh/prog1/examples/classes>

strikte bool'sche Operatoren

class StrictBool {

  static boolean booleanExpr(){
    System.out.println("in booleanExpr");
    return true;
  }

  static public void main(String [] _){
    System.out.println(true | booleanExpr());
    System.out.println(false & booleanExpr());
  }

}

sep@linux:~/fh/prog1/examples/classes> java StrictBool
in booleanExpr
true
in booleanExpr
false
sep@linux:~/fh/prog1/examples/classes>

{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse Roman. Diese Klasse soll eine natürliche Zahl darstellen.
{\bf \alph{unteraufgabe})} Schreiben Sie für Ihre Klasse Roman einen Konstruktor, der ein Stringobjekt als Parameter hat. Dieser Stringparameter soll eine römische Zahl darstellen. Der Konstruktor soll diese Zahl lesen und in einem Feld des Typs int abspeichern.
{\bf \alph{unteraufgabe})} Implementieren Sie die Methode public String toString() für Ihre Klasse Roman, die die intern gespeicherte Zahl als römische Zahl dargestellt zurückibt.
{\bf \alph{unteraufgabe})} Fügen Sie ihrer Klasse Roman die folgenden Methoden für arithmetische Rechnungen hinzu.
• Roman add(Roman other)
• Roman sub(Roman other)
• Roman mul(Roman other)
• Roman div(Roman other)

{\bf \alph{unteraufgabe})} Testen Sie Ihre Klasse Roman.

Chapter 4
Vererbung

class Person {

  String name ;
  String address;

  Person(String name, String address){
    this.name = name;
    this.address = address;
  }

  public String toString(){
    return name+", "+address;
  }
}

class StudentOhneVererbung {

  String name ;
  String address;
  int matrikelNummer;

  StudentOhneVererbung(String name, String address,int nr){
    this.name = name;
    this.address = address;
    matrikelNummer = nr;
  }

  public String toString(){
    return    name + ", " + address
            + " Matrikel-Nr.: " + matrikelNummer;
  }
}

class Student extends Person {

• Erweitern: zu den Eigenschaften der Oberklasse werden weitere Eigenschaften hinzugefügt. Im Beispiel der Studentenklasse soll das Feld matrikelNummer hinzugefügt werden.
• Verändern: eine Eigenschaft der Oberklasse wird umdefiniert. Im Beispiel der Studentenklasse soll die Methode toString der Oberklasse in ihrer Funktionalität verändert werden.

4.1  Hinzufügen neuer Eigenschaften

  int matrikelNummer;

String writeAllFields(Student s){
   return s.name+" "+s.address+" "+s.matrikelNummer;
}

int getMatrikelNummer(){
  return matrikelNummer;
}

4.2  Überschreiben bestehender Eigenschaften

  public String toString(){
    return    name + ", " + address
            + " Matrikel-Nr.: " + matrikelNummer;
  }

4.3  Konstruktion

   Student(String name,String adresse,int nr){
     super(name,adresse);
     matrikelNummer = nr;
   }
}

class TestStudent {
  public static void main(String [] _){
    Student s
     = new Student("Martin Müller","Hauptstraße 2",755423);
    System.out.println(s);
  }
}

4.4  Zuweisungskompatibilität

class TestStudent1{
  public static void main(String [] args){
    Person p 
     = new Student("Martin Müller","Hauptstraße",7463456);
  }
}

class StudentError1{
  public static void main(String [] args){
    Student s
      = new Person("Martin Müller","Hauptstraße");
  }
}

StudentError1.java:3: incompatible types
found   : Person
required: Student
    Student s = new Person("Martin Müller","Hauptstraße");
                ^
1 error

class TestStudent2 {
   
  static void printPerson(Person p){
    System.out.println(p.toString());
  }

  public static void main(String [] args){
     Student s
       = new Student("Martin Müller","Hauptstraße",754545);
     printPerson(s);
  }
}

class StudentError2{
   
  static void printStudent(Student s){
    System.out.println(s.toString());
  }

  public static void main(String [] args){
     Person p = new Person("Martin Müller","Hauptstraße");
     printStudent(p);
  }
}

StudentError2.java:9: printStudent(Student) in StudentError2 
                      cannot be applied to (Person)
     printStudent(p);
     ^
1 error

4.5  Späte Bindung (late binding)

class TestLateBinding {
 
  public static void main(String [] args){
    Student s = new Student("Martin Müller","Hauptstraße",756456);
    Person p1 = new Person("Harald Schmidt","Marktplatz");
    
    System.out.println(s.toString());
    System.out.println(p1.toString());

    Person p2 = new Student("Martin Müller","Hauptstraße",756456);
    System.out.println(p2.toString());
  }
}

sep@swe10:~/fh/> java TestLateBinding
Martin Müller, Hauptstraße Matrikel-Nr.: 756456
Harald Schmidt, Marktplatz
Martin Müller, Hauptstraße Matrikel-Nr.: 756456

System.out.println(p2.toString());

Objekt, das in Feld p2 gespeichert ist, führe bitte deine Methode toString aus.

• ButtonLogic

  class ButtonLogic {
    String getDescription(){
      return "in Großbuchstaben umwandeln";
    }
    String eval(String x){return x.toUpperCase();}
  }
  
  

Dialogue

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
class Dialogue extends JFrame{

  final ButtonLogic logic; 

  final JButton button;
  final JTextField inputField  = new JTextField(20) ;
  final JTextField outputField = new JTextField(20) ;
  final JPanel p = new JPanel();

  Dialogue(ButtonLogic l){
    logic = l;
    button=new JButton(logic.getDescription());
    button.addActionListener
     (new ActionListener(){
        public void actionPerformed(ActionEvent _){
          outputField.setText
             (logic.eval(inputField.getText().trim()));
        }
      });
    p.setLayout(new BorderLayout());
    p.add(inputField,BorderLayout.NORTH);
    p.add(button,BorderLayout.CENTER);
    p.add(outputField,BorderLayout.SOUTH);
    getContentPane().add(p);
    pack();
    setVisible(true);
  }
}

TestDialogue
class TestDialogue {
  public static void main(String [] _){
    new Dialogue(new ButtonLogic());
  }
}

{\bf \alph{unteraufgabe})} Übersetzen Sie die drei Klassen und starten Sie das Programm.
{\bf \alph{unteraufgabe})} Schreiben Sie eine Unterklasse der Klasse ButtonLogic. Sie sollen dabei die Methoden getDescription und eval so überschreiben, daß der Eingabestring in Kleinbuchstaben umgewandelt wird. Schreiben Sie eine Hauptmethode, in der Sie ein Objekt der Klasse Dialogue mit einem Objekt Ihrer Unterklasse von ButtonLogic erzeugen.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt eine Unterklasse der Klasse ButtonLogic, so daß Sie im Zusammenspiel mit der Guiklasse Dialogue ein Programm erhalten, in dem Sie römische Zahlen in arabische Zahlen umwandeln können. Testen Sie Ihr Programm.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt eine Unterklasse der Klasse ButtonLogic, so daß Sie im Zusammenspiel mit der Guiklasse Dialogue ein Programm erhalten, in dem Sie arabische Zahlen in römische Zahlen umwandeln können. Testen Sie Ihr Programm.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt ein Guiprogramm, daß eine Zahl aus ihrer Darstellung zur Basis 10 in eine Darstellung zur Basis 2 umwandelt. Testen Sie.

4.5.1  Methoden als Daten

  Dialogue(ButtonLogic l){
    logic = l;
    button=new JButton(logic.getDescription());

4.6  Zugriff auf Methoden der Oberklasse

  public String toString(){
    return    name + ", " + address
            + " Matrikel-Nr.: " + matrikelNummer;
  }

name + ", " + address

  public String toString(){
    return      //call toString of super class
                super.toString()  
                //add the Matrikelnummer
            + " Matrikel-Nr.: " + matrikelNummer;
  }

4.7  Die Klasse Object

4.7.1  Die Methode equals

public boolean equals(Object other)

public boolean equals(Object other){
  return        this.name.equals(other.name) 
             && this.adresse.equals(other.adresse);
}

4.8  Klassentest

class InstanceOfTest {
  public static void main(String [] str){
     Person p1 = new Person("Strindberg","Skandinavien");
     Person p2 = new Student("Ibsen","Skandinavien",789565);
     if (p1 instanceof Student) 
       System.out.println("p1 ist ein  Student.");
     if (p2 instanceof Student) 
       System.out.println("p2 ist einStudent.");
     if (p1 instanceof Person) 
       System.out.println("p1 ist eine Person.");
     if (p2 instanceof Person) 
       System.out.println("p2 ist eine Person.");
  }
}

sep@swe10:~/fh> java InstanceOfTest
p2 ist einStudent.
p1 ist eine Person.
p2 ist eine Person.

4.9  Typzusicherung (Cast)

class CastTest {
  public static void main(String [] str){
    Person p = new Student("Ibsen","Skandinavien",789565);

    if (p instanceof Student){ 
      Student s = (Student)p;
      System.out.println(s.matrikelNummer);
    }
  }
}

class CastError {
  public static void main(String [] str){
    Person p = new Person("Strindberg","Skandinavien");
    Student s = (Student)p;
    System.out.println(s.matrikelNr);
  }
}

sep@swe10:~/fh> java CastError       
Exception in thread "main" java.lang.ClassCastException: Person
        at CastError.main(CastError.java:4)

public boolean equals(Object other){
  boolean erg = false;
  if (other instanceof Person){
     Person p = (Person) other;
     erg = this.name.equals(p.name) 
             && this.adresse.equals(p.adresse);
  }
  return erg;        
}

Chapter 5
Datentypen und Algorithmen

5.1  Listen

5.1.1  Formale Spezifikation

Konstruktoren

• einem Konstruktor für neue Listen, die noch leer sind.
• einem Konstruktor, der aus einem Element und einer bereits bestehenden Liste eine neue Liste konstruiert, indem an die Ursprungsliste das Element angehängt wird.

• Empty: () ®List
• Cons: (Object,List) ®List

Selektoren

• head: (List)®Object
• tail: (List)®List

Testmethoden

• isEmpty: List®boolean

Listenalgorithmen

Beispiel:
Wir errechnen in diesem Beispiel die Länge einer Liste, indem wir die obigen Gleichungen zum Reduzieren auf die Liste anwenden:

Schachtel- und Zeiger-Darstellung

5.1.2  Modellierung

Modellierung als Klassenhierarchie

In einer Klasse

5.1.3  Codierung

Implementierung als Klassenhierarchie

class List {
 boolean isEmpty(){return false;}
 Object head(){return null;}
 List tail(){return null;}

class Empty extends List {
  Empty(){}
  boolean isEmpty(){return true;}
}

class Cons extends List{

  Object hd;
  List tl ;

  Cons(Object x,List xs){
    hd = x;
    tl = xs;
  }

  Object head(){
    return hd;
  }

  List tail(){
    return tl;
  }

class TestFirstList {
  public static void main(String [] args){

    //Konstruktion einer Testliste
    List xs = new Cons("friends",
              new Cons("romans", 
              new Cons("countrymen",
              new Empty())));

    //Zugriffe auf einzelne Elemente
    System.out.println("1. Element: "+xs.head());
    System.out.println("2. Element: "+xs.tail().head());
    System.out.println("3. Element: "+xs.tail().tail().head());
    
    //Test für die Methode isEmpty()
    if (xs.tail().tail().tail().isEmpty()){
      System.out.println("leere Liste nach drittem Element.");
    }

    //Ausgabe eines null Wertes
    System.out.println(xs.tail().tail().tail().head());
  } 
}

sep@linux:~/fh/prog1/examples/classes> java TestFirstList
1. Element: friends
2. Element: romans
3. Element: countrymen
leere Liste nach drittem Element.
null
sep@linux:~/fh/prog1/examples/classes>

Implementierung als eine Klasse

class Li {
  boolean empty = true;
  Object  hd;
  Li      tl;
 
  Li (){}

  Li (Object x,Li xs){
   hd = x;
   tl = xs;
   empty = false;
  }

  boolean isEmpty() {return empty;}  
  Object  head(){return hd;}
  Li      tail(){return tl;}

class TestFirstLi {
  public static void main(String [] args){

    //Konstruktion einer Testliste
    Li xs = new Li("friends",
            new Li("romans", 
            new Li("countrymen",
            new Li())));

    //Zugriffe auf einzelne Elemente
    System.out.println("1. Element: "+xs.head());
    System.out.println("2. Element: "+xs.tail().head());
    System.out.println("3. Element: "+xs.tail().tail().head());
    
    //Test für die Methode isEmpty()
    if (xs.tail().tail().tail().isEmpty()){
      System.out.println("leere Liste nach drittem Element.");
    }

    //Ausgabe eines null Wertes
    System.out.println(xs.tail().tail().tail().head());
  }
 
}

sep@linux:~/fh/prog1/examples/classes> java TestFirstLi
1. Element: friends
2. Element: romans
3. Element: countrymen
leere Liste nach drittem Element.
null
sep@linux:~/fh/prog1/examples/classes>

5.1.4  Methoden für Listen

Länge

  int length(){
    if (isEmpty())return 0;
    return 1+tail().length();
  }

class TestLength {
  static  Li XS = new Li("friends",new Li("romans", 
                  new Li("countrymen",new Li())));

  public static void main(String [] args){
    System.out.println(XS.length());
  }
}

sep@linux:~/fh/prog1/examples/classes> java TestLength
3
sep@linux:~/fh/prog1/examples/classes>

  int length(){return 0;} 
}

  int length(){return 1+tail().length();}
}

class TestListLength {
  static  List XS = new Cons("friends",new Cons("romans", 
                    new Cons("countrymen",new Empty())));

  public static void main(String [] args){
    System.out.println(XS.length());
  }
}

  int lengthWhile(){
    int erg=0;
    Li xs = this;
    while (!xs.isEmpty()){
      erg= erg +1;
      xs = xs.tail();
    }
    return erg;
  }

• die Initialisierung einer Laufvariablen: List xs = this;
• eine bool'sche Bedingung zur Schleifensteuerung: !xs.isEmpty()
• eine Weiterschaltung der Schleifenvariablen: xs = xs.tail();

  int lengthFor(){
    int erg=0;
    for (Li xs=this;!xs.isEmpty();xs=xs.tail()){
      erg = erg +1;
    }
    return erg;
  }

toString

  public String toString(){
    return "("+toStringAux()+")";
  }

  private String toStringAux(){
    if (isEmpty()) return "";
    else if (tail().isEmpty()) return head().toString();
    else return head().toString()+","+tail().toStringAux();
  }

{\bf \alph{unteraufgabe})} Object last(): gibt das letzte Element der Liste aus.
{\bf \alph{unteraufgabe})} List concat(List other) bzw.: Li concat(Li other): erzeugt eine neue Liste, die erst die Elemente der this-Liste und dann der other-Liste hat, es sollen also zwei Listen aneinander gehängt werden.
{\bf \alph{unteraufgabe})} Object elementAt(int i): gibt das Element an einer bestimmten Indexstelle der Liste zurück. Spezifikation:



elementAt(Cons(x,xs),1) = x elementAt(Cons(x,xs),n+1) = elementAt(xs,n)

5.1.5  Sortierung

class StringOrdering{
  static boolean lessEqual(String x,String y){
    return x.compareTo(y)<=0;
  }
}

Sortieren durch Einfügen

class SortStringLi extends Li { 

  SortStringLi(){super();}
  SortStringLi(String x,SortStringLi xs){super(x,xs);}

  SortStringLi sortTail(){return (SortStringLi)tail();}

  SortStringLi insertSorted(String x){

    if (isEmpty()) {return new SortStringLi(x,this);}

    else if (StringOrdering.lessEqual((String)head(),x)){
      return new SortStringLi
                  ((String)head()
                  ,((SortStringLi)tail()).insertSorted(x));

    } else return new SortStringLi(x,this);
  }//method insertSorted

  SortStringLi getSorted(){
    SortStringLi result = new SortStringLi();

    for (Li xs= this;!xs.isEmpty();xs = xs.tail()){
      result = result.insertSorted((String)xs.head());
    }

    return result;
  }//method sort

  public static void main(String [] args){
    SortStringLi xs
      = new SortStringLi("zz"
       ,new SortStringLi("ab"
       ,new SortStringLi("aaa"
       ,new SortStringLi("aaa"
       ,new SortStringLi("aaz"
       ,new SortStringLi("aya"
       ,new SortStringLi()))))));


    System.out.println("Die unsortierte Liste:");
    System.out.println(xs);

    Li ys = xs.getSorted();
    System.out.println("Die sortierte Liste:");
    System.out.println(ys);
  }
}//class SortStringLi

sep@swe10:~/fh/prog1/Listen> java SortStringLi
Die unsortierte Liste:
(zz,ab,aaa,aaa,aaz,aya)
Die sortierte Liste:
(aaa,aaa,aaz,ab,aya,zz)
sep@swe10:~/fh/prog1/Listen>

Quick Sort

class FilterCondition {
  boolean condition(Object testMe){
    return true;
  }
}

Li filter(Condition cond);

  Li filter(FilterCondition cond){
    Li result = new Li();

    //test all elements of this list
    for (Li xs=this;!xs.isEmpty();xs=xs.tail()){

      //in case that the condition is true for the element
      if (cond.condition(xs.head())) {
        //then add it to the result
        result = new Li(xs.head(),result);
      }
    }
    return result;
  }

Beispiel:
Bevor wir die Methode quicksort implementieren, wollen wir ein paar Tests für unsere Methode filter schreiben. Hierzu schreiben wir Klassen für die Bedingungen, nach denen wir Elemente aus einer Liste filtern wollen:

class LongString extends FilterCondition{
  boolean condition(Object testMe){
    return ((String)testMe).length()>10;
  }
}

class StringStartsWithA extends FilterCondition{
  boolean condition(Object testMe){
    return ((String)testMe).charAt(0)=='A';
  }
}

class ContainsNoA extends FilterCondition{
  boolean condition(Object testMe){
    for (int i= 0;i<((String)testMe).length();i=i+1){
      final char c = ((String)testMe).charAt(i);

      if (c=='A' || c=='a') return false;
    }
    return true;
  }
}

class TestFilter {

  static
     Li XS = new Li("Shakespeare",
             new Li("Brecht",
             new Li("Achternbusch",
             new Li("Calderon",
             new Li("Moliere",
             new Li("Sorokin",
             new Li("Schimmelpfennig",
             new Li("Kane",
             new Li("Wilde",
             new Li())))))))));

  public static void main(String [] _){
     System.out.println(XS);
     System.out.println(XS.filter(new ContainsNoA()));
     System.out.println(XS.filter(new StringStartsWithA()));
     System.out.println(XS.filter(new LongString()));
  }
}

sep@linux:~/fh/prog1/examples/classes> java TestFilter
(Shakespeare,Brecht,Achternbusch,Calderon,Moliere,Sorokin,Schimmelpfennig,Kane,Wilde)
(Wilde,Schimmelpfennig,Sorokin,Moliere,Brecht)
(Achternbusch)
(Schimmelpfennig,Achternbusch,Shakespeare)
sep@linux:~/fh/prog1/examples/classes>

class LessEqualX extends FilterCondition{
  Comparable x;

  LessEqualX(Comparable x){
    this.x=x;
  }
    
  boolean condition(Object testMe){
    return x.compareTo(testMe)>0;
  }
}

class GreaterX extends FilterCondition {
  Comparable x;

  GreaterX(Comparable x){
    this.x=x;
  }
    
  boolean condition(Object testMe){
    return x.compareTo(testMe)<=0;
  }
}

  Li quicksort(){
    Li result = new Li();
    if (!isEmpty()){ 
      result 
       =   //filter the smaller elements out of the tail
           tail().filter(new LessEqualX((String)head()))
            //sort these
            .quicksort()
            //concatenate it with the sorted 
            //sublist of greater elements
            .append(new Li(head()
                   ,tail().filter(new GreaterX((String)head()))
                    .quicksort()
              ));
    }
    return result;
  }

Li sortBy(Relation rel)

class Relation {
  boolean lessEqual(Object x,Object y){
    return true;
  }
}

class StringLessEqual extends Relation {
  boolean lessEqual(Object x,Object y){
    return ((String)x).compareTo((String)y)<=0;
  }
}

class OrderingCondition extends FilterCondition{
  Object x;
  Relation rel;

  OrderingCondition(Object x,Relation rel){
    this.x=x;
    this.rel = rel;
  }
    
  boolean condition(Object y){
    return rel.lessEqual(y,x);
  }
}

class NegativeOrderingCondition extends FilterCondition{
  Object x;
  Relation rel;

  NegativeOrderingCondition(Object x,Relation rel){
    this.x=x;
    this.rel = rel;
  }
    
  boolean condition(Object y){
    return !rel.lessEqual(y,x);
  }
}

  Li sortBy(Relation rel){
    Li result = new Li();
    if (!isEmpty()){ 
      FilterCondition le
       = new OrderingCondition(head(),rel);
      FilterCondition gr
       = new NegativeOrderingCondition(head(),rel);
      result = tail()
                .filter(le)
                .sortBy(rel)
                .append(new Li(head()
                              ,tail()
                                 .filter(gr)
                                 .sortBy(rel)));
    }
    return result;
  }
}

Beispiel:
Im folgenden Beispiel werden Strings einmal nach ihrer lexikographischen Ordnung, einmal nach ihrer Länge sortiert:

class StringLengthLessEqual extends Relation {
  boolean lessEqual(Object x,Object y){
    return ((String)x).length()<= ((String)y).length();
  }
}

class TestSortBy{
  public static void main(String [] args){
    Li xs = TestFilter.XS;

    System.out.println("Die unsortierte Liste:");
    System.out.println(xs);
    System.out.println("Die alphabetisch sortierte Liste:");
    System.out.println(xs.sortBy(new StringLessEqual()));
    System.out.println("Die nach der Länge sortierte Liste:");
    System.out.println(xs.sortBy(new StringLengthLessEqual()));
  }
}

sep@linux:~/fh/prog1/examples/classes> java TestSortBy
Die unsortierte Liste:
(Shakespeare,Brecht,Achternbusch,Calderon,Moliere,Sorokin,Schimmelpfennig,Kane,Wilde)
Die alphabetisch sortierte Liste:
(Achternbusch,Brecht,Calderon,Kane,Moliere,Schimmelpfennig,Shakespeare,Sorokin,Wilde)
Die nach der Länge sortierte Liste:
(Kane,Wilde,Brecht,Moliere,Sorokin,Calderon,Shakespeare,Achternbusch,Schimmelpfennig)
sep@linux:~/fh/prog1/examples/classes>

• ("a","b","c","d","e")
• ("c","a","b","d","e")

{\bf \alph{unteraufgabe})} Implementieren Sie für Ihre Listenklasse eine Methode String toHtmlTable(), die für Listen Html-Code für eine Tabelle erzeugt, z.B:

<table>
  <tr>erstes Listenelement</tr>
  <tr>zweites Listenelement</tr>
  <tr>drittes Listenelement</tr>
</table>


{\bf \alph{unteraufgabe})} Nehmen Sie die Klasse Student, die Felder für Namen, Vornamen und Matrikelnummer hat. Implementieren Sie für diese Klasse eine Methode String toTableRow(), die für Studenten eine Zeile einer Html-Tabelle erzeugt:

Student s1 = new Student("Müller","Hans",167857);
System.out.println(s1.toTableRow());

soll folgende Ausgabe ergeben:

<td>Müller</td><td>Hans</td><td>167857</td>

Ändern Sie die Methode toString so, daß sie dasselbe Ergebnis wie die neue Methode toTableRow hat.
{\bf \alph{unteraufgabe})} Legen Sie eine Liste von Studenten an, sortieren Sie diese mit Hilfe der Methode sortBynach Nachnamen und Vornamen und erzeugen Sie eine Html-Seite, die die sortierte Liste anzeigt.
Sie können zum Testen die folgende Klasse benutzen:

HtmlView

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.plaf.basic.*; 
import javax.swing.text.*; 
import javax.swing.text.html.*; 

public class HtmlView extends JPanel {

  //example invocation
  public static void main(String s[]) {
    HtmlView view = new HtmlView();
    view.run();
    view.setText("<h1>hallo</h1>");
  }

  JFrame frame;
  JTextPane ausgabe = new JTextPane();

  public HtmlView() {
    ausgabe.setEditorKit(new HTMLEditorKit());
    add(ausgabe);	
  }

  void setText(String htmlString){
    ausgabe.setText(htmlString);
    frame.pack();
    ausgabe.repaint();
  }

  void run(){
    frame = new JFrame("HtmlView");
    frame.getContentPane().add(this);
    frame.pack();
    frame.setVisible(true);
  }
}

Bubble Sort

5.1.6  Formale Beweise über Listenalgorithmen

Vollständige Induktion

Induktion über Listen

Beispiel:
Als Beispiel wollen wir eine Eigenschaft über Listen im Zusammenhang mit den Funktionen concat und length beweisen. Wir wollen beweisen, daß die Länge der Konkatenation zweier Listen gleich der Summe der Längen der beiden Listen ist, also daß für alle Listen xs und ys gilt:

Chapter 6
Weiterführende programmiersprachliche Konzepte

6.1  Pakete

6.1.1  Paketdeklaration

package testPackage;
class MyClass {
}

package de.tfhberlin.panitz.testPackages;
class TestPaket {
  public static void main(String [] args){
    System.out.println("hello from package \'testpackages\'");
  }
}

6.1.2  Übersetzen von Paketen

6.1.3  Starten von Klassen in Paketen

sep@swe10:~/> java de.tfhberlin.panitz.testPackages.Test
hello from package 'testpackages'
sep@swe10:~/>

6.1.4  Das Java Standardpaket

6.1.5  Benutzung von Klassen in anderen Paketen

package de.tfhberlin.panitz.utilTest;
class TestArrayList {
  public static void main(String [] args){
    java.util.ArrayList xs = new java.util.ArrayList();
    xs.add("friends");
    xs.add("romans");
    xs.add("countrymen");
    System.out.println(xs);
  }
}

6.1.6  Importieren von Paketen und Klassen

Importieren von Klassen

package de.tfhberlin.panitz.utilTest;

import java.util.ArrayList;

class TestImport {
  public static void main(String [] args){
    ArrayList xs = new ArrayList();
    xs.add("friends");
    xs.add("romans");
    xs.add("countrymen");
    System.out.println(xs);
  }
}

package de.tfhberlin.panitz.utilTest;

import java.util.ArrayList;
import java.util.Vector;

class TestImport2 {
  public static void main(String [] args){
    ArrayList xs = new ArrayList();
    xs.add("friends");
    xs.add("romans");
    xs.add("countrymen");
    System.out.println(xs);

    Vector ys = new Vector();
    ys.add("friends");
    ys.add("romans");
    ys.add("countrymen");
    System.out.println(ys);
  }
}

Importieren von Paketen

package de.tfhberlin.panitz.utilTest;

import java.util.*;

class TestImport3 {
  public static void main(String [] args){
    List xs = new ArrayList();
    xs.add("friends");
    System.out.println(xs);

    Vector ys = new Vector();
    ys.add("romans");
    System.out.println(ys);
  }
}

6.2  Sichtbarkeitsattribute

6.2.1  Sichtbarkeitsattribute für Klassen

package de.tfhberlin.panitz.p1;
public class MyPublicClass {
}

package de.tfhberlin.panitz.p1;
class MyNonPublicClass {
}

package de.tfhberlin.panitz.p2;

import de.tfhberlin.panitz.p1.*;

class UsePublic {
  public static void main(String [] args){
    System.out.println(new MyPublicClass());
  }
}

package de.tfhberlin.panitz.p2;

import de.tfhberlin.panitz.p1.*;

class UseNonPublic {
  public static void main(String [] args){
    System.out.println(new MyNonPublicClass());
  }
}

sep@swe10:~> javac -d . UseNonPublic.java
UseNonPublic.java:7: de.tfhberlin.panitz.p1.MyNonPublicClass is not
public in de.tfhberlin.pantitz.p1; 
cannot be accessed from outside package
        System.out.println(new MyNonPublicClass());
                               ^
UseNonPublic.java:7: MyNonPublicClass() is not 
public in de.tfhberlin.panitz.p1.MyNonPublicClass; 
cannot be accessed from outside package
        System.out.println(new MyNonPublicClass());
                           ^
2 errors
sep@swe10:~>

6.2.2  Sichtbarkeitsattribute für Eigenschaften

package de.tfhberlin.panitz.p1;

public class VisibilityOfFeatures{
  private   String s1 = "private";
            String s2 = "package";
  protected String s3 = "protected";
  public    String s4 = "private";

  public static void main(String [] args){
    VisibilityOfFeatures v = new VisibilityOfFeatures();
    System.out.println(v.s1);
    System.out.println(v.s2);
    System.out.println(v.s3);
    System.out.println(v.s4);
  }
}

package de.tfhberlin.panitz.p1;

public class PrivateTest 
{

  public static void main(String [] args){
    VisibilityOfFeatures v = new VisibilityOfFeatures();
    //s1 is private and cannot be accessed; 
    //we are in a  different class.
    //System.out.println(v.s1);
    System.out.println(v.s2);
    System.out.println(v.s3);
    System.out.println(v.s4);
  }
}

package de.tfhberlin.panitz.p2;
import de.tfhberlin.panitz.p1.VisibilityOfFeatures;

public class  PackageTest extends VisibilityOfFeatures{

  public static void main(String [] args){
    PackageTest v = new PackageTest();
    //s1 is private and cannot be accessed
    // System.out.println(v.s1);

    //s2 is package visible and cannot be accessed;
    //we are in a different package.
    //System.out.println(v.s2);

    System.out.println(v.s3);
    System.out.println(v.s4);
  }
}

package de.tfhberlin.panitz.p2;
import de.tfhberlin.panitz.p1.VisibilityOfFeatures;

public class ProtectedTest  {

  public static void main(String [] args){
    VisibilityOfFeatures v = new VisibilityOfFeatures();
    //s1 is private and cannot be accessed
    // System.out.println(v.s1);
    
    //s2 is package visible and cannot be accessed. We are
    //in a different package
    //System.out.println(v.s2);

    //s2 is protected and cannot be accessed. 
    //We are not a subclass
    //System.out.println(v.s3);

    System.out.println(v.s4);
  }
}

6.2.3  Private Felder mit get- und set-Methoden

Beispiel:
Eine kleine Klasse mit Kapselung eines privaten Feldes:

package de.tfhberlin.sep.skript;

public class GetSetMethod {
  private int value=0;

  public void setValue(int newValue) {value=newValue;}
  public int  getvalue(){return value;} 
}

6.2.4  Überschriebene Methodensichtbarkeiten

class OverrideToString {
  String toString(){return "Objekt der Klasse OverrideToString";}
}

ep@linux:~/fh/prog1/examples/src> javac OverrideToString.java
OverrideToString.java:2: 
toString() in OverrideToString cannot override toString() in java.lang.Object; 
attempting to assign weaker access privileges; 
was public
  String toString(){return "Objekt der Klasse OverrideToString";}
         ^
1 error
sep@linux:~/fh/prog1/examples/src>

6.2.5  Unveränderbare Listen

class InmutableList {
  private boolean empty = true;
  private Object  hd;
  private InmutableList tl;
 
  public InmutableList(){}
  public InmutableList(Object x,InmutableList xs){
   hd = x;
   tl = xs;
   empty = false;
  }

  public boolean isEmpty() {return empty;}  
  public Object  head(){return hd;}
  public InmutableList tail(){return tl;}

  public int length(){
    if (isEmpty())return 0;
    return 1+tail().length();
  }

  public String toString(){
    return "("+toStringAux()+")";
  }
  private String toStringAux(){
    if (isEmpty()) return "";
    else if (tail().isEmpty()) return head().toString();
    else return head().toString()+","+tail().toStringAux();
  }

  public InmutableList append(InmutableList ys){
    if (isEmpty()) return ys;
    return new InmutableList(head(),tail().append(ys));
  }

  public InmutableList filter(FilterCondition cond){
    InmutableList result = new InmutableList();

    for (InmutableList xs=this;!xs.isEmpty();xs=xs.tail()){
      if (cond.condition(xs.head())) {
        result = new InmutableList(xs.head(),result);
      }
    }
    return result;
  }

  public InmutableList sortBy(Relation rel){
    if (!isEmpty()){ 
      final FilterCondition le
       = new OrderingCondition(head(),rel);
      final FilterCondition gr
       = new NegativeOrderingCondition(head(),rel);
      final InmutableList smaller = tail().filter(le).sortBy(rel);
      final InmutableList greater = tail().filter(gr).sortBy(rel);
      return smaller.append(new InmutableList(head(),greater));
    }
    return new InmutableList();
  }
}

6.3  Schnittstellen (Interfaces) und abstrakte Klassen

6.3.1  Schnittstellen

Schnittstellendeklaration

• statt des Schlüsselworts class steht das Schlüsselwort interface.
• die Methoden haben keine Rümpfe, sondern nur eine Signatur.

package de.tfhberlin.panitz.dialoguegui;

public interface DialogueLogic {
  public String getDescription();
  public String eval(String input);
}

Implementierung von Schnittstellen

package de.tfhberlin.panitz.dialoguegui;

public class ToUpperCase implements DialogueLogic{
  protected String result;

  public String getDescription(){
    return "convert into upper cases";
  }
  public String eval(String input){
    result = input.toUpperCase();
    return result;
  }
}

package de.tfhberlin.panitz.html;

public interface ToHTMLString {
  public String toHTMLString();
}

package de.tfhberlin.panitz.dialoguegui;

import de.tfhberlin.panitz.html.*;

public class ToUpper extends    ToUpperCase 
                     implements ToHTMLString, DialogueLogic {

  public String toHTMLString(){
     return   "<html><head><title>"+getDescription()
            + "</title></head>"
            + "<body><b>Small Gui application</b>"
            + " for convertion of "
            + " a <b>String</b> into <em>upper</em>"
            + " case letters.<br></br>"
            + "The result of your query was: <p>"
            + "<span style=\"font-family: monospace;\">"
            + result
            + "</span></p></body></html>";
  }
}

package de.tfhberlin.panitz.dialoguegui;

import de.tfhberlin.panitz.html.*;

public interface DialogueLogics 
        extends ToHTMLString, DialogueLogic {}

package de.tfhberlin.panitz.dialoguegui;

class UpperConversion extends ToUpper
                      implements DialogueLogics{}

Benutzung von Schnittstellen

• primitive Typen
• Klassen
• Schnittstellen

package de.tfhberlin.panitz.dialoguegui;
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.plaf.basic.*; 
import javax.swing.text.*; 
import javax.swing.text.html.*; 

public class HtmlDialogue extends JFrame{
  final DialogueLogics logic; 
  final JButton button;
  final JTextField inputField = new JTextField(20) ;
  final JTextPane outputField = new JTextPane();
  final JPanel p = new JPanel();

  public HtmlDialogue(DialogueLogics l){
    outputField.setEditorKit(new HTMLEditorKit());
    logic = l;
    button=new JButton(logic.getDescription());
    button.addActionListener
     (new ActionListener(){
        public void actionPerformed(ActionEvent _){
          logic.eval(inputField.getText().trim());
          outputField.setText(logic.toHTMLString());
          pack();
        }
      });

    p.setLayout(new BorderLayout());
    p.add(inputField,BorderLayout.NORTH);
    p.add(button,BorderLayout.CENTER);
    p.add(outputField,BorderLayout.SOUTH);
    getContentPane().add(p);
    pack();
    setVisible(true);
  }
}

package de.tfhberlin.panitz.dialoguegui;
public class HtmlDialogueTest {
  public static void main(String [] args){
    new HtmlDialogue(new UpperConversion());
  }
}

Semantische Einschränkungen für Schnittstellen

• Schnittstellen können nur Schnittstellen, nicht aber Klassen erweitern.
• Jede Methode einer Schnittstelle muß öffentlich sein, braucht also das Attribut public. Wenn dieses für eine Methode nicht deklariert ist, so wird Java dieses von selbst hinzufügen. Trotzdem müssen implementierende Klassen diese Methode dann als öffentlich deklarieren. Daher ist es besser, das Attribut public auch hinzuschreiben.
• Es gibt keine statischen Methoden in Schnittstellen.
• Jede Methode ist abstrakt, d.h. hat keinen Rumpf. Man kann dieses noch zusätzlich deutlich machen, indem man das Attribut abstract für die Methode mit angibt.
• Felder einer Schnittstelle sind immer statisch, brauchen also das Attribut static und zusätzlich noch das Attribut final.

Iteratorschnittstellen

• einer Methode next, die jeweils das nächste Element der Iteration zurückgibt.
• einer Methode hasNext, die in einem bool'schen Rückgabewert angibt, ob es weitere Elemente gibt, die über next erfragt werden könnten.

package de.tfhberlin.panitz.iterator;
public interface IntIterator{
  public int next();
  public boolean hasNext();
}

package de.tfhberlin.panitz.iterator;
public class PrintIntIteratorElements{ 
  static void print(IntIterator it){
    while (it.hasNext()) System.out.print(it.next()+" ");
  }
}

package de.tfhberlin.panitz.iterator;
public class FromToStep implements IntIterator{
  private int from; 
  private int to; 
  private int step; 

  public FromToStep(int from,int to,int step){
    this.from=from;this.to=to;this.step=step;}

  public boolean hasNext(){return from<=to;}
  public int next(){
    int result = from;
    from=from+step;
    return result;
  }
}

package de.tfhberlin.panitz.iterator;
public class FromTo extends FromToStep{
  public FromTo(int from,int to){super(from,to,1);}
}

package de.tfhberlin.panitz.iterator;
public class TestFromTo {
  public static void main(String []_){
    PrintIntIteratorElements.print(new FromTo(17,42));
  }
}

sep@linux:~/fh/prog1/examples/src> java de.tfhberlin.panitz.iterator.TestFromTo
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 
sep@linux:~/fh/prog1/examples/src>

{\bf \alph{unteraufgabe})} Schreiben sie eine Unterklasse From der Klasse FromTo, die von einem Startwert an in Einerschritten ganze Zahlen zurückgibt und für die hasNext immer wahr ist.
{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse Sieb, die die Schnittstelle IntIterator implementiert. Die Klasse soll zwei Felder haben: eine ganze Zahl und ein weiteres Objekt, das die Schnittstelle IntIterator implementiert. Der Konstruktor habe die Signatur:
public Sieb(int i,IntIterator it)
Die Methode next soll das nächste Element des inneren Iterators it zurückgeben, das nicht durch die Zahl i teilbar ist.
Beispiel: PrintIntIteratorElements.print(new Sieb(3,new From(1))) gibt alle nicht durch 3 teilbaren natürlichen Zahlen auf dem Bildschirm aus.
{\bf \alph{unteraufgabe})} Übersetzen Sie ihren Code mit folgender Klasse:
package de.tfhberlin.panitz.iterator;
class PrimIterator implements IntIterator{
  private IntIterator sieb = new From(2);
  public boolean hasNext(){return sieb.hasNext();}
  public int next(){
    int result = sieb.next();
    sieb= new Sieb(result,sieb);
    return result;
  }
}
Lassen Sie sich alle Werte von PrimIterator mit der Methode PrintIntIteratorElements.print ausgeben.

6.3.2  Abstrakte Klassen

Definition abstrakter Klassen

package de.tfhberlin.sep.abstractList;
abstract class AbstractList  {
  abstract public boolean isEmpty();

  abstract public Object head();
  abstract public AbstractList tail();

  abstract public AbstractList empty();
  abstract public AbstractList cons(Object x,AbstractList xs);
    
  public int length(){
    if (isEmpty()) return 0;
    return 1+tail().length();
  }

  public AbstractList concat(AbstractList other){
    if (isEmpty()) return this;
    return cons(head(),tail().concat(other));
  }
}

Implementierende Unterklassen abstrakter Klassen

package de.tfhberlin.sep.abstractList;
public class LinkedList extends AbstractList {

  private Object hd=null;
  private AbstractList tl=null;
  private boolean empty;

  public LinkedList(){empty=true;}
  public LinkedList(Object x,AbstractList xs){
    hd=x;tl=xs;empty=false;
  }

  public boolean isEmpty(){return empty;}

  public Object head(){return hd;}
  public AbstractList tail(){return tl;}

  public AbstractList empty(){return new LinkedList();}
  public AbstractList cons(Object x,AbstractList xs){
     return new LinkedList(x,xs);
   }

}

Abstrakte Klassen und Schnittstellen

package de.tfhberlin.sep.listen;
public interface List  {
  boolean isEmpty();

  Object head();
  AbstractList tail();
    
  public int length();
  public AbstractList concat(AbstractList other);
}

package de.tfhberlin.sep.listen;
public abstract class AbstractList  implements List{

  abstract public AbstractList empty();
  abstract public AbstractList cons(Object x,AbstractList xs);
    
  public int length(){
    if (isEmpty()) return 0;
    return 1+tail().length();
  }

  public AbstractList concat(AbstractList other){
    if (isEmpty()) return this;
    return cons(head(),tail().concat(other));
  }
}

{\bf \alph{unteraufgabe})} Laden Sie sich hierzu das Archiv
Eliza.zip (http://www.tfh-berlin.de/~panitz/prog1/load/Eliza.zip)
vom Netz. Entpacken Sie es. Machen Sie sich mit den einzelnen Klassen vertraut.
{\bf \alph{unteraufgabe})} In der Klasse MyList sind nicht alle abstrakten Methoden der Klasse Li implementiert. Ergänzen Sie MyList um die Methoden:
reverse, words, unwords, drop, tails, isPrefixIgnoreCaseOf. Implementieren Sie diese Methoden entsprechend ihrer Dokumentation in der abstrakten Klasse Li und schreiben Sie Tests für jede Methode.
Wenn Ihre Tests erfolgreich sind, übersetzen Sie alle Klassen und starten Sie die main-Methode der Klasse Main.
{\bf \alph{unteraufgabe})} Erfinden Sie eigene Einträge für die Liste respMsgs in der Klasse Data.
{\bf \alph{unteraufgabe})} Erklären Sie, was die Methode rotate von den anderen Methoden der Klasse Li fundamental unterscheidet. Demonstrieren Sie dieses anhand eines Tests.

6.4  Ausnahme- und Fehlerbehandlung

6.4.1  Ausnahme- und Fehlerklassen

• java.lang.Error: alle Objekte dieser Klasse drücken aus, daß ein ernsthafter Fehlerfall aufgetreten ist, der in der Regel von dem Programm selbst nicht zu beheben ist.
• java.lang.Exception: alle Objekte dieser Klasse stellen Ausnahmesituationen dar. Im Programm kann eventuell beschrieben sein, wie bei einer solchen Ausnahmesituation weiter zu verfahren ist. Eine Unterklasse von Exception ist die Klasse java.lang.RuntimeException.

6.4.2  Werfen von Ausnahmen

package de.tfhberlin.panitz.exceptions;
public class FirstThrow {

  public static int fakultät(int n){
    if (n==0) return 1;
    if (n<0) throw new RuntimeException();
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    System.out.println(fakultät(5));
    System.out.println(fakultät(-3));
    System.out.println(fakultät(4));
  }
}

swe10:~> java de.tfhberlin.panitz.exceptions.FirstThrow
120
Exception in thread "main" java.lang.RuntimeException
  at de.tfhberlin.panitz.exceptions.FirstThrow.fakultät(FirstThrow.java:6)
  at de.tfhberlin.panitz.exceptions.FirstThrow.main(FirstThrow.java:12)
swe10:~>

package de.tfhberlin.panitz.exceptions;
public class NonThrow {

  public static int fakultät(int n){
    if (n==0) return 1;
    if (n<0) new RuntimeException();
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    System.out.println(fakultät(5));
    System.out.println(fakultät(-3));
    System.out.println(fakultät(4));
  }
}

swe10:~> java de.tfhberlin.panitz.exceptions.NonThrow
120

An irrecoverable stack overflow has occurred.

package de.tfhberlin.panitz.exceptions;
public class NotThrowable {

  public static void main(String [] args){
      throw "i am not throwable";
  }
}

swe10:~> javac -d . NotThrowable.java
NotThrowable.java:5: incompatible types
found   : java.lang.String
required: java.lang.Throwable
      throw "i am not throwable";
            ^
1 error
swe10:~>

package de.tfhberlin.panitz.exceptions;
public class ThrowIndex {

  public static void main(String [] args){
      "i am too short".charAt(120);
  }
}

swe10:~> java de.tfhberlin.panitz.exceptions.ThrowIndex
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: 
                                    String index out of range: 120
  at java.lang.String.charAt(String.java:516)
  at de.tfhberlin.panitz.exceptions.ThrowIndex.main(ThrowIndex.java:5)
swe10:~>

package de.tfhberlin.panitz.exceptions;

public class SecondThrow {
  public static int fakultät(int n){
    if (n==0) return 1;
    if (n<0) 
     throw
      new RuntimeException
           ("negative Zahl für Fakultätsberechnung");
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    System.out.println(fakultät(5));
    System.out.println(fakultät(-3));
    System.out.println(fakultät(4));
  }
}

swe10:~> java de.tfhberlin.panitz.exceptions.SecondThrow
120
Exception in thread "main" java.lang.RuntimeException: 
                                    negative Zahl für Fakultätsberechnung
  at de.tfhberlin.panitz.exceptions.SecondThrow.fakultät(SecondThrow.java:6)
  at de.tfhberlin.panitz.exceptions.SecondThrow.main(SecondThrow.java:12)
swe10:~>

6.4.3  Deklaration von geworfenen Ausnahmen

package de.tfhberlin.panitz.exceptions;
public class ThirdThrow {

  public static int fakultät(int n){
    if (n==0) return 1;
    if (n<0) throw new Exception
             ("negative Zahl für Fakultätsberechnung");
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    System.out.println(fakultät(5));
    System.out.println(fakultät(-3));
    System.out.println(fakultät(4));
  }
}

swe10:~> javac -d . ThirdThrow.java
ThirdThrow.java:6: unreported exception java.lang.Exception; 
                                      must be caught or declared to be thrown
    if (n<0) throw new Exception("negative Zahl für Fakultätsberechnung");
             ^
1 error

package de.tfhberlin.panitz.exceptions;
public class FourthThrow {

  public static int fakultät(int n) throws Exception{
    if (n==0) return 1;
    if (n<0) 
     throw 
      new Exception("negative Zahl für Fakultätsberechnung");
    return n*fakultät(n-1);
  }

  public static void main(String [] args) throws Exception{
    System.out.println(fakultät(5));
    System.out.println(fakultät(-3));
    System.out.println(fakultät(4));
  }
}

6.4.4  Eigene Ausnahmeklassen

package de.tfhberlin.panitz.exceptions;
public class NegativeNumberException extends Exception {
}

package de.tfhberlin.panitz.exceptions;
public class FifthThrow {

  public static int fakultät(int n) throws Exception{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    return n*fakultät(n-1);
  }

  public static void main(String [] args) throws Exception{
    System.out.println(fakultät(5));
    System.out.println(fakultät(-3));
    System.out.println(fakultät(4));
  }
}

sep@swe10:~/fh/beispiele> java de.tfhberlin.panitz.exceptions.FifthThrow
120
Exception in thread "main" de.tfhberlin.panitz.exceptions.NegativeNumberException
        at de.tfhberlin.panitz.exceptions.FifthThrow.fakultät(FifthThrow.java:6)
        at de.tfhberlin.panitz.exceptions.FifthThrow.main(FifthThrow.java:12)
sep@swe10:~/fh/beispiele>

6.4.5  Fangen von Ausnahmen

Syntax

package de.tfhberlin.panitz.exceptions;
public class Catch1 {

  public static int fakultät(int n) throws Exception{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    try {
      System.out.println(fakultät(5));
      System.out.println(fakultät(-3));
      System.out.println(fakultät(4));
    }catch (Exception e){
      System.out.println("Ausnahme aufgetreten: "+e);
    }
  }
}

swe10:~> java de.tfhberlin.panitz.exceptions.Catch1
120
Ausnahme aufgetreten: de.tfhberlin.panitz.exceptions.NegativeNumberException
swe10:~>

Granularität des Abfangens

package de.tfhberlin.panitz.exceptions;
public class Catch2 {

  public static int fakultät(int n) throws Exception{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    try {
      System.out.println(fakultät(5));
    }catch (Exception _){
      System.out.println("Ausnahme für Fakultät von 5");
    } 
    try {
      System.out.println(fakultät(-3));
    }catch (Exception _){
      System.out.println("Ausnahme für Fakultät von -3");
    } 
    try {
      System.out.println(fakultät(4));
    }catch (Exception _){
      System.out.println("Ausnahme für Fakultät von 4");
    } 
  }
}

swe10:~/fh/beispiele> java de.tfhberlin.panitz.exceptions.Catch2
120
Ausnahme für Fakultät von -3
24
swe10:~/fh/beispiele>

Abfangen spezifischer Ausnahmen

package de.tfhberlin.panitz.exceptions;
public class Catch3 {

  public static int fakultät(int n) 
                        throws NegativeNumberException{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    try {
      System.out.println(fakultät(5));
      System.out.println(fakultät(-3));
      System.out.println(fakultät(4));
    }catch (NegativeNumberException e){
      System.out.println("Ausnahme aufgetreten: "+e);
    } 
  }
}

Abfangen mehrerer Ausnahmen

package de.tfhberlin.panitz.exceptions;
public class NumberTooLargeException extends Exception {
}

package de.tfhberlin.panitz.exceptions;
public class Catch4 {

  public static int fakultät(int n) 
        throws NegativeNumberException, NumberTooLargeException{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    if (n>20) throw new NumberTooLargeException();
    return n*fakultät(n-1);
  }

  public static void printFakultät(int i){
    try {
      System.out.println(fakultät(i));
    }catch (NegativeNumberException _){
      System.out.println("Fakultät von negativer Zahl");
    } 
    catch (NumberTooLargeException _){
      System.out.println("Fakultät von zu großer Zahl");
    } 
  }

  public static void main(String [] args){
    printFakultät(30);
    printFakultät(-3);
    printFakultät(4);
  }
}

swe10:~/fh/beispiele> java de.tfhberlin.panitz.exceptions.Catch4
Fakultät von zu großer Zahl
Fakultät von negativer Zahl
24
swe10:~/fh/beispiele>

Zusammenspiel mit Rückgabewerten

package de.tfhberlin.panitz.exceptions;
public class WrongCatch {

  public static int fakultät(int n) 
        throws NegativeNumberException, NumberTooLargeException{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    if (n>20) throw new NumberTooLargeException();
    return n*fakultät(n-1);
  }

  public static int checkFakultät(int i){
    try {
      return fakultät(i);
    }catch (Exception e){
      System.out.println("Ausnahme "+e+" aufgetreten");
    } 
  }

  public static void main(String [] args){
    System.out.println(checkFakultät(30));
    System.out.println(checkFakultät(-3));
    System.out.println(checkFakultät(4));
  }
}

sep@swe10:~/fh/beispiele> javac -d . WrongCatch.java
WrongCatch.java:12: missing return statement
  public static int checkFakultät(int i){
                                        ^
1 error
sep@swe10:~/fh/beispiele>

package de.tfhberlin.panitz.exceptions;
public class Catch5 {

  public static int fakultät(int n) 
        throws NegativeNumberException, NumberTooLargeException{
    if (n==0) return 1;
    if (n<0) throw new NegativeNumberException();
    if (n>20) throw new NumberTooLargeException();
    return n*fakultät(n-1);
  }

  public static int checkFakultät(int i){
    try {
      return fakultät(i);
    }catch (Exception e){
      System.out.println("Ausnahme "+e+" aufgetreten");
      return 0;
    } 
  }

  public static void main(String [] args){
    System.out.println(checkFakultät(30));
    System.out.println(checkFakultät(-3));
    System.out.println(checkFakultät(4));
  }
}

[sep@swe10:~/fh/beispiele> java de.tfhberlin.panitz.exceptions.Catch5
Ausnahme de.tfhberlin.panitz.exceptions.NumberTooLargeException aufgetreten
0
Ausnahme de.tfhberlin.panitz.exceptions.NegativeNumberException aufgetreten
0
24
sep@swe10:~/fh/beispiele>

6.4.6  Der Aufrufkeller

package de.tfhberlin.panitz.exceptions;
public class StackTrace {

    public static int fakultät(int n) {
    if (n==0) {
	new Exception().printStackTrace();
      return 1;
    }
    return n*fakultät(n-1);
  }

  public static void main(String [] args){
    System.out.println(fakultät(4));
  }
}

sep@swe10:~/fh/beispiele> java de.tfhberlin.panitz.exceptions.StackTrace
java.lang.Exception
        at de.tfhberlin.panitz.exceptions.StackTrace.fakultät(StackTrace.java:6)
        at de.tfhberlin.panitz.exceptions.StackTrace.fakultät(StackTrace.java:9)
        at de.tfhberlin.panitz.exceptions.StackTrace.fakultät(StackTrace.java:9)
        at de.tfhberlin.panitz.exceptions.StackTrace.fakultät(StackTrace.java:9)
        at de.tfhberlin.panitz.exceptions.StackTrace.fakultät(StackTrace.java:9)
        at de.tfhberlin.panitz.exceptions.StackTrace.main(StackTrace.java:13)
24
sep@swe10:~/fh/beispiele>

6.4.7  Schließlich und finally

class Finally {
 
  static void m(int i) throws Exception{
    if (i>0) throw new Exception();
  }

  public static void main(String [] args){
    try {m(1);}
    catch (Exception _){System.out.println("Ausnahme gefangen");}
    finally {System.out.println("erster Test");}

    try {m(-1);}
    catch (Exception _){System.out.println("Ausnahme gefangen");}
    finally {System.out.println("zweiter Test");}
  }
}

class MoreFinally {

    static void m(int i){
	if (i<0) throw new NullPointerException();
    }

    public static void main(String [] args){
	try {m(-1);}
	catch (IndexOutOfBoundsException _){}
	finally 
	{System.out.println("wird trotzdem ausgegeben");}
   }

}

6.4.8  Anwendungslogik per Ausnahmen

  public int length(){
 
    try {
      return 1+tail().length();
    }catch (NullPointerException _){
      return 0;
    }
  }

Chapter 7
Java Standardklassen

• java.lang: das automatisch importierte Standardpaket. Hier finden sich die allerwichtigsten und permanent gebrauchten Klassen, wie z.B. String, System und vor allem auch Object. Auch die wichtigsten Ausnahmeklassen liegen in diesem Paket.
• java.util: hier befinden sich primär die Sammlungsklassen und Schnittstellen für die Sammlungsklassen. Desweiteren finden sich hier Klassen zum Umgang mit Kalenderdaten, Zeiten oder Währungen.
• java.io: Klassen für dateibasierte Ein-/Ausgabe-Operationen.
• java.applet: Klassen zum Schreiben von Applets.
• java.awt: Klassen für graphische Komponenten.
• javax.swing: weitere Klassen für graphische Komponenten. Neuere Implementierung zu java.awt, die versucht, noch generischer und plattformunabhängiger zu sein.

7.1  Die Klasse Objekt

7.1.1  Die Methoden der Klasse Object

equals

class EqualVsIdentical {

  public static void main(String [] args){
    String x = "hallo".toUpperCase();
    String y = "hallo".toUpperCase();

    System.out.println("x: "+x);
    System.out.println("y: "+y);

    System.out.println("x==x        -> "+(x==x));
    System.out.println("x==y        -> "+(x==y));
    System.out.println("x.equals(x) -> "+(x.equals(x)));
    System.out.println("x.equals(y) -> "+(x.equals(y)));
  }

}

sep@swe10:~/fh/beispiele> java EqualVsIdentical
x: HALLO
y: HALLO
x==x        -> true
x==y        ->false
x.equals(x) ->true
x.equals(y) ->true
sep@swe10:~/fh/beispiele>

• Reflexivität: es sollte immer gelten: x.equals(x)
• Symmetrie: wenn x.equals(y) dann auch y.equals(x)
• Transitivität: wenn x.equals(y) und y.equals(z) dann gilt auch x.equals(z)
• Konsistenz: wiederholte Aufrufe von equals auf dieselben Objekte liefern dasselbe Ergebnis, sofern die Objekte nicht verändert wurden.
• nichts gleicht null: x.equals(null) ist immer falsch.

hashCode

• wenn x.equals(y) dann folgt x.hashCode()==y.hashCode()
• bleibt ein Objekt unverändert, so ändert sich auch nicht sein Hashcode

clone

• x.clone() != x
• x.clone().equals(x)

class NoClone {
  String x = "hallo";
  public static void main(String [] args)
    throws CloneNotSupportedException{
    NoClone nc = new NoClone();
    NoClone cc = (NoClone)nc.clone();
    System.out.println(cc.x);
  }
}

sep@swe10:~/fh/beispiele> java NoClone
Exception in thread "main" java.lang.CloneNotSupportedException: NoClone
        at java.lang.Object.clone(Native Method)
        at NoClone.main(NoClone.java:5)
sep@swe10:~/fh/beispiele>

class Clone implements Cloneable {
  String x = "hallo";

  public static void main(String [] args) 
      throws CloneNotSupportedException{
    Clone nc = new Clone();
    Clone cc = (Clone)nc.clone();
    System.out.println(cc.x);
  }
}

sep@swe10:~/fh/beispiele> java Clone
hallo
sep@swe10:~/fh/beispiele>

finalize

Beispiel:
Wir können einmal testen, wie Java die Objekte willkürlich aus dem Speicher löscht. Hierzu schreiben wir eine Klasse, die in der Methode finalize eine Aufgabe über das Objekt auf der Kommandozeile ausgibt.

class Finalize {
   int i;
   Finalize(int i){this.i=i;}
   protected void finalize(){
     System.out.print(i+",");
   }

   public static void main(String [] _){
     for (int i=0;i<100000;i=i+1){
       new Finalize(i);
       System.out.print("*");
     }
   }
}

toString

weitere Methoden

7.2  Behälterklassen für primitive Typen

7.3  String und Stringbuffer

class StringVsStringBuffer {

  public static void main(String [] args){
    String a = "hello";
    String b = a+" world";
    System.out.println(a);

    StringBuffer ab = new StringBuffer("hello");
    StringBuffer bb = ab.append(" world");
    System.out.println(ab);
  }
}

class ReturnString {

  static public String toRoman(int i){
    StringBuffer result = new StringBuffer();
    while (i>=1000) {i=i-1000;result.append("M");}
    while (i>=900)  {i=i-900 ;result.append("CM");}
    while (i>=500)  {i=i-500 ;result.append("D");}
    while (i>=400)  {i=i-400 ;result.append("CD");}
    while (i>=100)  {i=i-100 ;result.append("C");}
    while (i>=90)   {i=i-90  ;result.append("XC");}
    while (i>=50)   {i=i-50  ;result.append("L");}
    while (i>=40)   {i=i-40  ;result.append("XL");}
    while (i>=10)   {i=i-10  ;result.append("X");}
    while (i>=9)    {i=i-9   ;result.append("IX");}
    while (i>=5)    {i=i-5   ;result.append("V");}
    while (i>=4)    {i=i-4   ;result.append("IV");}
    while (i>=1)    {i=i-1   ;result.append("I");}
    return result.toString();
  }
    
  public static void main(String [] args){
    System.out.println(toRoman(1999));
    System.out.println(toRoman(494));
  }

}

7.4  Sammlungsklassen

7.4.1  Listen

• add zum Hinzufügen von Elementen.
• clear zum Löschen aller Elemente.
• remove zum Löschen einzelner Elemente.

Listenklassen

import java.util.List;
import java.util.ArrayList;

class ListUsage{

  public static void main(String [] args){
    List xs = new ArrayList();
    xs.add("hallo");
    xs.add("welt");
    xs.add("wie");
    xs.add("geht");
    xs.add("es");
    xs.add("dir");
    System.out.println(xs);
  }

}

sep@swe10:~/fh/beispiele> java ListUsage
[hallo , welt , wie , geht , es , dir ]
sep@swe10:~/fh/beispiele>

7.4.2  Mengen

Aus !x.equals(y) folgt x.hashCode != y.hashCode()

7.4.3  Iteratoren

• Object next(), die den Iterator um ein Element weiterschaltet und das aktuelle Element als Ergebnis hat.
• boolean hasNext(), die true als Ergebnis hat, wenn die Methode next ein weiteres Element liefert.

Iterator für Li

public class LiIterator implements java.util.Iterator{

  public LiIterator(Li xs){this.xs=xs;}

  private Li xs;

  public boolean hasNext() {return !xs.isEmpty();}

  public Object next(){
    Object result = xs.head();
    xs = xs.tail();
    return result;
  }

  public void remove(){
   throw new UnsupportedOperationException ();
  }
}

  public java.util.Iterator iterator(){
    return new LiIterator(this);
  }

Benutzung von Iteratoren

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

class Iterate {

  static public String unwords(Collection cs){
    String result = "";

    for (Iterator it=cs.iterator();it.hasNext();){
      result = result+" "+it.next();
    }
    return result;
  }

  static public void main(String [] _){
    Collection cs = new ArrayList();
    cs.add("lebt");
    cs.add("wohl");
    cs.add("gott");
    cs.add("weiß");
    cs.add("wann");
    cs.add("wir");
    cs.add("uns");
    cs.add("wiedersehen");

    System.out.println(unwords(cs));
  }
}

    for (Iterator it=cs.iterator();it.hasNext();){
      result = result+" "+it.next();
      System.out.println(it.next())
    }

    for (Iterator it=cs.iterator();it.hasNext();){
      Object theNext = it.next();
      result = result+" "+theNext;
      System.out.println(theNext);
    }

7.4.4  Abbildungen

Abbildungen als Liste von Paaren

public class Paar{
  public Object fst;
  public Object snd;
  public Paar(Object f,Object s){fst=f;snd=s;}
}

class Abbildung extends Li{
  public Abbildung(Object schlüssel,Object wert,Abbildung xs){
      super(new Paar(schlüssel,wert),xs);
  }

  public Abbildung(){
  }

  Object lookup(Object schluessel){
    Object result = null;
    
    for (Abbildung xs = this 
        ;!this.isEmpty()
        ;xs=(Abbildung)xs.tail()){
      Paar p = (Paar)xs.head();
      if (p.fst.equals(schluessel)){
        return p.snd;
      }
    }
    return result;
  }

}

class Dictionary {
  static final Abbildung dic = 
     new Abbildung("Menge","set"
    ,new Abbildung("Abbildung","map"
    ,new Abbildung("Liste","list"
    ,new Abbildung("Iterator","iterator"
    ,new Abbildung("Schnittstelle","interface"
    ,new Abbildung("Klasse","class"
    ,new Abbildung()))))));

  static String english(String deutsch){
    return (String)dic.lookup(deutsch);
  }

  public static void main(String [] _){
    System.out.println(english("Schnittstelle"));    
    System.out.println(english("Abbildung"));    
  }
}

Standardklasse für Abbildungen

• void put(Object key, Object value): ein neues Schlüssel-/Wertpaar wird der Abbildung hinzugefügt.
• Object get(Object key): für einen bestimmten Schlüssel wird ein bestimmter Wert nachgeschlagen. Gibt es für diesen Schlüssel keinen Eintrag in der Abbildung, so ist das Ergebnis dieser Methode null.

import java.util.*;

class Dic{
  
  static Map map = new HashMap();

  static {
    map.put("Menge","set");
    map.put("Abbildung","map");
    map.put("Liste","list");
    map.put("Iterator","iterator");
    map.put("Schnittstelle","interface");
    map.put("Klasse","class");
  }

  static String english(String deutsch){
   return (String)map.get(deutsch);
  }

  public static void main(String [] _){
    System.out.println(english("Schnittstelle"));    
    System.out.println(english("Abbildung"));    
  }

}

7.4.5  Weitere Sammlungsmethoden

7.4.6  Vergleiche

import java.util.Comparator;
class ReverseComparator implements Comparator {

  public int compare(Object o1, Object o2) {
    return reverse((String) o1).compareTo(reverse((String) o2));
  }

  static private String reverse(String str){
    StringBuffer result = new StringBuffer();
    for (int i=str.length()-1;i>=0;i=i-1){
      result.append(str.charAt(i));
    }
    return result.toString();
  }

}

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;

class Rhyme {
  public static List/*String*/ rhyme(List/*String*/ xs){
    Collections.sort(xs,new ReverseComparator());
    return xs;
  }

  public static void main(String [] args){
      List xs = new ArrayList();
      xs.add("maus");
      xs.add("rasieren");
      xs.add("bauhaus");
      xs.add("verlieren");
      xs.add("regen");
      xs.add("laus");
      xs.add("segen");
      xs.add("kapitulieren");
      xs.add("monieren");
      xs.add("existieren");
      xs.add("kraus");
      rhyme(xs);
      System.out.println(xs);
  }

}

7.5  Reihungen

7.5.1  Deklaration von Reihungen

class ObjectArray {
  public static void main(String [] args){
    Object as = args;
    System.out.println(((String [])as).length);
  }
}

7.5.2  Erzeugen von Reihungen

Aufzählung der Reihung

class FirstArray {

 static String [] komponisten
  = {"carcassi","carulli","giuliani"
    ,"molino","monzino","paganini","sor"};

  public static void main(String [] args){
    System.out.println(komponisten.length);
    System.out.println(komponisten.toString());
  }
}

Uninitialisierte Reihungen

class SecondArray {

  static int [] zahlenReihung = new int[10];

  public static void main(String [] args){
    System.out.println(zahlenReihung);
  }
}

7.5.3  Zugriff auf Elemente

String [] stra = {"hallo","welt"};
String str = stra[1];

public class ArrayToString{
  static public String arrayToString(String [] obja){
    StringBuffer result = new StringBuffer("{");
    for (int i=0;i<obja.length;i=i+1){
      if (i>0) result.append(",");
      result.append(obja[i].toString());
    }
    result.append("}");
    return result.toString();
  }
}

7.5.4  Ändern von Elementen

String [] stra = {"hello","world"};
stra[0]="hallo";
stra[1]="welt";

7.5.5  Das Kovarianzproblem

class Kovarianz {

  static String [] stra = {"hallo","welt"};

  //gefährliche Zuweisung  
  static Object [] obja = stra;

  public static void main(String [] args) {
    //dieses ändert auch stra. Laufzeitfehler!
    obja[0]=new Integer(42);     

    String str = stra[0];
    System.out.println(str);
  }
}

sep@swe10:~/fh/beispiele> java Kovarianz
Exception in thread "main" java.lang.ArrayStoreException
        at Kovarianz.main(Kovarianz.java:10)

7.5.6  Weitere Methoden für Reihungen

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

7.5.7  Reihungen von Reihungen

class SchachFeld {
  Schachfigur [][] spielFeld
    =  {new Schachfigur[8]
       ,new Schachfigur[8]
       ,new Schachfigur[8]
       ,new Schachfigur[8]
       ,new Schachfigur[8]
       ,new Schachfigur[8]
       ,new Schachfigur[8]
       ,new Schachfigur[8]
       };

  public void zug(int vonX,int vonY,int nachX,int nachY){
    spielFeld[nachX][nachY] = spielFeld[vonX][vonY];
    spielFeld[vonX][vonY] = null;
  }
}
class Schachfigur {}

7.5.8  Blubbersortierung

class BubbleSort {

  static void bubbleSort(Comparable [] obja){
    boolean toBubble = true;
    while (toBubble){ 
      toBubble = bubble(obja);
    }
  }

  static boolean bubble(Comparable [] obja){
    boolean result = false;
    for (int i=0;i<obja.length;i=i+1){
      try {
        if (obja[i].compareTo(obja[i+1])>0){
          Comparable o = obja[i];
          obja[i]=obja[i+1];
          obja[i+1]=o;
          result=true;
        }
      }catch (ArrayIndexOutOfBoundsException _){}
    }
    return result;
  }  

  static public void main(String [] args){
    String [] stra = {"a","zs","za","bb","aa","aa","y"};
    System.out.println(ArrayToString.arrayToString(stra));
    bubbleSort(stra);
    System.out.println(ArrayToString.arrayToString(stra));
  }

}

{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse VierImplementierung, die die Schnittstelle VierLogik entsprechend der Dokumentation implementiert.
{\bf \alph{unteraufgabe})} Schreiben Sie folgende Hauptmethode und starten Sie diese. Sie sollten jetzt in der Lage sein, über die Eingabekonsole Vier gewinnt zu spielen.

public static void main(String[] args) {
  new VierKonsole().spiel(new VierImplementierung());
}

Suchen Sie sich einen Spielpartner und versuchen Sie, gegen ihn zu gewinnen.

7.6  Ein- und Ausgabe

• Zeichenenströme: Die Grundeinheit der Datenkommunikation sind Buchstaben und andere Schriftzeichen. Hierbei kann es sich um beliebige Zeichen aus dem Unicode handeln, also Buchstaben so gut wie jeder bekannten Schrift, von lateinischer über kyrillische, griechische, arabische, chinesische bis hin zu exotischen Schriften wie der keltischen Keilschrift. Dabei ist entscheidend, in welcher Codierurung die Buchstaben in der Datenquelle vorliegen. Die Codierung wird in der Regel beim Konstruieren eines Datenstroms festgelegt. Geschieht dieses nicht, so wird die Standardcodierung des Systems, auf dem das Programm läuft, benutzt.
• Byteströme (Oktettströme): Hierbei ist die Grundeinheit immer ein Byte, das als Zahl verstanden wird.

7.6.1  Zeichenströme

• Reader: für Ströme, aus denen gelesen werden soll.
• Writer: für Ströme, in die geschrieben werden soll.

7.6.2  Byteströme

• InputStream
• OutputStream

7.6.3  Ausnahmen

7.6.4  Schreiben und Lesen

7.6.5  Datenströme

Textdateien lesen

import java.io.*;
class ShowFile{
  public static void main(String [] args) throws Exception{
    Reader reader = new FileReader(args[0]);
    while (true){
      final int next = reader.read();
      if (next==-1) break;
      System.out.print((char)next);
      System.out.print(next);
    }
  }
}

Textdateien schreiben

import java.io.*;

public class Copy {
  public static void main(String[] args) throws IOException {
    FileReader in = new FileReader(args[0]);
    FileWriter out = new FileWriter(args[1]);
    int c;

    while ((c = in.read()) != -1){
      out.write(c);
    }
  }
}

7.6.6  Vom InputStream zum Reader, vom OutputStream zum Writer

InputStreamReader und OutputStreamWriter

Beispiel:
Statt die vorgefertigte Klasse FileWriter zum Schreiben einer Textdatei zu benutzen, erzeugt die folgende Version zum Kopieren von Dateien einen über einen FileOutputStream erzeugten Writer bzw.  einen über einen FileInputStream erzeugten Reader:

import java.io.*;

class Copy2 {
  static public void main(String [] args)
     throws Exception {
    Reader reader = new FileReader(args[0]);
    Writer writer 
     = new OutputStreamWriter(new FileOutputStream(args[1]));

    int c;
    while ((c = reader.read()) != -1){
      writer.write(c);
    }
    writer.close();
  }
}

Zeichenkodierungen

Beispiel:
In dieser Version der Kopierung einer Textdatei wird für den Writer ein Objekt der Klasse OutputStreamWriter benutzt, in der als Zeichenkodierung utf-16 benutzt wird.

import java.nio.charset.Charset;
import java.io.*;

class EncodedCopy {
  static public void main(String [] args)
     throws Exception {
    Reader reader = new FileReader(args[0]);
    Writer writer = new OutputStreamWriter
                         (new FileOutputStream(args[1])
                         ,Charset.forName("UTF-16"));

    int c;
    while ((c = reader.read()) != -1){
      writer.write(c);
    }
    writer.close();
  }
}

sep@linux:~/fh/prog1/> java EncodedCopy EncodedCopy.java EncodedCopyUTF16.java
sep@linux:~/fh/prog1/> ls -l EncodedCopy.java
-rw-r--r--    1 sep      users         443 2004-01-07 19:12 EncodedCopy.java
sep@linux:~/fh/prog1/> ls -l EncodedCopyUTF16.java
-rw-r--r--    1 sep      users         888 2004-01-07 19:13 EncodedCopyUTF16.java
sep@linux:~/fh/prog1/>

linux:~/>java FileConvert test.txt konvertiertTest.txt utf-8

Gepufferte Ströme

Beispiel:
Jetzt ergänzen wir zur Effizienzsteigerung noch das Kopierprogramm, so daß der benutzte Writer gepuffert ist:

import java.io.*;
import java.nio.charset.Charset;

class BufferedCopy{
  static public void main(String [] args)
     throws Exception {

    Reader reader = new FileReader(args[0]);
    Writer writer = new BufferedWriter
                      (new OutputStreamWriter
                          (new FileOutputStream(args[1])
                          ,Charset.forName("UTF-16")));

    int c;
    while ((c = reader.read()) != -1){
      writer.write(c);
    }
    writer.close();
  }
}

7.6.7  Ströme für Objekte

Beispiel:
Folgendes Testprogramm schreibt eine Zahl und ein Listenobjekt in eine Datei, um diese anschließend wieder aus der Datei auszulesen.

import java.io.*;
import java.util.List;
import java.util.ArrayList;

public class WriteReadObject {
  public static void main(String [] args) throws Exception{
    FileOutputStream fos = new FileOutputStream("t.tmp");
    ObjectOutputStream oos = new ObjectOutputStream(fos);

    List xs = new ArrayList();
    xs.add("the");
    xs.add("world");
    xs.add("is");
    xs.add("my");
    xs.add("oyster");

    oos.writeInt(12345);
    oos.writeObject(xs);
    oos.close();
	
    FileInputStream fis = new FileInputStream("t.tmp");
    ObjectInputStream ois = new ObjectInputStream(fis);

    int i = ois.readInt();
    List ys = (List) ois.readObject();

    ois.close();
 
    System.out.println(i);
    System.out.println(ys);
  }
}

7.6.8  Stromloses IO

Chapter 8
Erweiterungen in Java 1.5

8.1  Einführung

• Beim Entwurf und der Entwicklung von Java waren die Entwickler bei Sun unter Zeitdruck.
• Die Sprache Java wurde in ihren programmiersprachlichen Konstrukten sehr konservativ entworfen. Die Syntax wurde von C übernommen. Die Sprache sollte möglichst wenige aber mächtige Eigenschaften haben und kein Sammelsurium verschiedenster Techniken sein.

8.2  Generische Typen

8.2.1  Generische Klassen

class OldBox {
  Object contents;
  OldBox(Object contents){this.contents=contents;}
}

class UseOldBox{
  public static void main(String [] _){
    OldBox b = new OldBox("hello");
    String s = (String)b.contents;
    System.out.println(s.toUpperCase());
    System.out.println(((String) s).toUpperCase());
  }
}

class UseOldBoxError{
  public static void main(String [] _){
    OldBox b = new OldBox(new Integer(42));
    String s = (String)b.contents;
    System.out.println(s.toUpperCase());
  }
}

sep@linux:~/fh/java1.5/examples/src> javac UseOldBoxError.java
sep@linux:~/fh/java1.5/examples/src> java UseOldBoxError
Exception in thread "main" java.lang.ClassCastException
        at UseOldBoxError.main(UseOldBoxError.java:4)
sep@linux:~/fh/java1.5/examples/src>

class Box<elementType> {
  elementType contents;
  Box(elementType contents){this.contents=contents;}
}

class UseBox{
  public static void main(String [] _){
    Box<String> b1 = new Box<String>("hello");
    String s = b1.contents;
    System.out.println(s.toUpperCase());
    System.out.println(b1.contents.toUpperCase());

    Box<Integer> b2 = new Box<Integer>(new Integer(42));

    System.out.println(b2.contents.intValue());
  }
}

class UseBoxError{
  public static void main(String [] _){
    Box<String> b = new Box<String>(new Integer(42));
    String s = b.contents;
    System.out.println(s.toUpperCase());
  }
}

sep@linux:~/fh/java1.5/examples/src> javac UseBoxError.java
UseBoxError.java:3: cannot find symbol
symbol  : constructor Box(java.lang.Integer)
location: class Box<java.lang.String>
    Box<String> b = new Box<String>(new Integer(42));
                    ^
1 error
sep@linux:~/fh/java1.5/examples/src>

Vererbung

class Pair<at,bt> extends Box<at>{
  Pair(at x,bt y){
    super(x);
    snd = y; 
  }

  bt snd;

  public String toString(){
    return "("+contents+","+snd+")";
  }
}

class UsePair{
  public static void main(String [] _){
    Pair<String,Integer> p
     = new Pair<String,Integer>("hallo",new  Integer(40));
    
    System.out.println(p);
    System.out.println(p.contents.toUpperCase());
    System.out.println(p.snd.intValue()+2);
  }
}

sep@linux:~/fh/java1.5/examples/classes> java UsePair
(hallo,40)
HALLO
42
sep@linux:~/fh/java1.5/examples/classes>

class UniPair<at> extends Pair<at,at>{
  UniPair(at x,at y){super(x,y);}
  void swap(){
    final at z = snd;
    snd = contents;
    contents = z;
  }
}

class UseUniPair{
  public static void main(String [] _){
    UniPair<String> p
     = new UniPair<String>("welt","hallo");
    
    System.out.println(p);
    p.swap();
    System.out.println(p);
  }
}

sep@linux:~/fh/java1.5/examples/classes> java UseUniPair
(welt,hallo)
(hallo,welt)
sep@linux:~/fh/java1.5/examples/classes>

class StringBox extends Box<String>{
  StringBox(String x){super(x);}
}

class UseStringBox{
  public static void main(String [] _){
    StringBox b = new StringBox("hallo");
    System.out.println(b.contents.length());
  }
}

Einschränken der Typvariablen

class CollectMaxOld{
  private Comparable value;

  CollectMaxOld(Comparable x){value=x;}

  void setValue(Comparable x){
    if (value.compareTo(x)<0) value=x;
  }

  Comparable getValue(){return value;}
}

class CollectMax <elementType extends Comparable>{
  private elementType value;

  CollectMax(elementType x){value=x;}

  void setValue(elementType x){
    if (value.compareTo(x)<0) value=x;
  }

  elementType getValue(){return value;}
}

class UseCollectMax {
  public static void main(String [] _){
    CollectMax<String> cm = new CollectMax<String>("Brecht");
    cm.setValue("Calderon");
    cm.setValue("Horvath");
    cm.setValue("Shakespeare");
    cm.setValue("Schimmelpfennig");
    System.out.println(cm.getValue().toUpperCase());
  }
}

8.2.2  Generische Schnittstellen

Äpfel mit Birnen vergleichen

interface EQ<otherType> {
  public boolean eq(otherType other);
}

class Apfel implements EQ<Apfel>{
  String typ;

  Apfel(String typ){
    this.typ=typ;}

  public boolean eq(Apfel other){
    return this.typ.equals(other.typ); 
  }    
}

class TestEq{
  public static void main(String []_){
    Apfel a1 = new Apfel("Golden Delicious");
    Apfel a2 = new Apfel("Macintosh");
    System.out.println(a1.eq(a2));
    System.out.println(a1.eq(a1));
  }
}

class Birne implements EQ<Birne>{
  String typ;

  Birne(String typ){
    this.typ=typ;}

  public boolean eq(Birne other){
    return this.typ.equals(other.typ); 
  }    
}

class TesteEqError{
  public static void main(String []_){
    Apfel a = new Apfel("Golden Delicious");
    Birne b = new Birne("williams");
    System.out.println(a.equals(b));
    System.out.println(a.eq(b));
  }
}

./TestEQError.java:6: eq(Apfel) in Apfel cannot be applied to (Birne)
    System.out.println(a.eq(b));
                        ^
1 error

class BirneError implements EQ<Apfel>{
  String typ;

  BirneError(String typ){
    this.typ=typ;}

  public boolean eq(Birne other){
    return this.typ.equals(other.typ); 
  }    
}

sep@linux:~/fh/java1.5/examples/src> javac BirneError.java
BirneError.java:1: BirneError is not abstract and does not override abstract method eq(Apfel) in EQ
class BirneError implements EQ<Apfel>{
^
1 error
sep@linux:~/fh/java1.5/examples/src>

8.2.3  Kovarianz gegen Kontravarianz

class Kontra{
  public static void main(String []_){
    Box<Object> b  = new Box<String>("hello");
  }
}

sep@linux:~/fh/java1.5/examples/src> javac Kontra.java
Kontra.java:4: incompatible types
found   : Box<java.lang.String>
required: Box<java.lang.Object>
    Box<Object> b  = new Box<String>("hello");
                     ^
1 error
sep@linux:~/fh/java1.5/examples/src>

class Ko{
  public static void main(String []_){
    String [] x = {"hello"};
    Object [] b  = x;
    b[0]=new Integer(42);
    x[0].toUpperCase();
  }
}

sep@linux:~/fh/java1.5/examples/classes> java Ko
Exception in thread "main" java.lang.ArrayStoreException
        at Ko.main(Ko.java:5)
sep@linux:~/fh/java1.5/examples/classes>

8.2.4  Sammlungsklassen

import java.util.*;
import java.util.List;
class ListTest{
  public static void main(String [] _){
    List<String> xs = new ArrayList<String>();
    xs.add("Schimmelpfennig");
    xs.add("Shakespeare");
    xs.add("Horvath");
    xs.add("Brecht");
    String x2 = xs.get(1);
    System.out.println(xs);
  }
}

import java.util.*;
import java.util.List;
class WarnTest{
  public static void main(String [] _){
    List xs = new ArrayList<String>();
    xs.add("Schimmelpfennig");
    xs.add("Shakespeare");
    xs.add("Horvath");
    xs.add("Brecht");
    String x2 = (String)xs.get(1);
    System.out.println(xs);
  }
}

sep@linux:~/fh/java1.5/examples/src> javac WarnList.java
Note: WarnList.java uses unchecked or unsafe operations.
Note: Recompile with -warnunchecked for details.
sep@linux:~/fh/java1.5/examples/src>

8.2.5  Generische Methoden

class Trace {

  static <elementType>  elementType trace(elementType x){
    System.out.println(x);
    return x;
  }
  
  public static void main(String [] _){
    String x = trace ((trace ("hallo")
                      +trace( " welt")).toUpperCase());

    Integer y = trace (new Integer(40+2));
  }
}

8.3  Iteration

Beispiel:
In diesen Beispiel finden sich die zwei wahrscheinlich am häufigsten programmierten Schleifentypen. Einmal iterieren wir über alle Elemente einer Reihung und einmal iterieren wir mittels eines Iteratorobjekts über alle Elemente eines Sammlungsobjekts:

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

class OldIteration{

  public static void main(String [] _){
    String [] ar
      = {"Brecht","Horvath","Shakespeare","Schimmelpfennig"};
    List xs = new ArrayList();

    for (int i= 0;i<ar.length;i++){
      final String s = ar[i];
      xs.add(s);
    }  
 
    for (Iterator it=xs.iterator();it.hasNext();){
      final String s = (String)it.next();
      System.out.println(s.toUpperCase());
    }
  }
}

Beispiel:
Damit lassen sich jetzt die Iterationen der letzten beiden Schleifen wesentlich eleganter ausdrücken.

import java.util.List;
import java.util.ArrayList;

class NewIteration{

  public static void main(String [] _){
    String [] ar
     = {"Brecht","Horvath","Shakespeare","Schimmelpfennig"};
    List<String> xs = new ArrayList<String>();

    for (String s:ar) xs.add(s); 
    for (String s:xs) System.out.println(s.toUpperCase());
  }
}

8.3.1  Die neuen Schnittstellen Iterable und SimpleIterator

Beispiel:

package sep.util.io;

import java.io.Reader;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Iterator;


public class ReaderIterator 
              implements Iterable<Character>
                        ,Iterator<Character>{
  private Reader reader;
  private int n;
  public ReaderIterator(Reader r){
    reader=new BufferedReader(r);
    try{n=reader.read();
    }catch(IOException _){n=-1;}
  }
  public Character next(){
    Character result = new Character((char)n);   
    try{n=reader.read();
    }catch(IOException _){n=-1;}
    return result;
  }

  public boolean hasNext(){
    return n!=-1;
  }

  public void remove(){
    throw new UnsupportedOperationException();
  }

  public Iterator<Character> iterator(){return this;}
}

import sep.util.io.ReaderIterator;
import java.io.FileReader;

class TestReaderIterator {
  public static void main(String [] args) throws Exception{
      Iterable<Character> it
        =new ReaderIterator(new FileReader(args[0]));
      for (Character c:it){
      System.out.print(c);
    }
  }
}

Beispiel:
Ein abschließendes kleines Beispiel für generische Sammlungsklassen und die neue for-Schleife. Die folgende Klasse stellt Methoden zur Verfügung, um einen String in eine Liste von Wörtern zu spalten und umgekehrt aus einerListe von Wörtern wieder einen String zu bilden:

import java.util.*;
import java.util.List;

class TextUtils {

  static List<String> words (String s){
    final List<String> result = new ArrayList<String>();

    StringBuffer currentWord = new StringBuffer();

    for (char c:s.toCharArray()){
      if (Character.isWhitespace(c)){
        final String newWord = currentWord.toString().trim();
        if(newWord.length()>0){
          result.add(newWord);
          currentWord=new StringBuffer();
        }
      }else{currentWord.append(c);} 
    }
    return result;
  }

  static String unwords(List<String> xs){
    StringBuffer result=new StringBuffer();
    for (String x:xs) result.append(" "+x);
    return result.toString().trim();
  }

  public static void main(String []_){
    List<String> xs = words("  the   world  is my Oyster  ");

    for (String x:xs) System.out.println(x);

    System.out.println(unwords(xs));
  }
}

8.4  Automatisches Boxen

8.5  Aufzählungstypen

8.6  Ein paar Beispielklassen

package name.panitz.crempel.util;

public interface UnaryFunction<arg,result>{
  public result eval(arg a);
}

package name.panitz.crempel.util;

public class Tuple1<t1> {
  public t1 e1;
  public Tuple1(t1 a1){e1=a1;}
  String parenthes(Object o){return "("+o+")";}
  String simpleToString(){return e1.toString();}
  public String toString(){return parenthes(simpleToString());}
  public boolean equals(Object other){
    if (! (other instanceof Tuple1)) return false;
    return e1.equals(((Tuple1)other).e1);
  }
}

package name.panitz.crempel.util;

public class Tuple2<t1,t2> extends Tuple1<t1>{
  public t2 e2;
  public Tuple2(t1 a1,t2 a2){super(a1);e2=a2;}
  String simpleToString(){
    return super.simpleToString()+","+e2.toString();}
  public boolean equals(Object other){
    if (! (other instanceof Tuple2)) return false;
    return super.equals(other)&& e2.equals(((Tuple2)other).e2);
  }
}

package name.panitz.crempel.util;

public class Tuple3<t1,t2,t3> extends Tuple2<t1,t2>{
  public t3 e3;
  public Tuple3(t1 a1,t2 a2,t3 a3){super(a1,a2);e3=a3;}
  String simpleToString(){
    return super.simpleToString()+","+e3.toString();}
  public boolean equals(Object other){
    if (! (other instanceof Tuple3)) return false;
    return super.equals(other)&& e3.equals(((Tuple3)other).e3);
  }
}

package name.panitz.crempel.util;

public class Tuple4<t1,t2,t3,t4> extends Tuple3<t1,t2,t3>{
  public t4 e4;
  public Tuple4(t1 a1,t2 a2,t3 a3,t4 a4){super(a1,a2,a3);e4=a4;}
  String simpleToString(){
    return super.simpleToString()+","+e4.toString();}
  public boolean equals(Object other){
    if (! (other instanceof Tuple4)) return false;
    return super.equals(other)&& e4.equals(((Tuple4)other).e4);
  }
}

package name.panitz.crempel.util;

import java.util.Iterator;

public class FromTo implements Iterable<Integer>,Iterator<Integer>{
  private final int to; 
  private int from; 
  public FromTo(int f,int t){to=t;from=f;}
  public boolean hasNext(){return from<=to;}
  public Integer next(){int result = from;from=from+1;return result;}
  public Iterator<Integer> iterator(){return this;}
  public void remove(){new UnsupportedOperationException();}
}

data Maybe a = Nothing|Just a

package name.panitz.crempel.util;
public interface Maybe<a> {}

package name.panitz.crempel.util;
public class Nothing<a> implements Maybe<a>{

  public String toString(){return "Nothing("+")";}
  public boolean equals(Object other){
    return (other instanceof Nothing);
  }
}

package name.panitz.crempel.util;

public class Just<a> implements Maybe<a>{
  private a just;

  public Just(a just){this.just = just;}
  public a getJust(){return just;}

  public String toString(){return "Just("+just+")";}
  public boolean equals(Object other){
    if (!(other instanceof Just)) return false;
    final Just o= (Just) other;
    return just.equals(o.just);
  }
}

package name.panitz.crempel.tool;
public interface CrempelTool{String getDescription();void startUp();}

Chapter 9
Steuerfäden

9.1  Schreiben von Steuerfäden

• Durch Ableiten von der Klasse Thread und überschreiben der Methode run.
• Durch Implementierung der Schnittstelle Runnable, die Methode run enthält.

Beispiel:
Folgendes Programm definiert einen simplen Steuerfaden, der unendlich oft seinen Namen auf den Bildschirm ausgibt. In der main-Methode werden zwei Instanzen dieses Steuerfadens erzeugt und gestartet. Anhand der Ausgabe des Programms kann verfolgt werden, wie Java zwischen den zwei Steuerfäden umschaltet:

class SimpleThread extends Thread {

  public void run(){
    while (true){
      System.out.print(getName());
    }
  }

  public static void main(String [] args){
    new SimpleThread().start();
    new SimpleThread().start();
  }
}

9.1.1  Schlafenlegen von Prozessen

Beispiel:
Unseren ersten Steuerfaden aus dem letzten Beispiel erweitern wir jetzt darum, daß er sich jeweils eine bestimmte Zeit zur Ruhe legt, nachdem er seinen Namen ausgedruckt hat:

class SleepingThread extends Thread {
  public SleepingThread(int s){this.s=s;}
  private int s; 

  public void run(){
    while (true){
      System.out.print(getName());
      try {Thread.sleep(s);}catch (InterruptedException _){}
    }
  }

  public static void main(String [] args){
    new SleepingThread(1000).start();
    new SleepingThread(300).start();
  }
}

sep@swe10:~/fh/internal/beispiele> java SleepingThread
Thread-1Thread-0Thread-1Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1
Thread-0Thread-1Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1Thread-1
Thread-0Thread-1Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1Thread-0
Thread-1Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1Thread-1Thread-0
Thread-1Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1Thread-0Thread-1
Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1Thread-1Thread-0Thread-1
Thread-1Thread-1Thread-0Thread-1Thread-1Thread-1Thread-0
sep@swe10:~/fh/internal/beispiele>

9.2  Koordination nebenläufiger Steuerfäden

9.2.1  Benutzung gemeinsamer Objekte

class TwoNumbers{
   int x;
   int y;

   TwoNumbers(int x, int y) {this.x=x; this.y=y;}

   void swap(){
     int z=x;
     x=y;
     try {Thread.sleep(100);}catch (InterruptedException _){}
     y=z;
   }

   public String toString(){return "("+x+","+y+")";}
}

class Swap extends Thread{

  public Swap(TwoNumbers twoN){this.twoN=twoN;}

  private TwoNumbers twoN;

  public void run(){
    while (true){twoN.swap();}
  }
}

class PrintTwoNumbers extends Thread {
  public PrintTwoNumbers(TwoNumbers twoN){this.twoN=twoN;}

  private TwoNumbers twoN;

  public void run(){
    while (true){
      System.out.println(twoN);
      try {Thread.sleep(1000);}catch (InterruptedException _){}
    }
  }

  public static void main(String [] _){
    TwoNumbers twoN = new TwoNumbers(1,2);
    new Swap(twoN).start();
    new PrintTwoNumbers(twoN).start();
  }
}

sep@swe10:~/fh/internal/beispiele> java PrintTwoNumbers
(1,2)
(1,1)
(2,2)
(1,1)
(2,2)
(1,1)
(1,1)
(2,2)
(1,1)
(2,2)
(1,1)
(1,1)
(2,2)

sep@swe10:~/fh/internal/beispiele>

9.2.2  Synchronisation

Synchronisation von Methoden

class SafeTwoNumbers{
  int x;
  int y;

  SafeTwoNumbers(int x, int y) {this.x=x; this.y=y;}

  synchronized void swap(){
    int z=x;
    x=y;
    try {Thread.sleep(400);}catch (InterruptedException _){}
    y=z;
  }

  synchronized public String toString(){
    return "("+x+","+y+")";
  }
}

sep@swe10:~/fh/internal/beispiele> java PrintTwoNumbers
(1,2)
(2,1)
(1,2)
(2,1)
(1,2)
(2,1)
(1,2)
(2,1)

sep@swe10:~/fh/internal/beispiele>

Synchronisation von Blöcken

class SafeSwap extends Thread{

  public SafeSwap(TwoNumbers twoN){this.twoN=twoN;}

  private TwoNumbers twoN;

  public void run(){
    while (true){
      synchronized(twoN){twoN.swap();}
    }
  }
}

class SafePrintTwoNumbers extends Thread {
  public SafePrintTwoNumbers(TwoNumbers twoN){this.twoN=twoN;}

  private TwoNumbers twoN;

  public void run(){
    while (true){
      synchronized (twoN){System.out.println(twoN);}
      try {Thread.sleep(1000);}catch (InterruptedException _){}
    }
  }

  public static void main(String [] _){
    TwoNumbers twoN = new TwoNumbers(1,2);
    new SafeSwap(twoN).start();
    new SafePrintTwoNumbers(twoN).start();
  }
}

9.2.3  Verklemmungen

Verklemmung bei der Buchausleihe

Das 5-Philosophenproblem

Verklemmung im Straßenverkehr

Verklemmung in Java

class Deadlock extends Thread{

  Object a;
  Object b;

  Deadlock (Object a,Object b){this.a=a;this.b=b;}

  public void run(){
    synchronized (a){
      System.out.println(
        getName()+"jetzt habe ich das erste Objekt: "+a);   
      try {Thread.sleep(1000);}catch (InterruptedException _){}
      synchronized (b){
	  System.out.println(getName()+"jetzt habe ich beide");   
      }
    }
  }

  public static void main(String [] _){
    String s1 = "hallo";
    String s2 = "welt";
    new Deadlock(s1,s2).start();
    new Deadlock(s2,s1).start();
  }
}

sep@swe10:~/fh/internal/beispiele> java Deadlock
Thread-0jetzt habe ich das erste Objekt: hallo
Thread-1jetzt habe ich das erste Objekt: welt

9.2.4  Warten und Benachrichtigen

class GetSet1 {
  private int i;
  GetSet1(int i){this.i=i;}

  synchronized int get(){return i;}
  synchronized void set(int i){this.i=i;}
}

class Set extends Thread{
  GetSet1 o;
  Set(GetSet1 o){this.o=o;}
  public void run(){
    for (int i=1;i<=1000;i=i+1){
      o.set(i);
    }
  }
}

class Get extends Thread{
  GetSet1 o;
  Get(GetSet1 o){this.o=o;}
  public void run(){
    for (int i=1;i<=1000;i=i+1){
      System.out.print(o.get()+" ");
    }
  }

  public static void main(String [] _){
    GetSet1 gss = new GetSet1(0);
    new Get(gss).start();
    new Set(gss).start();
  }
}

class GetSet2 {
  private int i;
  private boolean available= true;
  GetSet2(int i){this.i=i;}

  synchronized int get(){
    while (!available){
      try{Thread.sleep(1000);}catch (Exception _){}
    }    
    available=false;
    return i;
  }

  synchronized void set(int i){
    while (available){
      try{Thread.sleep(1000);}catch (Exception _){}
    }
    this.i=i;
    available=true;
  }
}

class GetSet3 {
  private int i;
  private boolean available= true;
  GetSet3(int i){this.i=i;}

  synchronized int get(){
    while (!available){
      try{wait();}catch (Exception _){}
    }    
    available=false;
    notifyAll();
	 
    return i;
  }

  synchronized void set(int i){
    while (available){
      try{wait();}catch (Exception _){}
    }
    this.i=i;
    available=true;
    notifyAll();
  }
}

Chapter 10
Javawerkzeuge

10.1  Klassenpfad und Java-Archive

10.1.1  Benutzung von jar-Dateien

sep@swe10:~/fh/prog2> jar
Syntax: jar {ctxu}[vfm0Mi] [JAR-Datei] [Manifest-Datei] [-C dir] Dateien ...
Optionen:
    -c  neues Archiv erstellen
    -t  Inhaltsverzeichnis für Archiv auflisten
    -x  benannte (oder alle) Dateien aus dem Archiv extrahieren
    -u  vorhandenes Archiv aktualisieren
    -v  ausführliche Ausgabe für Standardausgabe generieren
    -f  Namen der Archivdatei angeben
    -m  Manifestinformationen aus angegebener Manifest-Datei einbeziehen
    -0  nur speichern; keine ZIP-Komprimierung verwenden
    -M  keine Manifest-Datei für die Einträge erstellen
    -i  Indexinformationen für die angegebenen JAR-Dateien generieren
    -C  ins angegebene Verzeichnis wechseln und folgende Datei einbeziehen
Falls eine Datei ein Verzeichnis ist, wird sie rekursiv verarbeitet.
Der Name der Manifest-Datei und der Name der Archivdatei müssen
in der gleichen Reihenfolge wie die Flags ''m'' und ''f'' angegeben werden.

Beispiel 1: Archivieren von zwei Klassendateien in einem Archiv 
mit dem Namen classes.jar:
       jar cvf classes.jar Foo.class Bar.class
Beispiel 2: Verwenden der vorhandenen Manifest-Datei ''meinmanifest'' 
und Archivieren aller
           Dateien im Verzeichnis foo/ in ''classes.jar'':
       jar cvfm classes.jar meinmanifest -C foo/ .

sep@swe10:~/fh/prog2>

Erzeugen von Jar-Dateien

jar cf jar-file input-file(s)

• Das c steht dafür, das eine Jar-Datei erzeugt werden soll.
• Das f steht dafür, daß der Dateiname der zu erzeugenden Jar-Datei folgt.
• jar-file ist der Name, den die zu erzeugende Datei haben soll. Hier nimmt man üblicherweise die Erweiterung .jar für den Dateinamen.
• input-file(s) ist eine Liste beliebiger Dateien und Ordner. Hier kann auch die aus der Kommandozeile bekannte *-Notation benutzt werden.

Beispiel:
Der Befehl

jar cf myProg.jar *.class

verpackt alle Dateien mit der Erweiterung .class in eine Jar-Datei namens myProg.jar.

Anzeige des Inhalts einer Jar-Datei

jar tf jar-file

• Das t steht dafür, das eine Auflistung der enthaltenen Dateien angezeigt werden⁴⁰ soll.
• Das f steht dafür, daß der Dateiname der benötigten Jar-Datei folgt.
• jar-file ist der Name der existierenden Jar-Datei.

Extrahieren des Inhalts der Jar-Datei

jar xf jar-file [archived-file(s)]

• Die x-Option gibt an, daß Dateien aus einer Jar-Datei extrahiert werden sollen.
• Das f gibt wieder an, daß der Name einer JAR-Datei folgt.
• jar-file ist der Name einer Jar-Datei, aus der die entsprechenden Dateien zu extrahieren sind.
• Optional kann noch eine Liste von Dateinamen folgen, die angibt, welche Dateien extrahiert werden sollen. Wird diese Liste weggelassen, so werden alle Dateien extrahiert.

Ändern einer Jar Datei

jar uf jar-file input-file(s)

• Die Option u gibt an, daß eine bestehende Jar-Datei geändert werden soll.
• Das f gibt wie üblich an, daß der Name einer Jar-Datei folgt.
• Eine Liste von Dateinamen gibt an, daß diese zur Jar-Datei hinzuzufügen sind.

10.1.2  Der Klassenpfad

Angabe des Klassenpfades als Option

sep@swe10:~/fh/prog2> java -help -cp
Usage: java [-options] class [args...]
           (to execute a class)
   or  java -jar [-options] jarfile [args...]
           (to execute a jar file)

where options include:

    -cp -classpath <directories and zip/jar files separated by :>
                  set search path for application classes and resources

Angabe des Klassenpfades als Umgebungsvariable

sep@swe10:~/fh/prog2> echo $CLASSPATH
.:/home/sep/jarfiles/log4j-1.2.8.jar:/home/sep/jarfiles:
sep@swe10:~/fh/prog2>

Beispiel:
Wir fügen dem Klassenpfad eine weitere Jar-Datei an ihrem Beginn an:

sep@swe10:~/fh/prog2> export CLASSPATH=~/jarfiles/jugs.jar:$CLASSPATH
sep@swe10:~/fh/prog2> echo $CLASSPATH
/home/sep/jarfiles/jugs.jar:.:/home/sep/jarfiles/log4j-1.2.8.jar:/home/sep/jarfiles:

Beispiel:
Der entsprechende Befehl des letzten Beispiels ist in Windows:
set CLASSPATH=~\jarfiles\jugs.jar:%CLASSPATH%

• Jugs: ein Kommandozeilen-basierter Javainterpreter.
• JugsGui: eine graphische interaktive Javaumgebung.

• 2*21
• "hello world".toUpperCase().substring(2,5)
• System.getProperties()
• System.getProperty("user.name")

10.2  Java Dokumentation mit javadoc

10.3  Klassendateien analysieren mit javap

Appendix A
Beispielaufgaben für die Klausur

class Aufgabe1{
  public static void main(String [] args){
    int i = 42;
    for (int j = i; j>=i%15;j=j-5){
      System.out.println(j);
    } 
  }
}

{\bf \alph{unteraufgabe})}

class Aufgabe2a {
   static int dividiere(int z, int n){
     if (n!=0) return z/n;
   }
}


{\bf \alph{unteraufgabe})}

class Aufgabe2b {
   static int dividiere(int z, int n){
     if (n!=0) return z/n;
     throw new Exception("division durch 0");
   }
}


{\bf \alph{unteraufgabe})}

class Aufgabe2c {
  String x;
  String y;

  Aufgabe2c(String x, StringBuffer y){
    this.x = x;
    this.y = y;
  }
}


{\bf \alph{unteraufgabe})}

class Aufgabe2d{
  public void printTwiceAsUpperCase(String s){
    Object doppelS = s+s;
    System.out.println(doppelS.toUpperCase());
  }
}


{\bf \alph{unteraufgabe})}

class Aufgabe2e_1{
  private String s = "hallo";
  public String getS(){return s;}
}

class Aufgabe2e_2{
  public static String getS(Aufgabe2e_1 e1){return e1.s;}
}


{\bf \alph{unteraufgabe})}

class Aufgabe2f{
  public void printString(String s){
    System.out.println(s);
  }

  public static void main(String [] args){
    printString("hallo");
  }
}

abstract class AbList{
    abstract public AbList empty();
    abstract public AbList cons(Object x, AbList xs);
    abstract public boolean isEmpty();
    abstract public Object head();
    abstract public AbList tail();
}

{\bf \alph{unteraufgabe})} public AbList take(int i);
take soll eine Teilliste der ersten i Elemente zurückgeben.
{\bf \alph{unteraufgabe})} public AbList drop(int i);
drop soll eine Teilliste zurückgeben, in der die ersten i Elemente fehlen.
{\bf \alph{unteraufgabe})} public AbList sublist(int beginIndex,int laenge);
sublist soll die Teilliste zurückgeben, vom Element an der Stelle beginIndex anfängt und die nachfolgenden laenge Elemente enthält. Sie dürfen die Methoden take und drop benutzen.
{\bf \alph{unteraufgabe})} public AbList twiceElements();
twiceElements baut eine Liste, in der jedes Element doppelt eingetragen wurde.
Beispiel: aus der Liste ("a","b","c") erzeugt twiceElements die Liste: ("a","a","b","b","c","c").

class Aufgabe5_1{
    public String getInfo(){return "5_1";}
}

class Aufgabe5_2 extends Aufgabe5_1{
    public String getInfo(){return "5_2";}
}

class Aufgabe5_3 extends Aufgabe5_2{
    public String getInfo(){return "5_3";}
}

class Aufgabe5 {
  static String getInfo(Aufgabe5_1 o){return o.getInfo();}

  public static void main(String [] args){
    Aufgabe5_1 a1 = new Aufgabe5_3();
    Aufgabe5_1 a2 = new Aufgabe5_2();
    Aufgabe5_1 a3 = new Aufgabe5_1();
    System.out.println(a3.getInfo());
    System.out.println(getInfo(a3));
    System.out.println(getInfo(a1));
    System.out.println(a2.getInfo());
  }
}

class Aufgabe6{
  String g1(){
    new NullPointerException();
    return "g1";
  }

  String g2()throws Exception{
    try {
      return g1();
    }catch (NullPointerException _){
      throw new Exception();
    }
  }

  String g3(){
    String result="";
    try {
      result=g2();
    }catch (NullPointerException _){
      return "null pointer";
    }catch (Exception _){
      return "exception";
    }
    return result;
  }
  public static void main(String [] args){
    System.out.println(new Aufgabe6().g3());
  }
}

Appendix B
Gesammelte Aufgaben

• Personen mit Namen, Vornamen, Straße, Ort und Postleitzahl.
• Bücher mit Titel und Autor.
• Datum mit Tag, Monat und Jahr.
• Buchausleihe mit Ausleiher, Buch und Datum.

{\bf \alph{unteraufgabe})} Schreiben Sie geeignete Konstruktoren für diese Klassen.
{\bf \alph{unteraufgabe})} Schreiben Sie für jede dieser Klassen eine Methode public String toString() mit dem Ergebnistyp. Das Ergebnis soll eine gute textuelle Beschreibung des Objektes sein.⁴¹
{\bf \alph{unteraufgabe})} Schreiben Sie eine Hauptmethode in einer Klasse Main, in der Sie Objekte für jede der obigen Klassen erzeugen und die Ergebnisse der toString-Methode auf den Bildschirm ausgeben.

class TestInteger {
  public static void main(String [] _){
    System.out.println(2147483647+1);
    System.out.println(-2147483648-1);
  }
}

• Eine Methode click(), die den internen Zähler um eins erhöht.
• Eine Methode reset(), die den Zähler wieder auf den Wert 0 setzt.
• Eine Methode, die den aktuellen Wert des Zählers ausgibt.

{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse Roman. Diese Klasse soll eine natürliche Zahl darstellen.
{\bf \alph{unteraufgabe})} Schreiben Sie für Ihre Klasse Roman einen Konstruktor, der ein Stringobjekt als Parameter hat. Dieser Stringparameter soll eine römische Zahl darstellen. Der Konstruktor soll diese Zahl lesen und in einem Feld des Typs int abspeichern.
{\bf \alph{unteraufgabe})} Implementieren Sie die Methode public String toString() für Ihre Klasse Roman, die die intern gespeicherte Zahl als römische Zahl dargestellt zurückibt.
{\bf \alph{unteraufgabe})} Fügen Sie ihrer Klasse Roman die folgenden Methoden für arithmetische Rechnungen hinzu.
• Roman add(Roman other)
• Roman sub(Roman other)
• Roman mul(Roman other)
• Roman div(Roman other)

{\bf \alph{unteraufgabe})} Testen Sie Ihre Klasse Roman.

• ButtonLogic

  class ButtonLogic {
    String getDescription(){
      return "in Großbuchstaben umwandeln";
    }
    String eval(String x){return x.toUpperCase();}
  }
  
  

Dialogue

import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
class Dialogue extends JFrame{

  final ButtonLogic logic; 

  final JButton button;
  final JTextField inputField  = new JTextField(20) ;
  final JTextField outputField = new JTextField(20) ;
  final JPanel p = new JPanel();

  Dialogue(ButtonLogic l){
    logic = l;
    button=new JButton(logic.getDescription());
    button.addActionListener
     (new ActionListener(){
        public void actionPerformed(ActionEvent _){
          outputField.setText
             (logic.eval(inputField.getText().trim()));
        }
      });
    p.setLayout(new BorderLayout());
    p.add(inputField,BorderLayout.NORTH);
    p.add(button,BorderLayout.CENTER);
    p.add(outputField,BorderLayout.SOUTH);
    getContentPane().add(p);
    pack();
    setVisible(true);
  }
}

TestDialogue
class TestDialogue {
  public static void main(String [] _){
    new Dialogue(new ButtonLogic());
  }
}

{\bf \alph{unteraufgabe})} Übersetzen Sie die drei Klassen und starten Sie das Programm.
{\bf \alph{unteraufgabe})} Schreiben Sie eine Unterklasse der Klasse ButtonLogic. Sie sollen dabei die Methoden getDescription und eval so überschreiben, daß der Eingabestring in Kleinbuchstaben umgewandelt wird. Schreiben Sie eine Hauptmethode, in der Sie ein Objekt der Klasse Dialogue mit einem Objekt Ihrer Unterklasse von ButtonLogic erzeugen.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt eine Unterklasse der Klasse ButtonLogic, so daß Sie im Zusammenspiel mit der Guiklasse Dialogue ein Programm erhalten, in dem Sie römische Zahlen in arabische Zahlen umwandeln können. Testen Sie Ihr Programm.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt eine Unterklasse der Klasse ButtonLogic, so daß Sie im Zusammenspiel mit der Guiklasse Dialogue ein Programm erhalten, in dem Sie arabische Zahlen in römische Zahlen umwandeln können. Testen Sie Ihr Programm.
{\bf \alph{unteraufgabe})} Schreiben Sie jetzt ein Guiprogramm, daß eine Zahl aus ihrer Darstellung zur Basis 10 in eine Darstellung zur Basis 2 umwandelt. Testen Sie.

{\bf \alph{unteraufgabe})} Object last(): gibt das letzte Element der Liste aus.
{\bf \alph{unteraufgabe})} List concat(List other) bzw.: Li concat(Li other): erzeugt eine neue Liste, die erst die Elemente der this-Liste und dann der other-Liste hat, es sollen also zwei Listen aneinander gehängt werden.
{\bf \alph{unteraufgabe})} Object elementAt(int i): gibt das Element an einer bestimmten Indexstelle der Liste zurück. Spezifikation:



elementAt(Cons(x,xs),1) = x elementAt(Cons(x,xs),n+1) = elementAt(xs,n)

• ("a","b","c","d","e")
• ("c","a","b","d","e")

{\bf \alph{unteraufgabe})} Implementieren Sie für Ihre Listenklasse eine Methode String toHtmlTable(), die für Listen Html-Code für eine Tabelle erzeugt, z.B:

<table>
  <tr>erstes Listenelement</tr>
  <tr>zweites Listenelement</tr>
  <tr>drittes Listenelement</tr>
</table>


{\bf \alph{unteraufgabe})} Nehmen Sie die Klasse Student, die Felder für Namen, Vornamen und Matrikelnummer hat. Implementieren Sie für diese Klasse eine Methode String toTableRow(), die für Studenten eine Zeile einer Html-Tabelle erzeugt:

Student s1 = new Student("Müller","Hans",167857);
System.out.println(s1.toTableRow());

soll folgende Ausgabe ergeben:

<td>Müller</td><td>Hans</td><td>167857</td>

Ändern Sie die Methode toString so, daß sie dasselbe Ergebnis wie die neue Methode toTableRow hat.
{\bf \alph{unteraufgabe})} Legen Sie eine Liste von Studenten an, sortieren Sie diese mit Hilfe der Methode sortBynach Nachnamen und Vornamen und erzeugen Sie eine Html-Seite, die die sortierte Liste anzeigt.
Sie können zum Testen die folgende Klasse benutzen:

HtmlView

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.plaf.basic.*; 
import javax.swing.text.*; 
import javax.swing.text.html.*; 

public class HtmlView extends JPanel {

  //example invocation
  public static void main(String s[]) {
    HtmlView view = new HtmlView();
    view.run();
    view.setText("<h1>hallo</h1>");
  }

  JFrame frame;
  JTextPane ausgabe = new JTextPane();

  public HtmlView() {
    ausgabe.setEditorKit(new HTMLEditorKit());
    add(ausgabe);	
  }

  void setText(String htmlString){
    ausgabe.setText(htmlString);
    frame.pack();
    ausgabe.repaint();
  }

  void run(){
    frame = new JFrame("HtmlView");
    frame.getContentPane().add(this);
    frame.pack();
    frame.setVisible(true);
  }
}

{\bf \alph{unteraufgabe})} Schreiben sie eine Unterklasse From der Klasse FromTo, die von einem Startwert an in Einerschritten ganze Zahlen zurückgibt und für die hasNext immer wahr ist.
{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse Sieb, die die Schnittstelle IntIterator implementiert. Die Klasse soll zwei Felder haben: eine ganze Zahl und ein weiteres Objekt, das die Schnittstelle IntIterator implementiert. Der Konstruktor habe die Signatur:
public Sieb(int i,IntIterator it)
Die Methode next soll das nächste Element des inneren Iterators it zurückgeben, das nicht durch die Zahl i teilbar ist.
Beispiel: PrintIntIteratorElements.print(new Sieb(3,new From(1))) gibt alle nicht durch 3 teilbaren natürlichen Zahlen auf dem Bildschirm aus.
{\bf \alph{unteraufgabe})} Übersetzen Sie ihren Code mit folgender Klasse:
package de.tfhberlin.panitz.iterator;
class PrimIterator implements IntIterator{
  private IntIterator sieb = new From(2);
  public boolean hasNext(){return sieb.hasNext();}
  public int next(){
    int result = sieb.next();
    sieb= new Sieb(result,sieb);
    return result;
  }
}
Lassen Sie sich alle Werte von PrimIterator mit der Methode PrintIntIteratorElements.print ausgeben.

{\bf \alph{unteraufgabe})} Laden Sie sich hierzu das Archiv
Eliza.zip (http://www.tfh-berlin.de/~panitz/prog1/load/Eliza.zip)
vom Netz. Entpacken Sie es. Machen Sie sich mit den einzelnen Klassen vertraut.
{\bf \alph{unteraufgabe})} In der Klasse MyList sind nicht alle abstrakten Methoden der Klasse Li implementiert. Ergänzen Sie MyList um die Methoden:
reverse, words, unwords, drop, tails, isPrefixIgnoreCaseOf. Implementieren Sie diese Methoden entsprechend ihrer Dokumentation in der abstrakten Klasse Li und schreiben Sie Tests für jede Methode.
Wenn Ihre Tests erfolgreich sind, übersetzen Sie alle Klassen und starten Sie die main-Methode der Klasse Main.
{\bf \alph{unteraufgabe})} Erfinden Sie eigene Einträge für die Liste respMsgs in der Klasse Data.
{\bf \alph{unteraufgabe})} Erklären Sie, was die Methode rotate von den anderen Methoden der Klasse Li fundamental unterscheidet. Demonstrieren Sie dieses anhand eines Tests.

{\bf \alph{unteraufgabe})} Schreiben Sie eine Klasse VierImplementierung, die die Schnittstelle VierLogik entsprechend der Dokumentation implementiert.
{\bf \alph{unteraufgabe})} Schreiben Sie folgende Hauptmethode und starten Sie diese. Sie sollten jetzt in der Lage sein, über die Eingabekonsole Vier gewinnt zu spielen.

public static void main(String[] args) {
  new VierKonsole().spiel(new VierImplementierung());
}

Suchen Sie sich einen Spielpartner und versuchen Sie, gegen ihn zu gewinnen.

linux:~/>java FileConvert test.txt konvertiertTest.txt utf-8

• Jugs: ein Kommandozeilen-basierter Javainterpreter.
• JugsGui: eine graphische interaktive Javaumgebung.

• 2*21
• "hello world".toUpperCase().substring(2,5)
• System.getProperties()
• System.getProperty("user.name")

Appendix C
Java Syntax