Programmieren in Java - IM-Wikifbim.fh-regensburg.de/~saj39122/pgj/ueb/loesungen.pdf · Programmieren in Java 1. Übung 7 1. Übung 1. Aufgabe Gegeben ist das folgende Programm in

Prof. Jürgen Sauer

Programmieren in Java

Übungen mit Lösungen

Programmieren in Java Inhaltsverzeichnis

2


3

Inhaltsverzeichnis

1. Übung __________________________________________________________________ 7

1. Aufgabe _______________________________________________________________ 7

2. Aufgabe _______________________________________________________________ 8

3. Aufgabe _______________________________________________________________ 9

4. Aufgabe ______________________________________________________________ 10

5. Aufgabe ______________________________________________________________ 10

6. Aufgabe ______________________________________________________________ 11

2. Übung _________________________________________________________________ 12

1. Aufgabe ______________________________________________________________ 12

2. Aufgabe ______________________________________________________________ 13

3. Aufgabe ______________________________________________________________ 14

4. Aufgabe ______________________________________________________________ 16

5. Aufgabe ______________________________________________________________ 17

3. Übung _________________________________________________________________ 18

1. Aufgabe ______________________________________________________________ 18

2. Aufgabe ______________________________________________________________ 20

3. Aufgabe ______________________________________________________________ 21

1. Aufgabe ______________________________________________________________ 23

2. Aufgabe ______________________________________________________________ 25

3. Aufgabe ______________________________________________________________ 27

4. Aufgabe ______________________________________________________________ 29

5. Übung _________________________________________________________________ 31

1. Aufgabe ______________________________________________________________ 31

2. Aufgabe ______________________________________________________________ 32

3. Aufgabe ______________________________________________________________ 34

4. Aufgabe ______________________________________________________________ 37

6. Übung _________________________________________________________________ 39

1. Aufgabe ______________________________________________________________ 39

2. Aufgabe ______________________________________________________________ 41

3. Aufgabe ______________________________________________________________ 42

4. Aufgabe ______________________________________________________________ 43

7. Übung _________________________________________________________________ 45

1. Aufgabe ______________________________________________________________ 45

2. Aufgabe ______________________________________________________________ 46

3. Aufgabe ______________________________________________________________ 47

4. Aufgabe ______________________________________________________________ 48


4

5. Aufgabe ______________________________________________________________ 49

6. Aufgabe ______________________________________________________________ 50

7. Aufgabe ______________________________________________________________ 50

8. Aufgabe ______________________________________________________________ 51

8. Übung _________________________________________________________________ 52

1. Aufgabe ______________________________________________________________ 52

2. Aufgabe ______________________________________________________________ 55

3. Aufgabe ______________________________________________________________ 59

9. Übung _________________________________________________________________ 64

1. Aufgabe ______________________________________________________________ 64

2. Aufgabe ______________________________________________________________ 71

3. Aufgabe ______________________________________________________________ 77

10. Übung ________________________________________________________________ 79

1. Aufgabe ______________________________________________________________ 79

2. Aufgabe ______________________________________________________________ 80

3. Aufgabe ______________________________________________________________ 81

4. Aufgabe ______________________________________________________________ 82

11. Übung ________________________________________________________________ 84

1. Aufgabe ______________________________________________________________ 84

2. Aufgabe ______________________________________________________________ 85

3. Aufgabe ______________________________________________________________ 86

4. Aufgabe ______________________________________________________________ 87

5. Aufgabe ______________________________________________________________ 88

12. Übung ________________________________________________________________ 89

1. Aufgabe ______________________________________________________________ 89

2. Aufgabe ______________________________________________________________ 91

3. Aufgabe ______________________________________________________________ 94

4. Aufgabe ______________________________________________________________ 96

5. Aufgabe ______________________________________________________________ 98

6. Aufgabe _____________________________________________________________ 100

7. Aufgabe _____________________________________________________________ 102

Uebung 13_______________________________________________________________ 104

1. Aufgabe _____________________________________________________________ 104

2. Aufgabe _____________________________________________________________ 107

3. Aufgabe _____________________________________________________________ 110

4. Aufgabe _____________________________________________________________ 116

5. Aufgabe _____________________________________________________________ 118

Uebung 14_______________________________________________________________ 121


5

15. Übung _______________________________________________________________ 126

1. Aufgabe _____________________________________________________________ 126

2. Aufgabe _____________________________________________________________ 129

16. Übung _______________________________________________________________ 131

1. Aufgabe _____________________________________________________________ 131

2. Aufgabe _____________________________________________________________ 133

3. Aufgabe _____________________________________________________________ 135

4. Aufgabe _____________________________________________________________ 136

5. Aufgabe _____________________________________________________________ 137


6

Programmieren in Java 1. Übung

7

1. Übung

1. Aufgabe

Gegeben ist das folgende Programm in Quelltextform, das eine Anwendung beschreibt:

import java.lang.*;/* ErstesProgramm ist eine Applikation, die den einfachen Gebrauch von Zeichenketten aufzeigt */public class ErstesProgramm extends Object{ // Beginn der Ausfuehrung vom Programm public static void main(String args[]) { // Ausgabe auf das Standard-Ausgabegeraet System.out.println( "Das erste Programm der Vorlesung Programmieren in Java."); }}

a) Übertrage den vorliegenden Quelltext in eine Datei, die in einem für die Übung spezielleingerichteten Arbeitsverzeichnis liegen soll. Beachte, daß in diesem Verzeichnis die Datei für dieBearbeitung durch den Java-Compiler einen speziellen Namen erhalten muß. Zum Übertragendes Quellcode nutze man einen auf dem System vorhandenen Editor.

b) Nachdem die Datei mit dem Quelltext erstellt wurde, übersetze den Quellcode mit dem Java-Compiler

c) Welche Datei wurde in dem unter a) eingerichteten Arbeitsverzeichnis durch den Compiler nachfehlerfreier Übersetzung erzeugt.

ErstesProgramm.class

d) Rufe das Java-Laufzeitsystem zur Ausführung der im Arbeitsverzeichnis vorliegendenausführbaren Datei auf.


8

2. Aufgabe

Erzeuge 100 Zufallszahlen zwischen 0 und 1 und ermittle aus diesen 100 Zufallszahlen die größteZahl (das Maximum).Die Routine Math.random() aus dem Paket java.lang liefert eine (Pseudo-) Zufallszahl vom Typ doublezwischen 0 und 1. Die beiden Endwerte kommen nicht vor, die Zahlen sind ansonsten gleichmäßig imIntervall verteilt.

a) Gib den Algorithmus zur Lösung dieser Aufgabe an!

public double ermittle_Zahl (){

double zahl = 0.0;double max = 0.0;

for (int i = 0; i < 100; i++){

zahl = Math.random ();

if (max < zahl)max = zahl;

}

return max;}

b) Gib das Programm an, das eine Lösung dieser Aufgabe bereitstellt.

public class Zufallszahlen{

public static void main ( String args[] ){

double zahl = ermittle_Zahl ();

System.out.println (zahl);}

}


9

3. Aufgabe

a) Welche Ausgabe auf das Standardausgabegerät produziert das folgende Programmfragment:

for (int i = 1; i < 10; i++){

for (int j = 1; j < 10; j++)System.out.print(i * j + “ “);System.out.println();

}

1 2 3 4 5 6 7 8 92 4 6 8 10 12 14 16 183 6 9 12 15 18 21 24 274 8 12 16 20 24 28 32 365 10 15 20 25 30 35 40 456 12 18 24 30 36 42 48 547 14 21 28 35 42 49 56 638 16 24 32 40 48 56 64 729 18 27 36 45 54 63 72 81

b) Die Formatierung der vorliegende Ausgabe läßt Wünsche nach Verbesserungen aufkommen.Schreibe ein Programm, das all die Wünsche nach besserer Formatierung erfüllt.

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

int tmp = 0;

for (int i = 1; i < 10; i++){

for (int j = 1; j < 10; j++) { tmp = i * j; if ( tmp < 10 ) System.out.print( " " ); System.out.print(i * j + " "); } System.out.println();

}}}

1 2 3 4 5 6 7 8 9 2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 6 12 18 24 30 36 42 48 54 7 14 21 28 35 42 49 56 63 8 16 24 32 40 48 56 64 72 9 18 27 36 45 54 63 72 81


10

4. Aufgabe

Schreibe ein Programm, das in einer „for“-Schleife insgesamt 100 Sternchen („*“) hintereinanderausdruckt. Übergib als Kommandozeilenparameter einen „int“-Wert, der festlegt, nach wiviel Zeichenein Zeilenvorschub erfolgen soll. So soll z.B nach folgendem Aufruf „java Aufg04 25“ die folgendeBildschirmausgabe erfolgen:

****************************************************************************************************

public class Aufg04{

public static void main (String args[]){

int neueZeile = Integer.parseInt( args[0] );

for (int i = 1; i < 101; i++){

System.out.print( "*" );

if ( (i % neueZeile) == 0 )System.out.println();

}}

}

5. Aufgabe

Schreibe ein Programm, das die ganzen Zahlen von 1 bis n (n > 1) miteinander multipliziert. DasProgramm erwartet den Parameter n in der Kommandozeile und berechnet das Produkt 1*2*3*...*n.Das Resultat soll auf die Standardausgabeeinheit ausgegeben werden.



int erg = 1;int n = Integer.parseInt( args[0] );

for (int i = 1; i <= n; i++)erg *= i;

System.out.println( "Ergebnis: " + erg );}

}


11

6. Aufgabe

Schreibe ein Programm, das alle ungeraden Zahlen von 1 bis n (n > 2) addiert. Verwende dazu eine„for“-Schleife. Der Wert von „n“ übergebe als Kommandozeilenparameter an das Programm, dasResultat soll auf die Standardausgabeeinheit ausgegeben werden.

public class ungeradeZahlen{

public static void main ( String args[] ){

int n = Integer.parseInt ( args[0] );int erg = 0;

for (int i = 1; i <= n; i++){

if ( ( i % 2 ) == 1 )erg += i;

}

System.out.println( "Ergebnis: " + erg );}

}


12

2. Übung

1. Aufgabe

a) Erstelle das folgende Programm

public class WillkommensGruss{ public static void main(String args[]) { System.out.print("Herzlich Willkommen "); System.out.println(args[0]); }}

b) Was passiert, falls das vorliegende Programm ohne Angabe eines Arguments in derKommandozeile aufgerufen wird?

Das Laufzeitsystem erzeugt eine „Ausnahme (exception)“: ArrayIndexOutOfBoundsException

c) Wie kann die unter b) bestimmte Situation durch eine spezielle Behandlung abgefangen werden?

Die spezielle Behandlung ist das „exception handling“.

d) Gestalte das unter a) vorliegende Programm so, daß es die unter c) angegebene spezielleBehandlung realisiert.

class WillkommensGruss{ public static void main(String args[]) { try { System.out.println("Herzlich Willkommen " + args[0]); } catch (Exception e) { System.out.println("Herzlich Willkommen Unbekannter"); } }}

e) Überprüfe die unter d) realisierte spezielle Behandlung auf Funktionsfähigkeit.


13

2. Aufgabe

Gegeben ist im Rahmen der main()-Routine ein Datenfeld mit einer Reihe ganzzahliger Komponenten:

public class Aufg2{ public static void main(String args[]) { int x[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }; ....... }}

a) Ergänze die main()-Methode mit Anweisungen, die das mit Ganzzahlen gefüllte Datenfeld soumgestalten, daß die Zahlen, von der ersten zu letzen Komponente gesehen, eine aufsteigendeSortierung zeigen

b) Ergänze die main()-Methode durch Anweisungen, die das Datenfeld (Array) vor und nach derSortierung in einer Zeile ausgeben.

c) Wie müssen die Anweisungen für das Sortieren verändert werden, wenn das folgende Datenfeldzu sortieren ist

String x[] = {“Juergen“, “Hubert“, “Josef“, “Liesel“, “Vera“, “Christian“};

public class Aufg2{ public static void main(String args[]) { int x[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }; int i; System.out.println("Vor dem Sortieren:"); for (i = 0; i < x.length;i++) { System.out.print(x[i] + " "); } System.out.println(); int j;

for (i = 0; i < x.length; i++) { for (j = i + 1; j < x.length; j++) { if (x[i] > x[j]) // if (x[i].compareTo(x[j]) > 0) { int temp = x[i]; // String temp = x[i] x[i] = x[j]; x[j] = temp; } } } // Nach dem Sortieren for (i = 0; i < x.length; i++) { System.out.print(x[i] + " "); } System.out.println(); }}


14

3. Aufgabe

a) Stelle aus der Java-API-Dokumentation die Operatoren für ganzzahlige Arithmetik (Datentyp: int)zusammen

b) Schreibe eine Applikation, die zwei ganze Zahlen auf der Ebene der Befehlszeile einliest undanschließend mit diesen beiden Zahlen alle binären und unären Operationen auf ganzen Zahlenausführt. Die Demonstration binärer und unärer Arithmetik mit ganzen Zahlen soll den NamenIntDemo tragen.Aus der Befehlszeile können ganzen Zahlen über

int i = Integer.valueOf(args[0]).intValue();int j = Integer.valueOf(args[1]).intValue();

konvertiert werden.

(Quell-Code siehe unten)

c) Was passiert, wenn nach fehlerfreier Übersetzung java IntDemo aufgerufen wird

java.lang.ArrayIndexOutOfBoundsException

d) Wie kann dieser Fehler aufgefangen werden?

Durch einen try-catch-Block .

e) Erweitere das vorliegende Programm um diese Fehlerbehandlungsroutine.

(Quell-Code siehe unten)

f) Erweitere das vorliegende Programm durch die Berechnung von 1/0. Führe das Programmanschließend aus. Welches Resultat ergibt sich für 1/0.

/ by zero


15

public class IntDemo{

public static void main(String args[]) { try { // Konvertieren int i = Integer.valueOf(args[0]).intValue(); int j = Integer.valueOf(args[1]).intValue(); // Ausgabe der ueber die Befehlszeile eingegebenen Zahlen System.out.println("i = " + i); System.out.println("j = " + j); // Binaere Arithmetik mit den Operatoren + - * / % int n; n = i + j; System.out.println("n = i + j = " + n); n = i - j; System.out.println("n = i - j = " + n); n = i * j; System.out.println("n = i * j = " + j); n = i / j; System.out.println("n = i / j = " + n); n = i % j; System.out.println("n = i % j = " + n); // Unaere Arithmetik mit Inkrement- / Dekrementoperator i++; System.out.println("Nach i++: i = " + i); j--; System.out.println("Nach j--: j = " + j); n = i++; System.out.println("Nach n = i++: n = " + n + ", i = " + i); n = ++i; System.out.println("Nach n = ++i: n = " + n + ", i = " + i); System.out.println("i = " + i); System.out.println("j = " + j); n = ++i + j--; System.out.println("Nach n = ++i + j--: n = " + n + ", i = " + i + " j = " + j); System.out.println("i = " + i); System.out.println("j = " + j); n = i + j * ++j; System.out.println("Nach n = i + j * ++j: n = " + n + ", i = " + i + j = " + j); i = 1; j = 0; System.out.println("i = " + i); System.out.println("j = " + j); n = i / j; System.out.println("n = i / j = " + n); } catch(Exception e) { System.out.println("Fehler bei der Eingabe: java a b"); System.out.println(e.getMessage()); } }}


16

4. Aufgabe

Gib über die Kommandozeile eine natürliche Zahl ein. Das über die Kommandozeile ebenfallsaufzurufende Programm soll den kleinsten Teiler der natürlichen Zahl bestimmen und angeben. Fallskein Teiler existiert, soll ausgegeben werden, daß die Zahl eine Primzahl ist.


public static void main(String args[]){

int eingabe = Integer.valueOf(args[0]).intValue();int kleinsterTeiler = eingabe;

if ((eingabe % 2) == 0){

System.out.println("Kleinster Teiler: 2");}else{

for (int i = (eingabe - 1); i > 2; i--){

if ((eingabe % i) == 0)kleinsterTeiler = i;

}

System.out.println ("Kleinster Teiler: " + kleinsterTeiler);}

}}


17

5. Aufgabe

Schreibe ein Programm zur Berechnung der Iterationsvorschrift:

x(n+1) = (x(n) + 2/x(n)) / 2x(0) = 2

Die Vorschrift wird häufig für die Berechnung von 2 herangezogen. Bestätige durch das Programm,das dies korrekt ist.



double x = 2.0;double x1 = 0.0;int n = 0;

try{

n = Integer.parseInt( args[0] );}catch (Exception ex){

System.out.println("Fehler bei der Eingabe: java n");System.out.println(ex.getMessage());

}

for (int i = 1; i <= n; i++){

x1 = ( x + 2 / x ) / 2;x = x1;

}

System.out.println( "Ergebnis: " + x1 );}

}


18

3. Übung

1. Aufgabe

Entwicklung einer Applikation zur Demonstration der Wirkungsweise einer for-Schleife.

a) Über die Kommandozeile soll eine Gleitpunktzahl a (Datentyp double) und eine ganze Zahl n(Datentyp int) eingelesen werden. Mit Hilfe einer for-Schleife soll an berechnet und ausgegebenwerden. Zu beachten ist, daß ganze Zahlen auch negativ sein können.

b) Gegeben ist der Vektor double x[] = { 1.0, 2.0, 3.0 }; . Gib diesen Vektor auf dieStandard-Ausgabeeinheit in folgender Weise aus:

Vektor x:( 1.0, 2.0, 3.0 )

c) Gegeben ist die Matrix

double m[][] = { { -1.0, -2.0, -3.0 }, { 0.0, 1.0, 0.0 }, { 1.0, 2.0, 3.0 } };

Gib die Matrix auf die Standard-Ausgabeeinheit in folgender Weise aus

Matrix M:( -1.0, -2-0, -3.0 )( 0.0, 1.0, 0.0 )( 1.0, 2.0, 3.0 )

public class ForDemo extends Object{ public static void main(String args[]) { // double a = 2.0; double a = Double.valueOf(args[0]).doubleValue(); // int n = 10; int n = Integer.valueOf(args[1]).intValue(); System.out.println("a = " + a); System.out.println("n = " + n); int absn; if (n >= 0) { absn = n; } else { absn = -n; } double aHochn = 1.0; for (int i = 1; i <= absn; i++) { aHochn = aHochn * a; } if (n < 0) { aHochn = 1.0 / aHochn; } System.out.println("aHochn = " + aHochn);


19

double x[] = { 1.0, 2.0, 3.0 }; System.out.println("Vektor x:"); for (int i = 0; i < 3; i++) { if (i == 0) { System.out.print("( "); } else { System.out.print(", "); } System.out.print(x[i]); } System.out.println(" )"); double m[][] = { { -1.0, -2.0, -3.0 }, { 0.0, 1.0, 0.0 }, { 1.0, 2.0, 3.0 } }; System.out.println("Matrix M:"); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (j == 0) { System.out.print("( "); } else { System.out.print(", "); } System.out.print(m[i][j]); } System.out.println(" )"); } }}


20

2. Aufgabe

a) Schreibe ein Programm, das ganze Zahlen von –2 bis +2 bestimmt und dividiert, d.h. –2/-2, -1/-1, 0/0, 1/1, 2/2 berechnet und das Ergebnis auf die Standard-Ausgabeeinheit ausgibt.

(siehe unten)

b) Welche spezielle Ausnahmesituation tritt bei der Ausführung des unter a) ermittelten Programmsauf?

java.lang.ArithmeticException: / by zero

c) Wie kann die unter b) bestimmte Situation durch eine spezielle Behandlung abgefangen werden?

try-catch-Block

c) Gestalte das unter a) vorliegende Programm so, daß es die unter c) angegebene spezielleBehandlung realisiert.

(siehe unten)

e) Überprüfe die unter d) realisierte spezielle Behandlung auf Funktionsfähigkeit.

import java.lang.*;

public class TryCatchDemo extends Object{ public static void main(String args[]) { int n;

for (int i = -2; i <= 2; i++) { System.out.println("i = " + i);

// n = i / i; // System.out.println("n = i / i = " + n);

try { n = i / i; System.out.println("n = i / i = " + n); } catch ( ArithmeticException e) { System.out.println("ArithmeticException!"); } } }}


21

3. Aufgabe

a) Stelle aus der Java-API-Dokumentation die Operatoren für Arithmetik von Gleitpunktzahlen(Datentyp: double) zusammen.

b) Schreibe eine Applikation, die zwei ganze Zahlen auf der Ebene der Befehlszeile einliest undanschließend mit diesen beiden Zahlen alle binären und unären Operationen auf ganzen Zahlenausführt. Die Demonstration binärer und unärer Arithmetik mit ganzen Zahlen soll den NamenDoubleDemo tragen.

Aus der Befehlszeile können ganzen Zahlen über

double x = Double.valueOf(args[0]).doubleValue();double y = Double.valueOf(args[1]).doubleValue();

konvertiert werden.

c) Berechne 1.0/0.0, -1.0/0.0, 0.0/0.0, -0.0/0.0, 1.0/0.0 + 2.0, -1.0/0.0 + 2.0,0.0/0.0 + 2.0, -0.0 + 2.0 im Rahmen des vorliegenden Programms.

public class DoubleDemo{ public static void main(String args[]) { try { // Konvertieren double x = Double.valueOf(args[0]).doubleValue(); double y = Double.valueOf(args[1]).doubleValue(); // Ausgabe der ueber die Befehlszeile eingegebenen Zahlen System.out.println("x = " + x); System.out.println("y = " + y); // Binaere Arithmetik mit den Operatoren + - * / double z; z = x + y; System.out.println("z = x + y = " + z); z = x - y; System.out.println("z = x - y = " + z); z = x * y; System.out.println("z = x * y = " + z); z = x / y; System.out.println("z = x / y = " + z); // Unaere Arithmetik mit Inkrement- / Dekrementoperator x++; System.out.println("Nach x++: x = " + x); y--; System.out.println("Nach y--: y = " + y); z = x++; System.out.println("Nach z = x++: z = " + z + ", x = " + x); z = ++x; System.out.println("Nach z = ++x: z = " + z + ", x = " + x); System.out.println("x = " + x); System.out.println("y = " + y); z = ++x + y--; System.out.println("Nach z = ++x + y--: z = " + z + ", x = " + x + " y = " + y); System.out.println("x = " + x); System.out.println("y = " + y); z = x + y * ++y; System.out.println("Nach z = x + y * ++y: z = " + z + ", x = " + x + " y = " + y);


22

z = 1.0 / 0.0; System.out.println("z = 1.0 / 0.0 = " + z); z = -1.0 / 0.0; System.out.println("z = -1.0 / 0.0 = " + z); z = 0.0 / 0.0; System.out.println("z = 0.0 / 0.0 = " + z); z = -0.0 / 0.0; System.out.println("z = -0.0 / 0.0 = " + z); z = 1.0 / 0.0 + 2.0; System.out.println("z = 1.0 / 0.0 + 2.0 = " + z); z = -1.0 / 0.0 + 2.0; System.out.println("z = -1.0 / 0.0 + 2.0 = " + z); z = 0.0 / 0.0 + 2.0; System.out.println("z = 0.0 / 0.0 + 2.0 = " + z); z = -0.0 / 0.0 + 2.0; System.out.println("z = -0.0 / 0.0 + 2.0 = " + z); } catch(Exception e) { System.out.println("Fehler bei der Eingabe: java a b"); System.out.println(e.getMessage()); } }}


23

4. Übung

1. Aufgabe

Die folgende Darstellung zeigt ein Fenster, das einem Applet zugeordnet ist.

Das Fenster zeigt verschiedene Schriften. Schriftart, Stil und Größe ist in der jeweiligen Ausgabezeileim Fenster vermerkt.

a) Schreibe das zugehörige Applet, das das vorliegende Fenster mit den unterschiedlichen Schriftenproduziert.

import java.awt.Font;import java.awt.Graphics;

public class Aufg1 extends java.applet.Applet{ public void paint(Graphics g) { Font f = new Font("TimesRoman",Font.PLAIN,18); Font fb = new Font("TimesRoman",Font.BOLD,18); Font fi = new Font("TimesRoman",Font.ITALIC,18); Font fbi = new Font("TimesRoman", Font.BOLD + Font.ITALIC,18); Font f2 = new Font("Arial",Font.PLAIN,10); Font f2b = new Font("Courier",Font.BOLD,12); Font f2i = new Font("Arial",Font.ITALIC,30); g.setFont(f); g.drawString( "Nomaler (plain) Font (TimesRoman) in Schriftgroesse 18", 10,25); g.setFont(fb); g.drawString( "Fetter Font (TimesRoman) in Schriftgroesse 18", 10,50); g.setFont(fi); g.drawString( "Kursiver (italic) Font (TimesRoman) in Schriftgroesse 18", 10,75); g.setFont(fbi); g.drawString( "Fetter und Kursiver Font (TimesRoman) in Schriftgroesse 18",


24

10,100); g.setFont(f2); g.drawString( "Normaler Font (Arial) in Schriftgroesse 10", 10,125); g.setFont(f2b); g.drawString( "Fetter Font (Courier) in Schriftgroesse 12", 10,150); g.setFont(f2i); g.drawString( "Kursiver Font (Arial) in Schriftgroesse 30", 10,180); }}

b) Gib die für die Anzeige des Fensters in einem „Java“-fähigen Web-Browser oder über den„appletviewer“ nötige „HTML“-Datei an.

<HTML><HEAD><TITLE>1. Aufgabe</TITLE></HEAD><BODY><APPLET CODE="Aufg1.class" WIDTH=600 HEIGHT=200></APPLET></BODY></HTML>

c) Teste das unter a) entwickelte Applet mit dem „appletviewer“ bzw. einem „Java“-fähigen Web-Browser.


25

2. Aufgabe

Der Spruch „Aller Anfang ist schwer!“ soll mit Hilfe eines Applets in dem zu dem Applet zugeordnetenFenster dargestellt werden. Die Darstellung soll folgende Gestalt annehmen.

a) Bestimme den Quellcode zu diesem Applet, das die vorliegende Darstellung über einen Web-Browser bzw. einen „Appletviewer“ ermöglicht. Die Abmessungen des Fensters, des Ovals imFenster und des Texts sollen der Abbildung entnommen werden.

import java.applet.*;import java.awt.*;

public class Aufg2 extends Applet{ Font f; String spruch;

public void init() { f = new Font("Helvetica",Font.BOLD,24); this.spruch = "Aller Anfang ist schwer!"; }

public void paint(Graphics g) { // Oval mit Farbe yellow g.setColor(Color.yellow); g.fillOval(10,10,330,100); // Roter Rahmen; da Java keine Linienbreite kennt, // wird die Linienbreite durch 4 Ovale, (die sich // um Pixelbreite unterscheiden,) simuliert g.setColor(Color.red); g.drawOval(10,10,330,100); g.drawOval( 9, 9,332,102); g.drawOval( 8, 8,334,104); g.drawOval( 7, 7,336,106); g.setColor(Color.black); g.setFont(f); g.drawString(this.spruch,40,70); }}


26

b) Erstelle die zugehörige HTML-Datei, die das Applet zur Darstellung mit einem Web-Browser bzw.„appletviewer“ benötigt.

<HTML><HEAD><TITLE>2. Aufgabe </TITLE></HEAD><BODY><CENTER><APPLET CODE="Aufg2.class" WIDTH=350 HEIGHT=125></APPLET></CENTER></BODY></HTML>

c) Überprüfe die Lösung zu dieser Aufgabe durch einen Test mit dem „appletviewer“ oder einem„Java“-fähigen Web-Browser.


27

3. Aufgabe

a) In dem einem Applet zugeordneten Fenster soll der Buchstabe „F“, wie die folgende Abbildungzeigt, abgebildet werden:

Die Abmessungen des Fensters, die Konstruktionsmaße zur Darstellung des Buchstabens sollender folgenden Abbildung direkt entnommen werden. In der oberen, linken Ecke des Fenstersbefindet sich der Bezugspunkt.


28

1) Bestimme den Quellcode zu dem Applet, das die vorliegende Darstellung über einen Web-Browser bzw. „appletviewer“ ermöglicht.

import java.awt.Font;import java.awt.Graphics;

public class Aufg3 extends java.applet.Applet{ public void paint(Graphics g) { int feldX[] = { 50, 50, 120, 120, 80, 80, 100, 100, 80, 80 }; int feldY[] = {170, 40, 40, 70, 70, 100, 100, 130, 130, 170 }; g.drawPolygon(feldX, feldY, feldX.length); }}

2) Erstelle die „zugehörige“ HTML-Datei.


3) Überprüfe die Lösung zu dieser Aufgabe durch eine Implementierung


29

b) Die Darstellung soll farbig ausgestattet werden. Der Hintergrund des Bildes soll gelb (Größe: 200x 200 Pixel), der Buchstabe „F“ rot ausgefüllt werden. Schreibe dazu das zugehörige Applet undüberprüfe es anschließend mit dem „appletviewer“ bzw. einem „Java“-fähigen Web-Browser.

import java.awt.Font;import java.awt.Color;import java.awt.Graphics;

public class Aufg3 extends java.applet.Applet{ public void paint(Graphics g) { int feldX[] = { 50, 50, 120, 120, 80, 80, 100, 100, 80, 80 }; int feldY[] = {170, 40, 40, 70, 70, 100, 100, 130, 130, 170 }; g.setColor(Color.yellow); g.fillRect(0,0,200,200); g.setColor(Color.red); g.fillPolygon(feldX, feldY, feldX.length); }}

4. Aufgabe

Die in der HTML-Datei im Applet-Tag angegebene Größe eines Fensters kann über die MethodegetSize() der im Paket java.awt befindlichen Klasse Dimension bestimmt werden, z.B.:

Dimension d = getSize(); hoehe = d.height; breite = d.width;

Zeige mit Hilfe von zwei verschiedenen Applets, welcher Unterschied in der Darstellung von

a) drawRect(0,0,breite,hoehe);

bzw.

b) drawRect(0,0,breite – 1, hoehe – 1);

im jeweiligen Applet-Fenster besteht.


30

a) import java.applet.*;import java.awt.*;

public class Aufg4 extends Applet{ int hoehe, breite; public void init() { // Wie gross ist das Applet Dimension d = getSize(); hoehe = d.height; breite = d.width; repaint(); } public void paint(Graphics g) { g.drawRect(0,0,breite,hoehe); }}


b) import java.applet.*;import java.awt.*;

public class Aufg4b extends Applet{ int hoehe, breite; public void init() { // Wie gross ist das Applet Dimension d = getSize(); hoehe = d.height; breite = d.width; repaint(); } public void paint(Graphics g) { g.drawRect(0,0,breite-1,hoehe-1); }}

<HTML><HEAD><TITLE>4. Aufgabe</TITLE></HEAD><BODY><APPLET CODE="Aufg4b.class" WIDTH=300 HEIGHT=300></APPLET></BODY></HTML>


31

5. Übung

1. Aufgabe

In einem HTML-File können Parameter angegeben werden, die in einem Applet ausgewertet können,z.B.

<APPLET CODE="Aufg1.class" WIDTH=350 HEIGHT=150><PARAM NAME=name VALUE="Nobody"></APPLET>

Parameterangaben in einem HTML-File bestehen demnach aus Name und Wert. Im Applet kann derParamter hier mit „name“ angesprochen werden und sein Wert überprüft werden (z.B. auf „null“).

a) Schreibe ein HTML-File, das den zuvor als Parameter angegebenen Parameter enthält.

<HTML><HEAD><TITLE>1. Aufgabe</TITLE></HEAD><BODY><APPLET CODE="Aufg1.class" WIDTH=350 HEIGHT=150><PARAM NAME=name VALUE="Nobody"></APPLET></BODY></HTML>

b) Schreibe ein Applet, das überprüft, ob der Parameter „name“ einen Wert besitzt. Falls er einenWert besitzt, zeige ihn, wie die vorliegende Darstellung zeigt, an. Im anderen Fall gib irgend etwasanderes aus.


32

import java.awt.*;

public class Aufg1 extends java.applet.Applet{ Font f; String name; public void init() { f = new Font("Helvetica",Font.BOLD,48); this.name = getParameter("name"); if (this.name == null) { this.name = "Juergen"; } this.name = "Hallo " + this.name; } public void paint(Graphics g) { // Oval mit Farbe pink g.setColor(Color.pink); g.fillOval(10,10,330,100); // Roter Umfassungsrahmen, da Java keine Linienbreite // verarbeitet, wird die Linienbreite durch 4 Ovale // unterschliedlicher Pixelbreite simuliert g.setColor(Color.red); g.drawOval(10,10,330,100); g.drawOval(9,9,332,102); g.drawOval(8,8,334,104); g.drawOval(7,7,336,106); // Textausgabe g.setColor(Color.black); g.setFont(f); g.drawString(this.name,30,75); }}

2. Aufgabe

Die folgende Darstellung zeigt das Fenster eines Applets und gibt eine Kaffeetasse wieder:


33

Bei genauer Betrachtung sieht man, daß diese Darstellung sich aus Ellipsen und Bögenzusammensetzt.

a) Schreibe ein Applet, das diese Darstellung realisiert. Die Abmessungen der Tasse (für die Bögenbzw. Ellipsen) können frei gewählt werden, es soll nur eine möglichst große Ähnlichkeit zumvorliegenden Bild erreicht werden.

import java.awt.*;

public class Aufg2 extends java.applet.Applet{

public void paint(Graphics g) { Dimension d = getSize(); g.setColor(Color.yellow); g.fillRect(0,0,d.width-1,d.height-1); // Zeichnen der Tasse // Blaue Untertasse g.setColor(Color.blue); // fillOval(x,y,hoehe,breite) g.fillOval(10,110,150,40); g.setColor(Color.black); // drawOval(x,y,hoehe,breite) g.drawOval(10,110,150,40); g.drawOval(60,122,50,16); // rote Tasse g.setColor(Color.red); // Henkel // drawArc(x,y,hoehe,breite,startwinkel,bogen) g.drawArc(130,30,40,50,-120,210); g.fillArc(20,-70,130,200,180,180); g.setColor(Color.black); g.fillOval(20,20,130,20); // Beschriftung g.drawString("Kaffetasse",60,170); }}

b) Erstelle das zugehörige HTML-File.




34

3. Aufgabe

a) Schreibe ein Applet, das das folgende, 6 Ecken umfassende, regelmäßige Polygon zeichnet.

Die Darstellung des Polygons geht zweckmäßigerweise von der Mitte des Fensters aus:

Alle Eckpunkte des Polygons liegen auf einem Kreis, der hier den Radius 60 haben soll, undlassen sich mit Hilfe der trigonometrischen Funktionen bestimmen.


35

import java.awt.*;

public class Aufg3 extends java.applet.Applet{ // Instanzvariable private int eckenAnz = 6; private int radius = 60; private Dimension s; private int xKoord[]; private int yKoord[];

// Methoden public void init() { s = getSize();

xKoord = new int[eckenAnz]; yKoord = new int[eckenAnz]; for (int i = 0; i < eckenAnz; i++) { xKoord[i] = (int) (s.width / 2 + radius * Math.cos(i * 2 * Math.PI / eckenAnz)); yKoord[i] = (int) (s.height / 2 + radius * Math.sin(i * 2 * Math.PI / eckenAnz)); } }

public void paint(Graphics g) { g.setColor(Color.white); g.fillRect(0,0,s.width,s.height); g.setColor(Color.black); g.drawPolygon(xKoord, yKoord, eckenAnz);}}

b) Gib das zugehörige HTML-File an.




36

d) Erweitere das unter a) angegebene Applet so, wie es die folgende Abbildung zeigt.

Das Polygon soll jetzt 12 Ecken haben und jeder Eckpunkt des Polygon ist jetzt mit jedemanderen Eckpunkt des Polygons verbunden.

import java.awt.*;

public class Aufg3 extends java.applet.Applet{ // Instanzvariable private int eckenAnz = 12; private int radius = 60; private Dimension s; private int xKoord[]; private int yKoord[];

// Methoden public void init() { s = getSize();

xKoord = new int[eckenAnz]; yKoord = new int[eckenAnz]; for (int i = 0; i < eckenAnz; i++) { xKoord[i] = (int) (s.width / 2 + radius * Math.cos(i * 2 * Math.PI / eckenAnz)); yKoord[i] = (int) (s.height / 2 + radius * Math.sin(i * 2 * Math.PI / eckenAnz)); } }

public void paint(Graphics g) { g.setColor(Color.white); g.fillRect(0,0,s.width,s.height); g.setColor(Color.black); g.drawPolygon(xKoord, yKoord, eckenAnz);

for (int i = 0; i < eckenAnz; i++) for (int j = 0; j < eckenAnz; j++) g.drawLine(xKoord[i], yKoord[i], xKoord[j], yKoord[j]);

}}


37

4. Aufgabe

a) Schreibe ein Applet, das die folgende Rosette zeichnet.

import java.awt.*;

public class Aufg4 extends java.applet.Applet{

/* Abmessungen des Fensters */ private static int hoehe; private static int breite;

/* Applet-Verarbeitungsmethoden */ public void init() { Dimension d = getSize(); hoehe = d.height - 1; breite = d.width - 1; }

public void paint(Graphics g) { g.setColor(Color.yellow); g.fillRect(0,0,breite,hoehe); g.setColor(Color.black); double b; int rx = breite / 2; int ry = hoehe / 2;


38

for (int i = 0;i < 360; i++) { b = i * Math.PI / 180; int x = (int) (breite / 2 * Math.sin(12*b)); int y = (int) (hoehe / 2 * Math.sin(12*b)); int rx1 = (int)(breite/2 + (x * Math.cos(b))); int ry1 = (int)(hoehe/2 + (y * Math.sin(b))); g.drawLine(rx,ry,rx1,ry1); rx = rx1; ry = ry1; } }}

b) Erstelle das zugehörige HTML-File.




39

6. Übung

1. Aufgabe

Es soll ein Applet geschrieben werden, das folgende Darstellung in seinem Fenster anzeigt:

Wie die Abbildung zeigt handelt es sich um ein Schachbrett, das aus sog. 3D-Rechtecken (Quadraten)besteht. Die Positionierung des Schachbretts soll abhängig von der Größe des Fensters erfolgen, dieeinzelnen 3D-Quadrate haben eine Größe von 40 Pixel. Auf dem Schachbrett sind 8 Damenpositioniert. Die Symbole zu den 8 Damen sind aus Polygone aufgebaut. Das zu schreibende Appletsoll die vorliegende Abbildung möglichst genau wiedergeben.

import java.awt.*;import java.applet.*;

public class Aufg1 extends Applet{ static final int N = 8; static final int GROESSE = 40; static int x_offset, y_offset; static int qx[] = { 4, 8, 32, 36, 31, 28, 24, 20, 16, 12, 9, 4, }; static int qy[] = { 19, 34, 34, 19, 24, 13, 22, 4, 22, 13, 24, 19, }; static int qxx[] = { 8, 17, 20, 23, 32, }; static int qyy[] = { 31, 31, 27, 31, 31, }; Dimension d;


40

public void init() { d = getSize(); }

public void paint( Graphics g ) { holOffsets(); zeichneBrett(g); zeichneAlleDamen(g); }

void holOffsets() { x_offset = (d.width - (N * GROESSE)) / 2; y_offset = (d.height- (N * GROESSE)) / 2 - 10; }

void zeichneBrett( Graphics g ) { g.setColor( Color.lightGray ); g.fillRect( 0, 0, d.width, d.height ); g.setColor( Color.lightGray ); g.draw3DRect( x_offset-2, y_offset-2, N*GROESSE+3, N*GROESSE+3, true ); g.draw3DRect( x_offset-3, y_offset-3, N*GROESSE+5, N*GROESSE+5, true ); g.draw3DRect( x_offset-4, y_offset-4, N*GROESSE+7, N*GROESSE+7, true ); for( int j=0; j < N; j++ ) { for( int i=0; i < N; i++ ) { if ((i + j) % 2 == 1) g.setColor(Color.red); else g.setColor(Color.lightGray); g.fillRect( x_offset + i*GROESSE, y_offset + j*GROESSE, GROESSE, GROESSE ); } } }

void zeichneAlleDamen( Graphics g ) { for( int i = 0; i < N; i++ ) { zeichneEineDame(g, x_offset+GROESSE*i, y_offset+GROESSE*(N - i - 1) ); } }

void zeichneEineDame(Graphics g, int x, int y ) { g.translate( x, y ); g.setColor( Color.white ); g.fillPolygon( qx, qy, qx.length ); g.setColor( Color.black ); g.drawPolygon( qx, qy, qx.length ); g.drawPolygon( qxx, qyy, qxx.length ); g.translate( -x, -y ); }}


41

2. Aufgabe

a) Schreibe eine Java-Anwendung, die die Initialisierungswerte primitiver Typen anzeigt.Hinweis zur Lösung: Instanzvariable erhalten standardmäßig Initialisierungswerte zugeordnet.

class Messung{ // Instanzvariable boolean t; char z; byte b; short k; int i; long l; float f; double d;

// Instanzmethoden void ausgabe() { System.out.println( "Datentyp Initialisieungwert\n" + "boolean " + t + "\n" + "char " + z + "\n" + "byte " + b + "\n" + "short " + k + "\n" + "int " + i + "\n" + "long " + l + "\n" + "float " + f + "\n" + "double " + d + "\n"); }

/* Anzeige der standardmaessig zugeordneten Initialisierungswerte*/

public class Initialisierungswerte{ public static void main(String[] args) { Messung m = new Messung(); m.ausgabe(); // auch moeglich: new Messung().ausgabe(); }}


42

3. Aufgabe

1. Welche Ausgaben zeigen die folgenden Anwendungen?

a)

public class Gleichheit{ public static void main(String[] args) { Integer n1 = new Integer(13); Integer n2 = new Integer(13); System.out.println(n1 == n2); }}

false

b)

public class GleichMethode{ public static void main(String[] args) { Integer n1 = new Integer(13); Integer n2 = new Integer(13); System.out.println(n1.equals(n2)); }}

true

c)

class Wert{ int i;}public class GleichMethode2{ public static void main(String[] args) { Wert w1 = new Wert(); Wert w2 = new Wert(); w1.i = w2.i = 100; System.out.println(w1.equals(w2)); }}

false

2. Implementiere die drei Anwendungen und überprüfe die unter a) bis c) angegebene Vorhersage.


43

4. Aufgabe

a) Schreibe ein Programm, das Primzahlen (von der Primzahl 2 an) ermittelt.

Was ist eine Primzahl? Eine Primzahl ist eine natürliche Zahl, die genau zwei verschiedene Teilerbesitzt (1 und sich selbst). Die Zahl ist 1 ist keine Primzahl, weil sie keine zwei verschiedeneTeiler besitzt. Nach dieser Definition ist die Zahl 2 die kleinste Primzahl. Weiter geht es mit 3, 5, 7,11, ...Wie findet man eine Primzahl? Man teilt die primzahlverdächtigen Zahlen durch alle Zahlen von 2ab bis kurz vor der Zahl selbst. War die Zahl nie teilbar, dann ist sie eine Primzahl, anderenfallsnicht. Primzahlen startet man mit der Zahl 2 und wiederholt das Verfahren so oft, bis diegewünschte Zahl erreicht wurde.Wie kann man den vorliegenden Algorithmus verbessern?

(1) Scheide alle geraden Zahlen aus, denn sie sind garantiert durch 2 teilbar(2) Teile die so verbliebenen Zahlen mindestes durch Divisor 3(3) Teile nur durch Primzahlen als Divisoren, denn jede Nichtprimzahl läßt sich als Produkt von

Primzahlen aufbauen(4) Gehe mit den Primzahldivisoren nur bis höchstens zur Wurzel aus der primzahlverdächtigen

Zahl. Warum? 25 ist bspw. 5 * 5, d.h. weiteres Probieren über 5 ist sinnlos.

b) Die Anzahl der zu ermittelten Primzahlen (erste Primzahl ist 2) soll per Default 100 sein. Ist einedavon abweichende Größe gewünscht, so soll das über die Kommandozeile bestimmt werdenkönnen.

c) Die so ermittelten Primzahlen sollen in einen Array ausgegeben werden. Die in diesem Arraygespeicherten Primzahlen sollen auf der Standardausgabeeinheit protokolliert werden. Dabeisollen jeweils 12 Primzahlen je Zeile angezeigt werden.

import java.lang.*;

class Primzahlen{ private int start; public int zaehler = 100;

// Konstruktor mit einem Argument public Primzahlen(int sta) { start = sta; }

private boolean istPrimzahl(int p) { int i;

for (i = 2; i < (p / 2); i++) { if ( (i * (p / i)) == p) return false; }

return true; }


44

public void erzeuge(int feld[]) { int sta = start; int z = zaehler; int idx = 0;

while (z > 0) { if (istPrimzahl(sta)) { feld[idx++] = sta; z--; }

if (sta == 2) sta++; else sta = sta + 2; } }}

public class Aufg4{ public static void main(String args[]) { Primzahlen p; int feldP[]; int laenge; int sta = 2; int zaehler = 0; laenge = args.length;

p = new Primzahlen(sta);

if (laenge > 0) { zaehler = Integer.parseInt(args[0]); p.zaehler = zaehler; }

feldP = new int[p.zaehler]; p.erzeuge(feldP);

for (int i = 0; i < p.zaehler; i++) { System.out.print(feldP[i] + " ");

if (i == 0) continue;

if ((i % 12) == 0) System.out.println();

} }}


45

7. Übung

1. Aufgabe

Schreibe ein Programm, das Methoden zum Berechnen der Fakultät enthält und aufruft. DieBerechnung der Fakultät soll

a) iterativb) rekursiv

erfolgen. Die Ausgabe soll jeweils die Fakultät der Zahlen 1 bis 10 zeigen.

public class FakultaetTest extends Object{ public static void main(String args[]) { int n; int i; long resultat;

for (i = 1; i <= 10; i++) { resultat = fakit(i); System.out.println(i + "!= " + resultat); }

for (i = 1; i <= 10; i++) { resultat = fakrek(i); System.out.println(i + "!= " + resultat); }

for (i = 1; i <= 10; i++) { resultat = fakultaet(i); System.out.println(i + "!= " + resultat); }

System.out.println(-1 + "!= " + fakit(-1)); System.out.println(-1 + "!= " + fakultaet(-1));

}

public static long fakit(int n) { int i; // Lokale Variable long resultat = 1; // Lokale Variable if (n < 0) return -1;

for (i = 1; i <= n; i++) { resultat *= i; }

return resultat; // Rueckgabewert

}


46

public static long fakrek(int n) { if (n == 0) { return 1; } else { return n * fakrek(n - 1); } }

public static long fakultaet(int n) { if (n < 0) { return -1; } else if (n == 0) { return 1; } else { return n * fakrek(n - 1); } }}

2. Aufgabe

a) Schreibe ein Java-Programm, das die Zahl e ermittelt. Zur Berechnung der Zahl e verwende dieTaylor-Reihe.

b) Vergleiche das unter a) erhaltene Ergebnis mit der Konstanten Math.E

public class Zahle{ public static void main(String [] args) { double g = 1.; double s = 1.;

for (int i = 1; i <= 15; i++) { g = g / i; s = s + g; System.out.println("i = " + i + " s = " + s); }

System.out.println("Die Konstante Math.E hat den Wert " + Math.E); }}


47

3. Aufgabe

Schreibe ein Programm, das über die folgenden Summe

die Zahl ln2 berechnet.

public class LN2 extends Object{ public static double ln2() { double res = 1; short vorz = -1;

for (int i = 2; i <=10000; i++) { res += 1. / i * vorz; vorz *= -1; System.out.println(res); }

return res; }

public static void main(String args[]) { System.out.println("Natuerlicher Logarithmus von 2: " + ln2()); }

}

∑∞

=

+ ⋅−1

1 1)1(

n

n

n


48

4. Aufgabe

Schreibe ein Programm, das folgende Ausgabe auf dem Bildschirm erzeugt:

* *** ***** ******* ********************

public class SternchenDreieck{ public static void main(String[] args) { final int N = 10; int i; int j;

for (i = 0; i < N; i++) { for (int k = 1; k < N - i; k++) System.out.print(" ");

for (j = 0; j < i * 2 -1; j++) System.out.print("*");

System.out.println(); } }}


49

5. Aufgabe

Alle Glieder einer Fibonacci-Folge, deren Werte eine feste Größe „MAXWERT“ nicht überschreitet,soll berechnet werden. In der Fibonacci-Folge 1, 1, 2, 3, 5, 8, 13, .... kann ab dem 3 Glied jedesweitere Glied aus der Summe der beiden vorhergehenden Glieder berechnet werden. Die Ausgabeder Folge soll so erfolgen:

*********************************

MAXWERT soll den Wert 30 besitzen.

public class ZeigeFibo{ public static void main(String[] args) { final int MAXWERT = 30; int a; int b; int c; a = 1; b = 1;

System.out.println("*");

do { for (int i = 1; i <= b; i++) System.out.print("*");

System.out.println();

c = a + b; a = b; b = c; } while (c < MAXWERT); }}


50

6. Aufgabe

Schreibe ein Programm, daß alle 3 Ziffern umfassenden Zahlen ausgibt, die gleich der Summe ihrer

zur 3. Potenz erhobenen Ziffern ist, z.B. 153 1 5 33 3 3= + +

public class DrittePotenz{ public static void main(String[] args) { for (int i = 0; i <= 9; i++) for (int j = 0; j <= 9; j++) for (int k = 0; k <= 9; k++) if (((i*i*i) + (j*j*j) + (k*k*k)) == (i * 100 + 10 * j + k)) { int resultat = i * 100 + 10 * j + k; System.out.println(resultat); } }}

7. Aufgabe

Schreibe ein Programm, das eine rekursive Funktion "gibausVertikal" enthält, die ganze Zahlenvertikal auf dem Bildschirm ausgibt- Falls die Zahl negativ ist, dann soll oben das Zeichen "-" stehen.Der Aufruf von bspw. gibausVertikal(-361) soll zu der folgenden Ausgabe führen

-361

Der Aufruf von bspw. gibausVertikal(1234) führt zu der folgenden Ausgabe

1234

public class AusgVertikal extends Object{ public static void gibausVertikal(int zahl) { if (zahl < 0) { System.out.println('-'); gibausVertikal(Math.abs(zahl)); } else if (zahl < 10) System.out.println(zahl); else { gibausVertikal(zahl / 10); System.out.println((zahl % 10)); } } public static void main(String args[]) { gibausVertikal(-12345); gibausVertikal(54321); }}


51

8. Aufgabe

a) Welche Ausgabe zeigt das folgende Programm, wenn die in diesem Programm enthaltenenrekursive Funktion mit dem Argument "n = 5" aufgerufen wird?

public class Hurra extends Object{ public static void gruesse(int n) { if (n <= 1) System.out.println("Hurra"); else { System.out.println("Hip"); gruesse(n-1); } } public static void main(String args[]) { gruesse(5); }}

HipHipHipHipHurra

b) Modifiziere die in dem vorliegenden Programm enthaltene rekursive Funktion, so daß zuerst "Hurra"ausggeben wird. Diesem Hurra sollen (n-1) "Hip" folgen.

public class Hip extends Object{ public static void gruesse(int n) { if (n <= 1) System.out.println("Hurra"); else { gruesse(n-1); System.out.println("Hip"); } }

public static void main(String args[]) { gruesse(5); }}


52

8. Übung

1. Aufgabe

a) Implementiere eine Klasse Complex zur Bearbeitung komplexer Zahlen. Die Struktur, die dieKlasse Complex annehmen soll, zeigt das folgende Klassendiagramm:

Complex

private double real; // Realteil private double imaginaer; // Imaginaerteil

public double real(); // Zugriff Realteil public double imaginaer(); // Zugriff Imaginaerteil public double betrag() // Betrag der komplexen Zahl, die diese Methode auf- // ruft public Complex plus(Complex z); // Addition 2er komplexer Zahlen (aufrufende Instanz // und uebergebene komplexe Zahl) public Complex minus(Complex z); // Subtraktion 2er komplexer Zahlen (aufrufende Instanz // minus uebergebene komplexe Zahl) public Complex mal(Complex z); // Multiplikation 2er komplexer Zahlen (aufrufende // Instanz multipliziert mit uebergebener komplexer Zahl) public Complex mal(Complex z); // Multiplikation der aufrufenden Instanz (komplexe Zahl) // mit uebergebener „double“-Zahl public Complex teilenDurch(Complex z); // Division 2er komplexer Zahlen (aufrufende Instanz // geteilt durch uebergebene komplexe Zahl) public String toString(); // Ausgabe komplexe Zahl

Zusätzlich zu den im Klassendiagramm angegebenen Instanzvariablen und Instanzmethoden sollein Konstruktor zur Initialisierung von Realteil und Imaginärteil angegeben werden.

public class Complex extends Object{ private double u; private double v;

Complex() { u = 0; v = 0; }

Complex(double x, double y) { u = x; v = y; }

// Realteil public double real() { return u; }


53

// Imagiaerteil public double imaginaer() { return v; }

// Betrag public double betrag() { return Math.sqrt(u * u + v * v); }

// Addition zweier komplexer Zahlen public Complex plus(Complex z) { return new Complex(u + z.u,v + z.v); }

// Subtraktion zweier komplexer Zahlen public Complex minus(Complex z) { return new Complex(u - z.u,v - z.v); }

// Multiplikation zweier komplexer Zahlen public Complex mal(Complex z) { return new Complex(u * z.u - v * z.v, u * z.v + v * z.u); }

// Multiplikation einer komplexen Zahl mit einer "double"-Zahl public Complex mal(double x) { return new Complex(u * x, v * x); }

public Complex teilenDurch(Complex z) { double rz = z.betrag(); return new Complex((u * z.u + v * z.v) / (rz * rz), (v * z.u - u * z.v) / (rz * rz)); }

public String toString() { if (v >= 0) return (String.valueOf(u) + " + " + String.valueOf(v) + "i"); else return (String.valueOf(u) + " - " + String.valueOf(-v) + "i"); }}


54

b) Zum Test der unter a) entwickelten und implementierten Klasse Complex soll eine KlasseComplexTest implementiert werden, die über eine Instanz einer komplexen Zahl alle Operationenmit komplexen Zahlen der Klasse Complex aufruft, die Berechnungen durchführt und auf demStandardausgabegerät protokolliert.

public class ComplexTest extends Object{ public static void main(String args[]) { Complex u, v, w, z;

u = new Complex(1,2); System.out.println("u: " + u);

v = new Complex(3,-4.5);

/* System.out.println("v: " + v.real() + " + "+ v.imaginaer() + "i"); */

System.out.println("v: " + v);

// Addiere u und v z = v.plus(u); System.out.println("v + u: " + z);

// Subtraktion u - v z = u.minus(v); System.out.println("u - v: " + z);

// Multiplikation u * v z = u.mal(v); System.out.println("u * v: " + z);

// Multiplikation v * u z = v.mal(u); System.out.println("v * u: " + z);

// Multiplikation mit einer Gleitpunktzahl double x = 5.1; z = v.mal(x); System.out.println("v * x: " + z);

// Teilen u durch v z = u.teilenDurch(v); System.out.println("u / v: " + z);

// Teilen v durch u z = v.teilenDurch(u); System.out.println("v / u: " + z); }}


55

2. Aufgabe

a) Implementiere eine Klasse Rational zur Bearbeitung rationaler Zahlen. Die Struktur, die dieKlasse Rational annehmen soll, zeigt das folgende Klassendiagramm:

Rational

private long num; // Numerator (Zaehler) private long den; // Denominator (Nenner)

public Rational(double x); // Konstruktor zur Ueberfuehrung einer double-Zahl in // einen Bruch public Rational(long num, long den); // Konstruktor zur Initialisierung einer gebrochenen Zahl // aus dem uebergebenen Zaehler bzw. Nenner public Rational plus(Rational r); // Addition 2er rationaler Zahlen (aufrufende Instanz // und uebergebene rationale Zahl) public Rational minus(Rational r); // Subtraktion 2er komplexer Zahlen (aufrufende Instanz // minus uebergebene komplexe Zahl) public Rational mal(Rational r); // Multiplikation 2er rationaler Zahlen (aufrufende // Instanz multipliziert mit uebergebener rationaler Zahl) public Rational teilenDurch(Complex z); // Division 2er rationaler Zahlen (aufrufende Instanz // geteilt durch uebergebene rationale Zahl) public void reduzieren(); // die vorliegende Instanz soll weitgehend auf kleinst- // moegliche Groessen reduziert werden, z.B. Teilen // durch gemeinsame Vielfache von Zaehler und Nenner public String toString(); // Ausgabe rationale Zahl

class Rational{ // Instanzvariable long num = 0L; // Numerator long den = 1L; // Denominator

// Private Methoden private long ggT(long m, long n) { long rest = m % n;

while (rest > 0) { m = n; n = rest; rest = m % n; }

return n; }


56

// Konstruktoren public Rational(double x) { double wert1; double wert2;

// Verschieben des Dezimalpunkts um 8 Stellen nach rechts wert1 = 100000000L * x;

// Verschieben des Dezimalpunkts um 7 Stellen nach rechts wert2 = 10000000L * x;

// wert1 - wert2 = 90000000 * x // Abschneiden zu einer "long"-Zahl, Entfernen des gebrochenen Teils // Approximation von x durch Numerator/90000000 num = (long) (wert1 - wert2); den = 90000000L;

// Reduzieren reduzieren(); }

public Rational(long num, long den) { super(); this.num = num; this.den = den;

if (den == 0) { System.out.println("Ein Null-Denominator ist falsch"); System.out.println("Denominator wird auf 1 gesetzt"); this.den = 1; } }

// Instanzmethoden // Addition public Rational plus(Rational r) { Rational temp = new Rational(num * r.den + den * r.num, den * r.den); return temp; }

// Subtraktion public Rational minus(Rational r) { Rational temp = new Rational(num * r.den - den * r.num, den * r.den); return temp; }

// Multiplikation public Rational mal(Rational r) { Rational temp = new Rational(num * r.num, den * r.den); return temp; }


57

// Division public Rational teilenDurch(Rational r) { Rational temp = new Rational(num * r.den, den * r.num); return temp; }

public void reduzieren() { long teiler; long absnum; // absoluter Wert des Numerators absnum = (num <0) ? -num : num;

if (num == 0) den = 1; else { // Finde den groessten gemeinsamen Teiler // von absnum und dem Denominator teiler = ggT(absnum,den);

// Fall „teiler == 1“, ist die rationale Zahl reduziert,anderenfalls // teile Numerator und Denominator durch ihren groessten gemeinsamen // Teiler

if (teiler > 1) { num /= teiler; den /= teiler; } } }

// Konvertieren rationale Zahl in "double"-Zahl public double rationalIndouble() { return (double) num / den; }

// Ausgabe public String toString() { return String.valueOf(num) + '/' + String.valueOf(den); }

}


58

b) Zum Test der unter a) entwickelten und implementierten Klasse Rational soll eine KlasseRationalTest implementiert werden, die alle unter a) angegebenen Methoden anhand geeigneterInstanzen rationaler Zahlen überprüft und auswertet.

class RationalTest{ public static void main(String args[]) { System.out.println("Approximation Double-Zahl in rationale Zahl");

double d = 0.75; Rational v = new Rational(d); System.out.println("v: " + v); System.out.println("Erzeugen einer rationalen Zahl");

Rational u = new Rational(2,3); System.out.println("u: " + u); System.out.println("Die zugehoerige double-Zahl ist: " + u.rationalIndouble()); System.out.println("Rechnen mit rationalen Zahlen");

Rational z; z = u.plus(v); System.out.println("u + v: " + z);

z = u.minus(v); System.out.println("u - v: " + z);

z = v.minus(u); System.out.println("v - u: " + z);

z = u.mal(v); System.out.println("u * v: " + z);

z = u.teilenDurch(v); System.out.println("u / v: " + z);

z = v.teilenDurch(u); System.out.println("v / u: " + z); }}


59

3. Aufgabe

Das folgende Klassendiagramm beschreibt die Klasse Turtle.

Turtle

private double turtleX; // x-Koordinate des aktuellen Endpunkts vom Turtle-Fahrstrahl private double turtleY; // y-Koordinate des aktuellen Endpunkts vom Turtle-Fahrstrahl private double turtleR; // Länge des Fahrstrahls der aktuellen Turtle private double turtleTheta; // Winkel, der am Ende des aktuellen Fahrstrahls entgegen dem Uhr- // zeigersinn („-“) bzw. im Uhrzeigersinn („+“) eingeschlagen wird.

public void schritt(); // bestimmt die (x,y)-Koordinate vom Endpunkt des jeweiligen Fahrstrahls public void wende(double winkel); // verändert den Winkel vom jeweiligen Endpunkt des Fahrstrahls aus // gesehen. Ein negative Winkelangabe dreht den aktuellen Fahrstrahl ent- // gegen dem Uhrzeigersinn, eine positive Winkelangabe dreht den // aktuellen Fahrstrahl im Uhrzeigersinn.

Mit Hilfe der Turtle-Grafik können einfache zweidimensionale Darstellungen erzeugt werden. Voneinem Ausgangspunkt kann im Rahmen der Turtle-Grafik ein Pfeil bestimmter Länge gezeichnetwerden:

Die Spitze des Pfeils gibt die Richtung an, die über eine Winkelangabe verändert werden kann. Einnegativer Winkel dreht den Pfeil entgegen dem Uhrzeigersinn, ein positiver Winkel dreht den Pfeil imUhrzeigersinn.

public class Turtle{ // Instanzvariable private double turtleR, turtleX, turtleY, turtleTheta;

// Konstruktor public Turtle() { this(0.0,0.0,100,0); }

public Turtle(double turtleX, double turtleY, double turtleR, double turtleTheta) { this.setzeTurtleX(turtleX); this.setzeTurtleY(turtleY); this.setzeTurtleR(turtleR); this.setzeTurtleTheta(turtleTheta); }

// Instanzmethoden public double holeTurtleX() { return turtleX; }

public void setzeTurtleX(double turtleX) { this.turtleX = turtleX; }


60

public double holeTurtleY() { return turtleY; }

public void setzeTurtleY(double turtleY) { this.turtleY = turtleY; }

public double holeTurtleR() { return turtleR; }

public void setzeTurtleR(double turtleR) { this.turtleR = turtleR; }

public double holeTurtleTheta() { return turtleTheta; }

public void setzeTurtleTheta(double turtleTheta) { this.turtleTheta = turtleTheta; }

public void schritt() { turtleX += turtleR * Math.cos(turtleTheta*Math.PI/180); turtleY += turtleR * Math.sin(turtleTheta*Math.PI/180); }

public void wende(double winkel) { turtleTheta += winkel; }}


61

Die soeben entwickelte Klasse Turtle kann

a) zum Zeichnen eines regelmäßigen Vielecks mit gegebener Anzahl Ecken (z.B. 3 bzw. 12) undSeitenlänge (100 Pixel bzw. 50 Pixel) benutzt werden. Schreibe ein Applet, das mit Hilfe derKlasse Turtle ein regelmäßiges Vieleck zeichnet.


public class Vieleck extends Applet{ // Turtle-Objekt Turtle turtle;

// Abmessung des Fensters Dimension d;

// Anzahl der Ecken /* int eckenZahl = 12; */ int eckenZahl = 3;

public void init() { d = getSize();

// turtle = new Turtle(d.width/2-25,3*d.height/4,100,0);

turtle = new Turtle(d.width/4,3*d.height/4,200,0); }

public void paint(Graphics g) { double xAlt; double yAlt;

g.setColor(Color.yellow); g.fillRect(0,0,d.width-1,d.height-1); g.setColor(Color.black);

for (int i = 0; i < eckenZahl; i++) { xAlt = turtle.holeTurtleX(); yAlt = turtle.holeTurtleY(); turtle.schritt(); g.drawLine((int) xAlt, (int) yAlt,(int) turtle.holeTurtleX(), (int) turtle.holeTurtleY());

turtle.wende(-360/eckenZahl); } }}


62

b) zum Zeichnen einer Qudratrosette verwendet werden.

Hier dreht man ein Quadrat um einen festen Punkt.Schreibe ein Applet, das mit Hilfe der Klasse Turtle die Quadratrosette zeichnet. Ein einzelnesQuadrat hat eine Seitenlänge von 100 Pixel.


public class Quadratrosette extends Applet{ // Turtle-Objekt Turtle turtle;

// Abmessung des Fensters Dimension d;

public void init() { d = getSize(); turtle = new Turtle(d.width/2,d.height/2,100,0); }

public void paint(Graphics g) { g.setColor(Color.yellow); g.fillRect(0,0,d.width-1,d.height-1);

for (int i = 0; i < 36; i++) { zeichneQuadrat(g); turtle.wende(10); } }


63

public void zeichneQuadrat(Graphics g) { g.setColor(Color.black);

for (int i = 0; i < 4; i++) { double xAlt = turtle.holeTurtleX(); double yAlt = turtle.holeTurtleY(); turtle.schritt(); g.drawLine((int) xAlt, (int) yAlt,(int) turtle.holeTurtleX(), (int) turtle.holeTurtleY()); turtle.wende(90); } }}


64

9. Übung

1. Aufgabe

a) „Damen“-Problem

Aufgabenstellung: Acht Damen sollen so auf einem Schachbrett positioniert werden, daß sie sichnicht schlagen können, d.h.: Zwei Damen stehen nie in derselben Zeile oder Spalte oderDiagonale.

Algorithmus zur Lösung: Zu Beginn wird ein zweidimensionales Feld mit 0 gefüllt.

0 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 0

Danach wird zufällig im zweidimensionalen Feld eine „Dame“ gesetzt. Das Setzen der Dame wirddurch eine 9 markiert.

0 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 9 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 00 0 0 0 0 0 0 0

Durch das Positionieren der Dame sind Positionierungen von weiteren Damen in derselben Zeileund Spalte wie die soeben positionierte Dame, aber auch in den zugehörigen Diagonalen nichterlaubt. Die nicht mehr zulässigen Positionen werden mit 1 markiert.

1 0 0 1 0 0 1 00 1 0 1 0 1 0 00 0 1 1 1 0 0 01 1 1 9 1 1 1 10 0 1 1 1 0 0 00 1 0 1 0 1 0 01 0 0 1 0 0 1 00 0 0 1 0 0 0 1


65

Damen dürfen jetzt nur noch auf die mit 0 markierten Komponenten des zweidimensionalen Feldsgebracht werden. Das geschieht solange bis alle Komponenten des zweidimensionalen Felds mit 1oder 9 gefüllt sind. Wurden beim Füllen des Felds insgesamt 8 Damen positioniert, dann wurdeeine Lösung erreicht, die so aussehen könnte:

1 1 1 1 1 1 9 1 1 9 1 1 1 1 1 1 1 1 1 1 1 9 1 1 1 1 9 1 1 1 1 1 9 1 1 1 1 1 1 1 1 1 1 9 1 1 1 1 1 1 1 1 1 1 1 9 1 1 1 1 9 1 9 1

import java.util.*;

public class Damen{ // Konstanten final int N = 8;

// Variable boolean fuellen; boolean ausgeben; Random rand = new Random(); int zeile, spalte; int[][] brett; int aktZahl = 0; int[] positionen = new int[N];

// Methoden int zRand(int mod) { return Math.abs(rand.nextInt() % mod); }

public void initialisiere() { fuellen = false; ausgeben = false; aktZahl = 0; brett = new int[N][N];

for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) { brett[i][j] = 0; } }


66

public void nimmPosition() { do { zeile = zRand(N);

// System.out.println(zeile); spalte = zRand(N);

// System.out.println(spalte); } while (brett[zeile][spalte] != 0);

brett[zeile][spalte] = 9; aktZahl++; }

public void bewertePosition() { for (int i = 0; i < 8; i++) { if (i != spalte) brett[zeile][i] = 1; }

for (int i = 0; i < 8; i++) { if (i != zeile) brett[i][spalte] = 1; }

int lDzeile = zeile; int lDspalte = spalte;

// Beruecksichtigung der nach links laufenden Diagonale while ((lDzeile > 0) && (lDspalte > 0)) { lDzeile--; lDspalte--; }

do { if ((lDzeile != zeile) && (lDspalte != spalte)) { brett[lDzeile][lDspalte] = 1; }

lDzeile++; lDspalte++; } while ((lDzeile < 8) && (lDspalte < 8));

// ausgabe(); int rDzeile = zeile; int rDspalte = spalte;

// Beruecksichtiung der nach rechts laufenden Diagonale while ((rDzeile > 0) && (rDspalte < 7)) { rDzeile--; rDspalte++; }


67

do { if ((rDzeile != zeile) && (rDspalte != spalte)) { brett[rDzeile][rDspalte] = 1; }

rDzeile++; rDspalte--; } while ((rDzeile < 8) && (rDspalte >= 0)); }

public void pruefe() { int nullen = 0; int anzDamen = 0;

for (int i = 0; i < 8; i++) for (int j = 0; j < 8; j++) { if (brett[i][j] == 0) nullen++; if (brett[i][j] == 9) anzDamen++; }

if (nullen == 0) fuellen = true; if (anzDamen == 8) ausgeben = true; }

public void ausgabe() { System.out.println();

for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { System.out.print(brett[i][j] + " "); }

System.out.println(); }

System.out.println(); int k = 0;

for (int i = 0; i < brett.length; i++) for (int j = 0; j < brett[i].length; j++) { if (brett[i][j] == 9) positionen[k++] = j; }

for (k = 0; k < N; k++) System.out.print(positionen[k]+" ");

System.out.println(); }


68

public void erzeugeDamen() { do { initialisiere();

do { nimmPosition();

// ausgabe(); bewertePosition();

// ausgabe(); if (aktZahl > 4) pruefe();

} while (!fuellen);

} while (!ausgeben);

ausgabe(); }}

public class Damentest{ public static void main(String args[]) { Damen d = new Damen(); d.erzeugeDamen(); }}


69

b) Die unter a) ermittelte Positionsangaben für Damen sollen jetzt, wie die folgende Darstellungzeigt, in ein Schachbretts eingebracht werden.


public class Aufg1 extends Applet{ static final int N = 8; static final int GROESSE = 40; static int x_offset, y_offset;

static int qx[] = { 4, 8, 32, 36, 31, 28, 24, 20, 16, 12, 9, 4, }; static int qy[] = { 19, 34, 34, 19, 24, 13, 22, 4, 22, 13, 24, 19, }; static int qxx[] = { 8, 17, 20, 23, 32, }; static int qyy[] = { 31, 31, 27, 31, 31, }; Dimension d; Damen dame;

public void init() { // Bestimmen der Applet-Fenstergroesse d = getSize();

// Berechnen der Positionen fuer die Damen dame = new Damen(); dame.erzeugeDamen(); }


70

public void paint( Graphics g ) { holOffsets(); zeichneBrett(g); zeichneAlleDamen(g); }

void holOffsets() { x_offset = (d.width - (N * GROESSE)) / 2; y_offset = (d.height- (N * GROESSE)) / 2 - 10; }

void zeichneBrett( Graphics g ) { g.setColor( Color.lightGray ); g.fillRect( 0, 0, d.width, d.height ); g.setColor( Color.lightGray ); g.draw3DRect( x_offset-2, y_offset-2, N*GROESSE+3, N*GROESSE+3, true ); g.draw3DRect( x_offset-3, y_offset-3, N*GROESSE+5, N*GROESSE+5, true ); g.draw3DRect( x_offset-4, y_offset-4, N*GROESSE+7, N*GROESSE+7, true );

for( int j=0; j < N; j++ ) { for( int i=0; i < N; i++ ) { if ((i + j) % 2 == 1) g.setColor(Color.red); else g.setColor(Color.lightGray);

g.fillRect( x_offset + i * GROESSE,y_offset + j * GROESSE, GROESSE, GROESSE );

} } }

void zeichneAlleDamen( Graphics g ) { for( int i = 0; i < N; i++ ) { // System.out.print(dame.positionen[i]+" "); zeichneEineDame(g, x_offset+GROESSE*(dame.positionen[i]), y_offset+GROESSE*i); } }

void zeichneEineDame(Graphics g, int x, int y ) { g.translate( x, y ); g.setColor( Color.white ); g.fillPolygon( qx, qy, qx.length ); g.setColor( Color.black ); g.drawPolygon( qx, qy, qx.length ); g.drawPolygon( qxx, qyy, qxx.length ); g.translate( -x, -y ); }}


71

2. Aufgabe

a) Schreibe eine Anwendung, die folgende Sortierroutinen umfaßt:

- Sortieren durch Austauschen- Sortieren durch Einfügen- Quicksort

Die Sortierroutinen sollen Bestandteil der Klasse Sort sein und über deren main()-Funktionaufgerufen werden können. Der Aufruf der Sortierroutinen soll ein ganzzahliges Feld mit unsortiertvorliegenden Zahlen übergeben, die in den Sortierroutinen aufsteigend sortiert werden sollen. DasFüllen des Datenfeldes soll mit Zufallszahlen im Bereich 0 bis 100 erfolgen, eine entsprechendeAusgabe des unsortiert bzw. sortiert vorliegenden Felds ist vorzusehen.

import java.util.*;

class Ueb1411{ void bubbleSort(int x[], int n) { boolean sortiert = false;

// Sortiere das Feld x while (!sortiert) { sortiert = true;

for (int i=0; i < n-1; i++) { if (x[i] > x[i+1]) { int temp = x[i]; x[i] = x[i+1]; x[i+1] = temp; sortiert = false; } } } }

void einfuegeSort(int x[], int n) { int temp, j;

for (int i=1; i < n; i++) { temp = x[i]; j = i - 1;

while ((j >= 0) && (temp < x[j])) { x[j+1] = x[j]; j--; } x[j+1] = temp; } }


72

public static void quicksort(int x[], int links, int rechts) { int i = links; int j = rechts;

// Auswahl eines Elements aus dem zu sortierenden Bereich int pivot = x[(links + rechts) / 2];

do { // Zerlegen in zwei Teilbereiche while (x[i] < pivot) i++; while (pivot < x[j]) j--;

if (i <= j) { int temp = x[i]; x[i] = x[j]; x[j] = temp; i++; j--; } } while (i <= j);

if (links < j) quicksort(x,links,j); if (i < rechts) quicksort(x,i,rechts); }

public static void main(String args[]) { int[] x; int n; n = Integer.valueOf(args[0]).intValue(); x = new int[n]; Random zufallsZahl = new Random();

// Initialisieren des Array x for (int i = 0; i < n; i++) { x[i] = zufallsZahl.nextInt() % 100; }

// Ausgabe des noch nicht sortierten x System.out.println("Vor dem Sortieren:"); for (int i = 0; i < n; i++) { System.out.println("x["+i+"] = " + x[i]); }

// Aufruf der Sortieroutine Ueb1411 s = new Ueb1411(); s.bubbleSort(x,n); // s.einfuegeSort(x,n); // int l = 0; int r = n - 1; // s.quicksort(x,l,r); // Gib das sortierte Feld x aus System.out.println(); System.out.println("Nach dem Sortieren:"); for (int i = 0; i < n; i++) { System.out.println("x["+i+"] = " + x[i]); } }}


73

b) Stelle das unter a) entwickelte Programm so um, daß anstatt ganzer Zahlen „Zeichenketten“bearbeitet werden können.

// import java.util.*;

public class Ueb1412{ void bubbleSort(String x[], int n) { boolean sortiert = false;

// Sortiere das Feld x while (!sortiert) { sortiert = true; for (int i=0; i < n-1; i++) { if ( (x[i].compareTo(x[i+1]) > 0) ) { String temp = x[i]; x[i] = x[i+1]; x[i+1] = temp; sortiert = false; } } } }

void einfuegeSort(int x[], int n) { int temp, j;

for (int i=1; i < n; i++) { temp = x[i]; j = i - 1;

while ((j >= 0) && (temp < x[j])) { x[j+1] = x[j]; j--; } x[j+1] = temp; } }

public static void quicksort(int x[], int links, int rechts) { int i = links; int j = rechts; // Auswahl eines Elements aus dem zu sortierenden Bereich int pivot = x[(links + rechts) / 2];


74

do { // Zerlegen in zwei Teilbereiche while (x[i] < pivot) i++; while (pivot < x[j]) j--;

if (i <= j) { int temp = x[i]; x[i] = x[j]; x[j] = temp; i++; j--; } } while (i <= j);

if (links < j) quicksort(x,links,j); if (i < rechts) quicksort(x,i,rechts); }

public static void main(String args[]) { String[] x = { "juergen","christian","bernd","werner","uwe", "erich","kurt","karl","emil","ernst" }; int n = 10;;

// Ausgabe des noch nicht sortierten x System.out.println("Vor dem Sortieren:");

for (int i = 0; i < n; i++) { System.out.println("x["+i+"] = " + x[i]); }

// Aufruf der Sortieroutine Ueb1412 s = new Ueb1412(); s.bubbleSort(x,n); // s.einfuegeSort(x,n); // int l = 0; int r = n - 1; // s.quicksort(x,l,r); // Gib das sortierte Feld x aus System.out.println(); System.out.println("Nach dem Sortieren:"); for (int i = 0; i < n; i++) { System.out.println("x["+i+"] = " + x[i]); } }}


75

c) Gegeben ist das folgende Interface

interface Vergleich{ boolean kleinerAls(Object ls, Object rs); boolean kleinerAlsoderGleich(Object ls, Object rs);}

Das Interface beschreibt zwei Methoden zum Vergleich zweier Objekte vom Typ Object. Diebeiden Methoden ermitteln den Rückgabewert true bzw. false je nachdem, ob das 1. Argument„kleiner“ oder „kleiner gleich“ zu dem 2. Argument ist.Implementiere dieses Interface in einer Klasse „StringSortTest“, die ein Array mit Zeichenkettenbereitstellt, der durch Aufruf einer Sortierroutine (Methode: „Quicksort“) der Klasse Sort die in demArray bereitgestellten Strings sortiert.

interface Vergleich{ boolean kleinerAls(Object ls, Object rs); boolean kleinerAlsoderGleich(Object ls, Object rs);}

public class Sort{ private Vergleich vergleich;

public Sort(Vergleich vergl) { vergleich = vergl; }

public void sort(Object x[],int n) { quickSort(x,0,n); }

public void quickSort(Object x[],int links, int rechts) { // System.out.println("rechts: " + rechts); if (rechts > links) { Object o = x[rechts]; int i = links - 1; int j = rechts;

// System.out.println("i: " + i + " j: " + j);

while (true) { while (vergleich.kleinerAls(x[++i],o)); while (j > 0) if (vergleich.kleinerAlsoderGleich(x[--j],o)) break;

if (i >= j) break; tausche(x,i,j); }

tausche(x,i,rechts); quickSort(x,links,i-1); quickSort(x,i+1,rechts); } }


76

private void tausche(Object x[], int stelle1, int stelle2) { Object tmp = x[stelle1]; x[stelle1] = x[stelle2]; x[stelle2] = tmp; }}

public class StringSortTest{ static class StringVergleich implements Vergleich { public boolean kleinerAls(Object l, Object r) { return((String)l).toLowerCase().

compareTo(((String)r).toLowerCase()) < 0; }

public boolean kleinerAlsoderGleich(Object l, Object r) { return((String)l).toLowerCase().

compareTo(((String)r).toLowerCase()) <= 0; } }

public static void main(String args[]) { String x[] = { "Juergen","Christian","Bernd","Werner","Uwe", "Erich","Kurt","Karl","Emil","Ernst" }; Object o[] = new Object[x.length];

for (int i = 0; i < x.length; i++) { o[i] = (Object) x[i]; }

// Ausgabe des noch nicht sortierten x System.out.println("Vor dem Sortieren:");

for (int i = 0; i < x.length; i++) { System.out.println("x["+i+"] = " + x[i]); }

// Aufruf der Sortieroutine Sort s = new Sort(new StringVergleich()); s.sort(o,x.length-1);

// Gib das sortierte Feld x aus for (int i = 0; i < x.length; i++) { x[i] = (String) o[i]; } System.out.println(); System.out.println("Nach dem Sortieren:"); for (int i = 0; i < x.length; i++) { System.out.println("x["+i+"] = " + x[i]); } }}


77

d) Die unter c) ermittelte Lösung läßt sich verallgemeinern, indem anstatt eines Datenfelds eineInstanz der Klasse Vector (enthalten im Paket „java.util“) verwendet wird. Gib auch hierfür einkomplette Anwendung an.

3. Aufgabe

Mit Hilfe der in Java implementierten mehrdimensionalen Datenfelder lassen sich Datenstrukturen zurLösung komplexer Probleme realisieren. Eine solche Datenstruktur, die eine Lösung für das bekanntePascalsche Dreieck beschreibt, zeigt die folgende Abbildung des zweidimensionalen Felds„dreieck[][]“, dessen Komponente die Zahlenwerte des Pascalschen Dreiecks (Binomialkoeffizienten)aufnehmen.

Schreibe eine Anwendung, das die vorliegende Datenstruktur mit den Komponenten des PascalschenDreiecks enthält und auf die Konsole ausgibt.

public class PascalDreieck{ static long[][] pascalDreieck(int n) { long [][] dreieck = new long[n][]; // n Zeilen

for (int i = 0; i < dreieck.length; i++) { dreieck [i] = new long[i+1]; // i+1 Elemente dreieck[i][0] = 1;

for (int j = 1; j < i; j++) { dreieck[i][j] = dreieck[i-1][j-1] + dreieck[i-1][j]; }

dreieck[i][i] = 1; } return dreieck; }


78

public static void main(String [] args) { long koeffizienten[][] = pascalDreieck(10);

for (int i = 0; i < koeffizienten.length; i++) { /* System.out.print(" ");

for (int k = 2 * (koeffizienten.length - i) + 7; k > i; k--) System.out.print(" "); */

for (int j = 0; j < koeffizienten[i].length; j++) { System.out.print(" " + koeffizienten[i][j]); }

System.out.println(); } }}


79

10. Übung

1. Aufgabe

a) Benötigt das folgende Programm eine Spezifikation für den hier vorliegenden Ausnahmetyp

public class NieGefangen{ static void f() { throw new RuntimeException("Von f()"); }

static void g() { f(); }

public static void main(String[] args) { g(); }}

nein

b) Zeige durch Implementierung und anschließenden Test des vorliegenden Programms, daß dieunter a) gemachte Angabe korrekt ist.

c) Welche Ausgabe zeigt das unter b) implementierte Programm?

Am Ende des Programms wird printStackTrace() aufgerufen

Ausgabe:java.lang.RuntimeException: Von f() at NieGefangen.f(NieGefangen.java:5) at NieGefangen.f(NieGefangen.java:9) at NieGefangen.f(NieGefangen.java:13)

d) Was kann daraus für das Behandeln einer "RuntimeException" in Java-Anwendungengeschlossen werden?

RuntimeException bestimmt Programmfehler mit folgenden Eigenschaften:1. Sie können nicht eingefangen werden2. Sie müssen im Programm vom Programmierer speziell überprüft und behandelt werden


80

2. Aufgabe

a) Wird die Ausnahme des folgenden Programms in main() aufgefangen?

public class WirfAus{ public static void main(String args[]) throws Throwable { try { throw new Throwable(); } catch (Exception e) { System.out.println("Gefangen in main()"); } }}

nein

b) Beweise die unter a) gemachte Aussage durch Implementierung und Test des vorliegendenProgramms. Gib einen Grund für dieses Programmverhalten an.

Eingefangen in main() wird eine Ausnahme der Klasse Exception, ausgeworfen wird von diesemProgramm eine Ausnahme der Klasse Throwable

Ausgabe:java.lang.Throwable at WirfAus.main(WirfAus.java:7)


81

3. Aufgabe

Welche Schlußfolgerung kann für das Wiederauswerfen von Ausnahmen aus der Ausgabe zu demfolgenden Programm gewonnen werden?

public class Wiederauswurf{ public static void f() throws Exception { System.out.println("Ursprung der Ausnahme in f()"); throw new Exception("Auswurf in f()"); }

public static void main(String args[]) { try { f(); } catch (Exception e) { System.out.println("Aufgefangen in main(), e.printStackTrace()"); e.printStackTrace(); throw new NullPointerException("von main()"); } }}

Zum Begutachten der Ausgabe implementiere das vorliegende Programm und betrachte das Ergebnis(die Ausgabe) durch den Java-Interpreter.

Ursprung der Ausnahme in f()Aufgefangen in main(), e.printStackTrace()java.lang.Exception: Auswurf in f() at java.lang.Throwable.<init>(Compiled Code) at java.lang.Exception.<init>(Compiled Code) at Wiederauswurf.f(Wiederauswurf.java:6) at Wiederauswurf.main(Wiederauswurf.java:12)java.lang.NullpointerException: von main() at java.lang.Throwable.<init>(Compiled Code) at java.lang.RuntimeException.<init>(Compiled Code) atjava.lang.NullPointerException.<init>(NullPointerException.java:64) at Wiederauswurf.main(Wiederauswurf.java:18)


82

4. Aufgabe

a) Was zeigt das folgende Programm?

class MeineAusnahme extends Exception{ public MeineAusnahme() {} public MeineAusnahme(String nachricht) { super(nachricht); }}

public class AuswurfMeineAusnahme{ public static void f() throws MeineAusnahme { System.out.println("Auswurf von MeineAusnahme aus f()"); throw new MeineAusnahme(); }

public static void g() throws MeineAusnahme { System.out.println("Auswurf von MeineAusnahme aus g()"); throw new MeineAusnahme("Ursprung in g()"); }

public static void main(String args[]) { try { f(); } catch (MeineAusnahme a) { a.printStackTrace(); }

try { g(); } catch (MeineAusnahme a) { a.printStackTrace(); } }}

Eigene benutzerdefinierte Ausnahmen können direkt von der Klasse Exception abgeleitet werden.Das Wiederauswerfen einer Ausnahme ist möglich


83

b) Implementiere das vorliegende Programm und überprüfe dessen Wirkungsweise.Welche Ausgabe erzeugt dieses Programm?

Ausgabe: TestAuswurf vom MeineAusnahme aus f()MeineAusnahme at java.lang.Throwable.<init>(Compiled Code) at java.lang.Exception.<init>(Compiled Code) at MeineAusnahme.<init>(AuswurfMeineAusnahme.java:3)

at AuswurMeineAusnahme.f(Vererbung.java:14) at AuswurfmeineAusnahme.main(Vererbung.java:24)Auswurf von MeineAusnahme aus g()MeineAusnahme: Ursprung in g() at java.lang.Throwable.<init>(Compiled Code) at java.lang.Exception.<init>(Compiled Code) at MeineAusnahme.<init>(AuswurfMeineAusnahme.java:6) at AuswurfMeineAusnahme.g(AuswurfMeineAusnahme.java:19) at AuswurfMeineAusnahme.main(AuswurfMeineAusnahme.java:31)


84

11. Übung

1. Aufgabe

Implementiere das folgende Programm

class EineWichtigeAusnahme extends Exception{ public String toString() { return "Eine wichtige Ausnahme!"; }}

class EineTrivialeAusnahme extends Exception{ public String toString() { return "Eine triviale Ausnahme!"; }}

public class VerlNachricht{ void f() throws EineWichtigeAusnahme { throw new EineWichtigeAusnahme(); }

void g() throws EineTrivialeAusnahme { throw new EineTrivialeAusnahme(); }

public static void main(String args[]) throws Exception { VerlNachricht vn = new VerlNachricht(); try { vn.f(); } finally { vn.g(); } }}

a) Welche Ausgabe zeigt dieses Programm?

Ausgabe:Eine triviale Ausnahme! at.java.lang.Throwable.<init>(Compiled Code) at.java.lang.Exception.<init>(Compiled Code) at EineTrivialeAusnahme.<init>(VerlNachricht.java:8) at Verlnachricht.g(VerlNachricht.java:23) at Verlnachricht.main(VerlNachricht.java:32)


85

b) Interpretiere diese Ausgabe!

EineWichtigeAusnahme wird in der finally-Klausel ersetzt durch EineTrivialeAusnahme

c) Welche Schlußfolgerung kann daraus gezogen werden?

schwerwiegender Sündenfall, der in einer der folgenden Java-Versionen behoben werden müßte.

2. Aufgabe

a) Schreibe ein Programm, das von der Standardeingabe eingelesene Zeichen (Zeichenketten) aufdie Standardausgabe ausgibt.

b) Überprüfe anhand des unter a) entwickelten und implementierten Programms, welche Ausgabenzu folgenden Eingaben gehören:

- Eingabe einer leeren Zeichenketten- Eingabe von „end of file“ (EOF) (unter Solaris: CTRL-D; unter Windows: CTRL-C)

import java.lang.*;import java.io.*;

public class Echo extends Object{ public static void main(String args[]) { BufferedReader ein =

new BufferedReader(new InputStreamReader(System.in)); String eingabeZeile = null;

try { eingabeZeile = ein.readLine(); }

catch (IOException e) { System.out.println(e.toString()); System.exit(0); }

System.out.println(eingabeZeile); }}


86

3. Aufgabe

Erstelle die Kopie einer Textdatei, deren Name über die Kommandozeile eingeben werden soll.

import java.io.*;

class DateiKopie{ public static void main(String args[]) throws IOException { /* Java IO-Bytestrom DataInput ein = new DataInputStream(new FileInputStream("DateiKopie.java")); DataOutput aus = new DataOutputStream(new FileOutputStream("KopieDatei.java")); String zeile;

while ((zeile = ein.readLine()) != null) { StringBuffer modifizierteZeile = new StringBuffer(zeile); aus.writeBytes(modifizierteZeile.toString()); System.out.println(modifizierteZeile.toString()); } */

BufferedReader ein;

try { ein = new BufferedReader(new FileReader("DateiKopie.java")); } catch (FileNotFoundException a) { System.out.println("Datei kann nicht geoeffnet werden!"); throw a; }

PrintWriter aus = new PrintWriter( new BufferedWriter( new FileWriter("KopieDatei.java"))); String s;

try { while ((s = ein.readLine()) != null) { aus.println(s); }

ein.close(); aus.close(); } catch (IOException a) { System.out.println("Fehler beim Kopieren der Datei"); throw a; } }}


87

4. Aufgabe

Bestimme die Größe einer Datei (in Bytes), deren Name über die Kommandozeile angegeben werdensoll.Hinweis zur Lösung: Die Klasse InputStream des JDK 1.0 im Paket java.io enthält eine Methodeavailable(), die die Anzahl Bytes eines Eingabestromobjekts zurückgibt

import java.io.*;

class DateiGroesse{ public static void main(String argv[]) throws IOException { int dateiGroesse = -1; InputStream s; s = new FileInputStream("a:DateiDarsteller.java"); dateiGroesse = s.available(); System.out.print("Dateigroesse ist " + dateiGroesse + " bytes\n"); s.close(); }}


88

5. Aufgabe

Eine Textdatei, z.B. die Datei "EinAus.java", soll bis zum Dateiende (EOFException) sequentielleingelesen werden. Jede einzelne Zeile soll nach dem Einlesen mit Hilfe der im Paket "java.io"vorliegenden Klasse LineNumberReader durchnummeriert und in eine Ausgabedatei geschriebenwerden. Die Ausgabedatei soll dabei folgende Gestalt annehmen:

/* 1 */ import java.io.*;/* 2 */ public class EinAus/* 3 */ {/* 4 */ public static void main(String args[]) throws IOException/* 5 */ {/* 6 */ String s = new String();/* 7 */ ......................../* 8 */ ........................................................../* 21 */ ......................../* 22 */ ......................../* 23 */ }/* 24 */ }

Die Klasse LineNumberReader ist eine Ableitung von BufferedReader, die zusätzlich die Anzahl derEingabezeilen beim Einlesen zählen kann. Beim Einlesen ist ein vorzeitiges Ende der Eingabedatei abzufangenund speziell über die Standardausgabe zu kommentieren.

import java.io.*;

public class EinAus{ public static void main(String args[]) throws IOException { String s = new String();

try { LineNumberReader ein = new LineNumberReader( new FileReader("EinAus.java")); PrintWriter aus = new PrintWriter( new BufferedWriter( new FileWriter("EinAusDemo.txt")));

while ((s = ein.readLine()) != null) aus.println("/* " + ein.getLineNumber() + " */ " + s); aus.close(); } catch (EOFException e) { System.out.println("Ende des Stroms"); } }}


89

12. Übung

1. Aufgabe

Schreibe ein Programm, das eine Textdatei (z.B. *.java“) aus dem aktuellen Verzeichnis über eine„TextArea“ auf ein Fenster des Bildschirms abbildet. Jede Zeile soll dabei durchnummeriert werden.Die Nummerierung ist in Kommentarzeilen einzuschließen. Zur Ermittlung der abzubildenen Datei istein „FileDialog“ heranzuziehen. Die Abbildung soll ein einem speziellen Font „Helvetica“, im StilFont.Plain“ und mit der Fontgröße 10 erfolgen. Das Fenster soll nach der Anzeige vergrößert werdenkönnen und schließlich auch wieder geschlossen werden können.

import java.awt.*;import java.io.*;import java.awt.event.*;

public class Ueb601 extends Frame{ private LineNumberReader ein;

public Ueb601() throws IOException { FileDialog d = new FileDialog( this, "Welche Datei soll geoeffnet werden?"); d.setFile("*.java"); d.setDirectory("."); // Aktuelles Verzeichnis d.show(); String datei = "*.*";

if ((datei = d.getFile()) != null) { try { ein = new LineNumberReader(new FileReader(datei)); } catch ( FileNotFoundException a) { throw a; }

// dateiName.setText(datei); // verzeichnis.setText(d.getDirectory());

try { dateiDarstellen(); } catch (IOException a ) { throw a; } } else { } }


90

public void dateiDarstellen() throws IOException { try { String s = new String(); TextArea textBereich = new TextArea(s,24,80);

while ((s = ein.readLine()) != null) { s = "/* " + ein.getLineNumber() + " */ " + s + '\n'; textBereich.append(s); }

textBereich.setFont(new Font("Helvetica",Font.PLAIN,10)); textBereich.setEditable(false); this.add("Center",textBereich); } catch (IOException e) { } this.show(); }

public static void main(String args[]) throws IOException { Frame f = new Ueb601(); f.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } });

f.setVisible(true); }}


91

2. Aufgabe

a) Schreibe ein Programm, das Celsius-Grade in Fahrenheit bzw. Fahrenheit- in Celsius-Gradeumrechnet. Zur Eingabe bzw. zur Darstellung der Umrechnung benutze die folgenden beidenTextfelder. Aus deren Beschriftung geht hervor, welches der beiden Textfelder zur Eingabe bzw.Darstellung von Celsius-Graden bzw. Fahrenheit- dient. Ein- ubd Ausgabe sollen in ein Fenstereiner grafischen Benutzeroberfläche erfolgen, das folgende Gestalt besitzt.

import java.lang.*;import java.awt.*;import java.awt.event.*;public class C2F extends Frame{ // Einlesen und Ausgeben von Zeichenketten ueber // eine grafische Benutzeroberflaeche private static TextField celsiusFeld = new TextField(10); private static TextField fahrenhFeld = new TextField(10);

public static void main(String args[]) { Frame fenster = new Frame("Umrechnung Fahrenheit - Celsius");

fenster.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } });

Label celsiusFeldLabel = new Label("Celsius:"); Label fahrenhFeldLabel = new Label("Fahrenheit:"); celsiusFeld.setEditable(true);

celsiusFeld.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { Float fRef = null; String s = celsiusFeld.getText(); try { fRef = new Float(s); } catch (NumberFormatException nfe) { System.err.println(nfe.toString()); }

float gz = fRef.floatValue(); double temp; temp = gz * 9.0 / 5.0 + 32.0; String s1 = String.valueOf(temp); fahrenhFeld.setText(s1); } });


92

fahrenhFeld.setEditable(true);

fahrenhFeld.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent ae) { Float fRef = null; String s = fahrenhFeld.getText(); try { fRef = new Float(s); } catch (NumberFormatException nfe) { System.err.println(nfe.toString()); }

float gz = fRef.floatValue(); double temp; temp = (gz - 32.0) * 5.0 / 9.0; String s1 = String.valueOf(temp); celsiusFeld.setText(s1); } });

Panel panel = new Panel(); panel.add(celsiusFeldLabel); panel.add(celsiusFeld); panel.add(fahrenhFeldLabel); panel.add(fahrenhFeld);

// Frame fenster = new Frame("Echo"); fenster.add(panel); fenster.pack(); fenster.setVisible(true); }}


93

b) Schreibe ein Programm, das die Temperturwerte von 0 bis 300 Fahrenheit-Graden in Schrittenvon 20 Fahrenheit-Graden in Celsius-Grade umrechnet und in eine Datei ausgibt.

import java.io.*;

public class FnachC{ public static void main(String args[]) { double fahr, celsius; double uWert, oWert, schritt; uWert = 0.0; oWert = 300.0; schritt = 20.0; fahr = uWert;

try { PrintWriter aus = new PrintWriter( new BufferedWriter( new FileWriter("test.txt")));

while (fahr <= oWert) { celsius = 5.0 * (fahr - 32.0) / 9.0; aus.println(fahr + " " + celsius); fahr += schritt; }

aus.close(); } catch (IOException a) { System.out.println("Fehler: " + a); System.exit(0); } }}


94

3. Aufgabe

Schreibe ein Programm, das das folgende Fenster erzeugt:

Beim Aktivieren (Drücken einer der Schaltknöpfe soll die Hintergrundfarbe gemäß der auf denSchaltknöpfen angegebenen Farbe sich ändern, z.B.: „Beim Drücken des mit „rot“ beschriftetenSchaltknopfs, soll die Hintergrundfarbe des Fensters „rot“ werden.

import java.awt.*;import java.awt.event.*;

public class Ueb603 extends Frame{ Button b1 = new Button("rot"); Button b2 = new Button("blau"); Button b3 = new Button("gruen"); Button b4 = new Button("pink"); Button b5 = new Button("orange"); Button b6 = new Button("gelb"); Button b7 = new Button("cyan");

public Ueb603() { // setLayout(new FlowLayout(FlowLayout.LEFT,20,20)); setLayout(new FlowLayout()); setBackground(Color.lightGray); b1.addActionListener(new B1L()); b2.addActionListener(new B2L()); b3.addActionListener(new B3L()); b4.addActionListener(new B4L()); b5.addActionListener(new B5L()); b6.addActionListener(new B6L()); b7.addActionListener(new B7L()); add(b1); add(b2); add(b3); add(b4); add(b5); add(b6); add(b7); // pack(); }


95

public class B1L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.red); } }

public class B2L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.blue); } }

public class B3L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.green); } }

public class B4L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.pink); } }

public class B5L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.orange); } }

public class B6L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.yellow); } }

public class B7L implements ActionListener { public void actionPerformed(ActionEvent ae) { setBackground(Color.cyan); } }


96

public static void main(String args[]) { Frame f = new Ueb603();

f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { // f.setVisible(false); System.exit(0); } });

f.setSize(100,150); f.setVisible(true); }}

4. Aufgabe

Gegeben ist die folgende Darstellung einer grafischen Benutzeroberfläche mit Checkbox-Komponenten:

Label und Status der jeweils zuletzt aktivierten Komponente sollen in das im oberen Teil derDarstellung befindliche Textfeld eingetragen werden.Realisiere die Inplementierung der vorliegendenen Darstellung.


public class Ueb703 extends Frame{ TextField t = new TextField(100); Checkbox cb1 = new Checkbox("Checkbox 1"), cb2 = new Checkbox("Checkbox 2",true), cb3 = new Checkbox("Checkbox 3",false);


97

public Ueb703() { // setLayout(new FlowLayout(FlowLayout.LEFT,20,20)); setLayout(new BorderLayout()); Panel p = new Panel(); p.setLayout(new GridLayout(3,1)); setBackground(Color.lightGray); t.setEditable(true); cb1.addItemListener(new CBL()); cb2.addItemListener(new CBL()); cb3.addItemListener(new CBL()); add(t); p.add(cb1); p.add(cb2); p.add(cb3); add("North",t); add("Center",p); }

public class CBL implements ItemListener { public void itemStateChanged(ItemEvent ie) { Checkbox cb = (Checkbox) ie.getItemSelectable(); t.setText(cb.getLabel() + ": " + cb.getState()); System.out.println(cb.getLabel() + ": " + cb.getState()); } }

public static void main(String args[]) { Ueb703 f = new Ueb703();




98

5. Aufgabe

Die folgende Darstellung zeigt ein Textfeld, dann auf der linken Seite eine CheckboxGroup mit dreiRadio-Buttons, der auf der rechten Seite einen freien Bereich zur Hintergrund-Darstellung der jeweisüber einen Radiobutton ausgewählten Farbe folgt.

Realisiere die Implementierung der vorliegenden Darstellung.


public class Ueb704 extends Frame{ TextField t = new TextField(100); CheckboxGroup cbg = new CheckboxGroup();

public Ueb704() { // setLayout(new FlowLayout(FlowLayout.LEFT,20,20));

setLayout(new BorderLayout()); Panel p = new Panel(); p.setLayout(new GridLayout(3,1)); Checkbox cb1 = new Checkbox("rot",cbg,false); Checkbox cb2 = new Checkbox("blau",cbg,false); Checkbox cb3 = new Checkbox("gruen",cbg,false); // Checkbox cb4 = new Checkbox("pink",cbg,false); // Checkbox cb5 = new Checkbox("orange",cbg,false); add("North",t); cb1.addItemListener(new CBIL()); cb2.addItemListener(new CBIL()); cb3.addItemListener(new CBIL()); // cb4.addItemListener(new CBIL()); // cb5.addItemListener(new CBIL()); p.add(cb1); p.add(cb2); p.add(cb3); // p.add(cb4); // p.add(cb5); add("West",p); }


99

public class CBIL implements ItemListener { public void itemStateChanged(ItemEvent ie) { Checkbox cb = (Checkbox) ie.getItemSelectable();

if (cb.getLabel() == "rot") { if (cb.getState()) { t.setText("Radio Button rot"); setBackground(Color.red); } }

if (cb.getLabel() == "blau") { if (cb.getState()) { t.setText("Radio Button blau"); setBackground(Color.blue); } }

if (cb.getLabel() == "gruen") { if (cb.getState()) { t.setText("Radio Button gruen"); setBackground(Color.green); } }

/* if (cb.getLabel() == "pink") { if (cb.getState()) { t.setText("Radio Button pink"); setBackground(Color.pink); } }

if (cb.getLabel() == "orange") { if (cb.getState()) { t.setText("Radio Button orange"); setBackground(Color.orange); } } */ } }


100



f.setBackground(Color.lightGray); f.setSize(200,200); f.setVisible(true); }}

6. Aufgabe

Das folgende Fenster einer grafischen Benutzeroberfläche

zeigt ein Fenster mit einem Textfeld, dem ein Auswahlmenü folgt. Darunter befindet sich ein Bereichzur Darstellung der ausgewählten Farben im Hintergrund. Es sollen folgende Farben über dasAuswahlmenü ausgewählt werden können: „rot“, „blau“, „gruen“, „orange“, „pink“, „gelb“, „cyan“. Dieaktivierte Auswahl ist über Index und ItemEvent im Textfeld zu protokollieren.Realisiere eine Implementierung der vorliegenden Darstellung.


public class Ueb705 extends Frame{ TextField t = new TextField(100); Choice auswahl = new Choice();

public Ueb705() { auswahl.addItem("rot"); auswahl.addItem("blau"); auswahl.addItem("gruen"); auswahl.addItem("pink"); auswahl.addItem("orange"); auswahl.addItem("gelb"); auswahl.addItem("cyan"); t.setEditable(false); setLayout(new BorderLayout()); add("North",t); add("Center",auswahl); // pack(); auswahl.addItemListener(new AuswMerkmL()); }


101

class AuswMerkmL implements ItemListener { public void itemStateChanged(ItemEvent e) { t.setText("Index: " + auswahl.getSelectedIndex() + " " + e.toString()); if (auswahl.getSelectedItem() == "rot") { setBackground(Color.red); } else if (auswahl.getSelectedItem() == "blau") { setBackground(Color.blue); } else if (auswahl.getSelectedItem() == "gruen") { setBackground(Color.green); } else if (auswahl.getSelectedItem() == "pink") { setBackground(Color.pink); } else if (auswahl.getSelectedItem() == "orange") { setBackground(Color.orange); } else if (auswahl.getSelectedItem() == "gelb") { setBackground(Color.yellow); } else if (auswahl.getSelectedItem() == "cyan") { setBackground(Color.cyan); } } }


f.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } });



102

7. Aufgabe

Die vorliegende Darstellung zeigt ein Fenster einer grafischen Benutzeroberfläche.

Das Fenster besteht aus einem linken und rechten Teil. Im linken Teil befindet sich eine „List“-Komponente. Die Liste soll zunächst die Einträge „rot“, „blau“, „gruen“, „pink“ umfassen. WeitereEinträge sollen über Aktivierung derSchlatfläche mit dem Label „Test“ übernommen werden. DieseEintäge sind: „orange“, „pink“, „gelb“, „cyan“. Auf der rechten Seite des Fensters ist eine „TextArea“dargestellt. In diesen Textbereich sollen jeweils die ausgewählten (aktivierten) Einträge aus derKomponente List, wie die Abbildung zeigt, übernommen werden.Realisiere eine Implementierung des vorliegenden Fensters im Rahmen einer grafischenBenutzeroberfäche.


public class Ueb706 extends Frame{ String[] farben = {"rot","blau","gruen","pink","orange", "gelb","cyan"}; List lst = new List(6,true); Button b = new Button("Test"); TextArea t = new TextArea(farben.length,10); int zaehler = 0;

public Ueb706() { setLayout(new GridLayout(1,2)); // setLayout(new FlowLayout()); Panel p1 = new Panel(); p1.setLayout(new BorderLayout()); Panel p2 = new Panel(); t.setEditable(false);

for (int i = 0; i < 4; i++) lst.addItem(farben[zaehler++]);

p2.add(t); // add("North",t); p1.add("Center",lst); p1.add("South",b); // add(t); // add(lst); // add(b); add(p1); add(p2); lst.addItemListener(new LL()); b.addActionListener(new BL()); }


103

public class LL implements ItemListener { public void itemStateChanged(ItemEvent ie) { t.setText(" "); String[] items = lst.getSelectedItems(); for (int i = 0; i < items.length; i++) t.append(items[i] + "\n"); } }

class BL implements ActionListener { public void actionPerformed(ActionEvent e) { if (zaehler < farben.length) { lst.addItem(farben[zaehler++],0); } } }





104

Uebung 13

1. Aufgabe

Das folgende Fenster soll erzeugt werden:

Das Fenster besteht aus

- drei Schiebereglern. Die Schieberegler sollen den Anfangswert 0 bis zum Höchstwert 255abdecken. Der linke Schieberegler dient zum Einstellen der Farbe „rot“, der mittlere zumEinstellen der Farbe „grün“, der rechte Schieberegler dient zum einstellen der Farbe blau. Die dreiFarben bilden die Grundlage des RBG-Farbmodells. Der wert 0 bedeutet, daß diese Grundfarbenicht in das Farbmodell eingeht, der Wert 255 zeigt die maximale Intensität dieser Farbe an. RGB-Farben werden durch das Tripel (r,g,b) dargestellt, die den jeweiligen Anteil der jeweiligenGrundfarbe in der Reihenfolge „rot“, gruen“, blau darstellen. Je nach Position des Schiebers solldas rechte Zeichenfeld die Hintergrundfarben annehmen, die dem jeweiligen Anteil an derGrundfarbe gemäß dem RBG-Farbmodell entspricht.

- drei Textfeldern. Die Textfelder enthalten den Wert des Schiebers der Schieberegler zugeordnet.Die über den Textfeldern angegebenen Labels zeigen die Zugehörigkeit zum jeweiligenSchieberegler an.

- einem Zeichenfeld, das durch seine Hintergrundfarbe die Mischung der Anteile der Farben nachdem RBG-Farbmodell anzeigt.

- einer mit Ruecksetzen beschriftete Schaltfläche. Das Drücken dieses Button bewirkt dasRuecksetzen des Schiebers und das Eintragen des Werts 0 in die Textfelder. Der Hintergrund desZeichenfelds wird auf Color.lightGray gesetzt.


public class Ueb91 extends Frame{ Scrollbar vsbRot = new Scrollbar(Scrollbar.VERTICAL,0,10,0,255); Scrollbar vsbGruen = new Scrollbar(Scrollbar.VERTICAL,0,10,0,255); Scrollbar vsbBlau = new Scrollbar(Scrollbar.VERTICAL,0,10,0,255); Canvas z = new Canvas(); TextField t1 = new TextField(10); TextField t2 = new TextField(10); TextField t3 = new TextField(10); int r = 0; int g = 0; int b = 0; Button schalter = new Button("Ruecksetzen"); // static Ueb91 f = new Ueb91();


105

public Ueb91() { setLayout(new BorderLayout()); Panel p1 = new Panel(); p1.setLayout(new GridLayout(1,3)); // Scrollbar vsbRot = new Scrollbar(Scrollbar.VERTICAL,0,10,0,255); vsbRot.addAdjustmentListener(new VsbRotAL()); // Scrollbar vsbGruen = new Scrollbar(Scrollbar.VERTICAL,0,10,0,255); vsbGruen.addAdjustmentListener(new VsbGruenAL()); // Scrollbar vsbBlau = new Scrollbar(Scrollbar.VERTICAL,0,10,0,255); vsbBlau.addAdjustmentListener(new VsbBlauAL()); p1.add(vsbRot); p1.add(vsbGruen); p1.add(vsbBlau); add("West",p1); Panel p2 = new Panel(); p2.setLayout(new GridLayout(6,1)); Label t1L = new Label("rot"); // t1.setEditable(false); Label t2L = new Label("gruen"); // TextField t2 = new TextField(10); t2.setEditable(false); Label t3L = new Label("blau"); // TextField t3 = new TextField(10); t3.setEditable(false); p2.add(t1L); p2.add(t1); p2.add(t2L); p2.add(t2); p2.add(t3L); p2.add(t3); add("Center",p2); Panel p3 = new Panel(); // p3.setSize(100,100); p3.setLayout(new BorderLayout()); // schalter.addActionListener(new BL()); p3.add("South",schalter); z.setSize(100,100); z.setBackground(Color.lightGray); p3.add("Center",z); add("East",p3); // pack(); }

public class VsbRotAL implements AdjustmentListener { public void adjustmentValueChanged(AdjustmentEvent e) { // System.out.println("Wert: " + e.getValue()); r = e.getValue(); String s = String.valueOf(r); t1.setText(s); Color farbe = new Color(r,g,b); z.setBackground(farbe); } }


106

public class VsbGruenAL implements AdjustmentListener { public void adjustmentValueChanged(AdjustmentEvent e) { g = e.getValue(); String s = String.valueOf(g); t2.setText(s); Color farbe = new Color(r,g,b); z.setBackground(farbe); // System.out.println("Wert: " + e.getValue()); } }

public class VsbBlauAL implements AdjustmentListener { public void adjustmentValueChanged(AdjustmentEvent e) { String s = String.valueOf(b); t3.setText(s); b = e.getValue(); Color farbe = new Color(r,g,b); z.setBackground(farbe); // System.out.println("Wert: " + e.getValue()); } }

public class BL implements ActionListener { public void actionPerformed(ActionEvent e) { t1.setText("0"); t2.setText("0"); t3.setText("0"); vsbRot.setValue(0); vsbGruen.setValue(0); vsbBlau.setValue(0); z.setBackground(Color.lightGray); r = 0; b = 0; g = 0; } }



f.setSize(300,200); f.setBackground(Color.lightGray); f.setVisible(true); }}


107

2. Aufgabe

Gesucht ist das Java-Programm, das eine grafische Benutzeroberfläche für ein bekanntes Spielimplementiert. Das Spiel besteht in dem wechselnden Einträgen von Kreuzen und Kreisen in einzweidimensionales Gitter, das über das folgende Eingabefenster durch Betätigen des Schaltknopfes„go“ mit den in den beiden Textfeldern angegebenen Zeilen und Spalten erscheinen soll.

In das zweidimensionale Gitter sollen die Gitterzellen Zeichenflächen („Canvas“) bilden, in dieabwechselnd ein Kreuz und danach ein Kreis eingetragen werden muß. „Kreuz“ und „Kreis“ werden indie leeren Zeichenflächen abwechselnd nach einem Mouse-Klick auf die Zeichenfäche eingetragen,bis alle Zellen gefüllt sind. Das Fenster mit dem Titel „Das Spiel selbst“ kann geschlossen werden, mit„go“ kann ein neuer Versuch gestartet werden.


public class Ueb101 extends Frame{ TextField zeilen = new TextField("3"); TextField spalten = new TextField("3");

public Ueb101() { setTitle("Toe Test"); Panel p = new Panel(); p.setLayout(new GridLayout(2,2)); p.add(new Label("Zeilen",Label.CENTER)); p.add(zeilen); p.add(new Label("Spalten",Label.CENTER)); p.add(spalten); add(p,BorderLayout.NORTH); Button b = new Button("go"); b.addActionListener(new BL()); add(b,BorderLayout.SOUTH); } static final int BLANK = 0; static final int XX = 1; static final int OO = 2;


108

class ToeDialog extends Dialog { // b: Anzahl der Zellen in der Breite // h: Anzahl der Zellen in der Hoehe int wende = XX;

public ToeDialog(int b, int h) { super(Ueb101.this,"Das Spiel selbst",false); setLayout(new GridLayout(b,h)); for (int i = 0; i < b * h; i++) add(new ToeButton()); setSize(b * 50, h * 50);

addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { dispose(); } }); }

class ToeButton extends Canvas { int zustand = BLANK;

ToeButton() { addMouseListener(new ML()); }

public void paint(Graphics g) { int x1 = 0; int y1 = 0; int x2 = getSize().width - 1; int y2 = getSize().height - 1; g.drawRect(x1, y1, x2, y2); x1 = x2 / 4; y1 = y2 / 4; int breite = x2 / 2; int hoehe = y2 / 2;

if (zustand == XX) { g.drawLine(x1,y1,x1 + breite, y1 + hoehe); g.drawLine(x1,y1 + hoehe,x1 + breite,y1); }

if (zustand == OO) { g.drawOval(x1,y1,x1 + breite / 2,y1 + hoehe / 2); } }


109

class ML extends MouseAdapter { public void mousePressed(MouseEvent e) { if (zustand == BLANK) { zustand = wende; wende = (wende == XX ? OO : XX); } else zustand = (zustand == XX ? OO : XX); repaint(); } } } }

class BL implements ActionListener { public void actionPerformed(ActionEvent e) { Dialog d = new ToeDialog(Integer.parseInt(zeilen.getText()), Integer.parseInt(spalten.getText())); d.show(); } }



f.setSize(200,100); // f.setBackground(Color.lightGray); f.setVisible(true); }}


110

3. Aufgabe

Das folgende Fenster ist in 4 Bereiche aufgeteilt. Die farbigen Flächen können auf alle möglichenLow-Level-Ereignisse reagieren. Die weiße Fläche reagiert nicht. Das jeweilige „Low-Level-Ereigniswird jeweils in Zeile 1 („AWTEvent“) der farbigen Flächen protokolliert.Zeile 2 zeigt jeweils das„ComponentEvent“ an. Zeile 3 und Zeile 4 stehen jeweils für die Ereigne MouseEvent bzw.MouseMotionEvent. Zeile 3 zeigt geweils das FocusEvent und Zeile 7 das KeyEvent. Zu Beginn hatdas Fenster folgende Gestalt:

Im Laufe der weiteren Verarbeitung kann das Fenster dann z.B. folgende Gestalt annehmen.


class Display{ public static final int EVENT = 0, COMPONENT = 1, MOUSE = 2, MOUSE_MOVE = 3, FOCUS = 4, KEY = 5, ACTION = 6, LAST = 7; public String[] ereignisse;

Display() { ereignisse = new String[LAST]; for (int i = 0; i < LAST;i++) ereignisse[i] = new String(); }


111

public void show(Graphics g) { for (int i = 0; i < LAST; i++) g.drawString(ereignisse[i],0,10 * i +10); }}

class ErmPanel extends Panel{ Color farbe; int id; Display ausgabe = new Display();

public ErmPanel(int i, Color f) { id = i; farbe = f; setLayout(new BorderLayout()); add(new MeinSchalter(),BorderLayout.SOUTH); addComponentListener(new CL()); addFocusListener(new FL()); addKeyListener(new KL()); addMouseListener(new ML()); addMouseMotionListener(new MML()); }

public void update(Graphics g) { paint(g); }

public void paint(Graphics g) { g.setColor(farbe); Dimension groesse = getSize(); g.fillRect(0,0,groesse.width,groesse.height); g.setColor(Color.black); ausgabe.show(g); }

/* Beim Weiterreichen einer Nachricht wird innerhalb der Nachrichtenquelle die Methode processEvent aufgerufen. Diese verteilt Nachrichten anhand ihres Typs an spezialisierte Methoden, deren Name sich nach dem Typ der zugehörigen Ereignisquelle richtet, z.B. processActionEvent. processEvent bzw. processActionEvent wird nur aufgerufen, wenn der entsprechende Ereignistyp für die Ereignisquelle aktiviert wurde public void processEvent(AWTEvent e) { ausgabe.ereignisse[Display.EVENT] = e.toString(); repaint(); super.processEvent(e); } */


112

class CL implements ComponentListener { public void componentMoved(ComponentEvent e) { ausgabe.ereignisse[Display.COMPONENT] = "componentMoved"; repaint(); }

public void componentResized(ComponentEvent e) { ausgabe.ereignisse[Display.COMPONENT] = "componentResized"; repaint(); }

public void componentHidden(ComponentEvent e) { ausgabe.ereignisse[Display.COMPONENT] = "componentHidden"; repaint(); }

public void componentShown(ComponentEvent e) { ausgabe.ereignisse[Display.COMPONENT] = "componentShown"; repaint(); } }

class FL implements FocusListener { public void focusGained(FocusEvent e) { ausgabe.ereignisse[Display.FOCUS] = "focusGained"; repaint(); } public void focusLost(FocusEvent e) { ausgabe.ereignisse[Display.FOCUS] = "focusLost"; repaint(); } }

class KL implements KeyListener { public void keyPressed(KeyEvent e) { ausgabe.ereignisse[Display.KEY] = "keyPressed"; showCode(e); }

public void keyReleased(KeyEvent e) { ausgabe.ereignisse[Display.KEY] = "keyReleased"; showCode(e); }

public void keyTyped(KeyEvent e) { ausgabe.ereignisse[Display.KEY] = "keyTyped"; showCode(e); }


113

void showCode(KeyEvent e) { int code = e.getKeyCode(); ausgabe.ereignisse[Display.KEY] += KeyEvent.getKeyText(code); repaint(); } }

class ML implements MouseListener { public void mouseClicked(MouseEvent e) { requestFocus(); ausgabe.ereignisse[Display.MOUSE] = "mouseClicked"; showMouse(e); }

public void mousePressed(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE] = "mousePressed"; showMouse(e); }

public void mouseReleased(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE] = "mouseReleased"; showMouse(e); }

public void mouseEntered(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE] = "mouseEntered"; showMouse(e); }

public void mouseExited(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE] = "mouseExited"; showMouse(e); }

void showMouse(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE] += ", x = " + e.getX() + ", y = " + e.getY(); repaint(); } }

class MML implements MouseMotionListener { public void mouseDragged(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE] = "mouseDragged"; showMouse(e); }


114

public void mouseMoved(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE_MOVE] = "mouseMoved"; showMouse(e); }

void showMouse(MouseEvent e) { ausgabe.ereignisse[Display.MOUSE_MOVE] += ", x = " + e.getX() + ", y = " + e.getY(); repaint(); } }}

class MeinSchalter extends Button{ int klickZaehler; String label = " ";

public MeinSchalter() { addActionListener(new AL()); }

public void paint(Graphics g) { g.setColor(Color.green); Dimension groesse = getSize(); g.fillRect(0,0,groesse.width,groesse.height); g.drawRect(0,0,groesse.width - 1, groesse.height - 1); drawLabel(g); }

public void drawLabel(Graphics g) { FontMetrics fm = g.getFontMetrics(); int breite = fm.stringWidth(label); int hoehe = fm.getHeight(); int ascent = fm.getAscent(); int leading = fm.getLeading(); int horizMargin = (getSize().width - breite) / 2; int verMargin = (getSize().height - hoehe) / 2; g.setColor(Color.red); g.drawString(label,horizMargin, verMargin + ascent + leading); repaint(); }

class AL implements ActionListener { public void actionPerformed(ActionEvent e) { klickZaehler++; label = "Klick # " + klickZaehler + " " + e.toString(); repaint(); } }}


115

public class PR14165 extends Frame{ PR14165() { setLayout(new GridLayout(2,2)); add(new ErmPanel(1,Color.cyan)); add(new ErmPanel(2,Color.lightGray)); add(new ErmPanel(3,Color.yellow)); }

public static void main(String[] args) { PR14165 f = new PR14165();

f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } });



116

4. Aufgabe

Die folgende Abbildung

Zeigt einige der wesentlichen Komponenten einer grafischen Benutzeroberfläche. Dafür ist ein Java-Programm zu erstellen, das diese Komponenten der grafischen Benutzeroberfläche in einem Fensterrealisiert. Wie die Abbildung zeigt, soll ein Menüleiste mit dem Menü „Menue“ und ein Auswahlmenü(rechts unten) erstellt werden. Das „Menue“ soll die Einträge „Menue Merkmal 1, Menue Merkmal 2,Menue Merkmal 3“ und dann getrennt durch eine Linie den Eintrag „Datei Dialog ...“ zeigen. DasAktivieren von „Datei Dialog ...“ soll einen File-Dialog ermöglichen, allerdings ohne Konsequenzen(nur Anzeige des Dialogfensters). Das Auswahlmenü rechts unten soll die Einträge „Wahl Merkmal 1,Wahl Merkmal 2, Wahl Merkmal 3“ ermöglichen. Die Liste auf der rechten Seite soll 10 Einträge derangegebenen Art zeigen. Der Canvas auf der rechten Seite soll eine Linie zeigen, die drei Punkteverbindet. Die Punkte sind markiert und beschriftet. Die übrigen Komponenten sind durch dieBeschriftung in der vorliegenden Abbildung eindeutig bestimmt.

import java.awt.*;

public class Ueb121 extends Frame{ // boolean inAnApplet = true; final String dateiDialogMenueMerkmal = "Datei Dialog...";

public Ueb121() { Panel unteresPanel = new Panel(); Panel zentrPanel = new Panel(); setLayout(new BorderLayout()); //Setze den Menuebalken MenuBar mb = new MenuBar(); Menu m = new Menu("Menue"); m.add(new MenuItem("Menue Merkmal 1")); m.add(new CheckboxMenuItem("Menue Merkmal 2")); m.add(new MenuItem("Menue Merkmal 3")); m.add(new MenuItem("-")); m.add(new MenuItem(dateiDialogMenueMerkmal)); mb.add(m); setMenuBar(mb); // Fuege kleinere Dinge am Fenstergrund ein unteresPanel.add(new TextField("TextFeld")); unteresPanel.add(new Button("Button")); unteresPanel.add(new Checkbox("Checkbox")); Choice w = new Choice(); w.addItem("Wahl Merkmal 1"); w.addItem("Wahl Merkmal 2"); w.addItem("Wahl Merkmal 3");


117

unteresPanel.add(w); add("South", unteresPanel); // Fuege groessere Dinge in den mittleren Bereich des Fenster zentrPanel.setLayout(new GridLayout(1,2)); // Lege einen Canvas in der linken Spalte an zentrPanel.add(new meinCanvas()); // Lege ein Label und einen Textbereich in der rechten Spalte an Panel p = new Panel(); p.setLayout(new BorderLayout()); p.add("North", new Label("Label", Label.CENTER)); p.add("Center", new TextArea("TextArea", 5, 20)); zentrPanel.add(p); add("Center", zentrPanel);

// Lege eine Liste auf der rechten Seite des Fenster an List l = new List(3, false);

for (int i = 1; i <= 10; i++) { l.addItem("Listen-Element " + i); } add("East", l); }

public boolean action(Event event, Object arg) { // reagiert wird auf einen Datei-Dialog if (event.target instanceof MenuItem) { if (((String)arg).equals(dateiDialogMenueMerkmal)) { FileDialog fd = new FileDialog(this, "FileDialog"); fd.show(); } } return true; }

public boolean handleEvent(Event event) { // Schliessen des Fensters if (event.id == Event.WINDOW_DESTROY) { // if (inAnApplet) // { dispose(); } /* else { */ System.exit(0); // } } return super.handleEvent(event); }

public static void main(String args[]) { Ueb121 fenster = new Ueb121(); // fenster.inAnApplet = false; fenster.setTitle("AWT Komponenten"); fenster.pack(); fenster.show(); }}


118

class meinCanvas extends Canvas{ public void paint(Graphics g) { int w = size().width; int h = size().height; g.drawRect(0, 0, w - 1, h - 1); g.drawString("Canvas", (w - g.getFontMetrics().stringWidth("Canvas"))/2, 10); g.setFont(new Font("Helvetica", Font.PLAIN, 8)); g.drawLine(10,10, 100,100); g.fillRect(9,9,3,3); g.drawString("(10,10)", 13, 10); g.fillRect(49,49,3,3); g.drawString("(50,50)", 53, 50); g.fillRect(99,99,3,3); g.drawString("(100,100)", 103, 100); } // Ohne die folgende Spezifikationen, wird der Canvas moeglicherweise // nicht alles wiedergeben. public Dimension minimumSize() { return new Dimension(150,130); } public Dimension preferredSize() { return minimumSize(); }}

5. Aufgabe

Eine Textdatei (z.B. eine Java-Quelldatei) soll bearbeitet werden. Die Bearbeitung soll menügesteuerterfolgen. Dafür soll aus der Menüleiste das Menü „Datei“ mit folgenden Menüeinträgen: „Oeffnen,Schliessen, Sichern“ aufgerufen werden.Eine Aktivierung des Menü-Eintrags Oeffnen bewirkt die Aktion:

- Aufruf des Standard-File-Dialogs- Auswahl einer Datei über den File-Dilaog aus dem aktuellen Verzeichnis- Kopieren der Datei in einen Textbereich mit Zeilennumerierung, so wie es in der 5. Übung, 5.

Aufgabe bereits erfolgte.

„Schliessen“ bewirkt die Aktion: Die unter „Oeffnen“ ausgewählte Datei wird ohne Sicherunggeschlossen.„Sichern“ bewirkt die Aktion: Die unter „Oeffnen“ ausgewählte und in den Textbereich mit einembestimmten Format kopierte Datei wird aus dem Textbereich über den File-Dialog in eine speziellausgewählte Datei kopiert.

import java.awt.*;import java.awt.event.*;import java.io.*;

public class Ueb111 extends Frame{ TextField dateiN = new TextField(); TextField verzeichnis = new TextField(); TextArea textBereich; MenuBar mb = new MenuBar(); Menu m = new Menu("Datei"); MenuItem oeffnen = new MenuItem("Oeffnen"), schliessen = new MenuItem("Schliessen"), sichern = new MenuItem("Sichern");


119

String dateiName; LineNumberReader ein;

public Ueb111() throws IOException { super("Ueb111"); // Hinzufuegen ActionListener oeffnen.addActionListener(new OeffnenL()); schliessen.addActionListener(new SchliessenL()); sichern.addActionListener(new SichernL()); // Hinzufuegen Menue-Eintraege m.add(oeffnen); m.add(schliessen); m.add(sichern); mb.add(m); // Installiere MenuBalken setMenuBar(mb); this.show(); }

public void dateiDarstellen() throws IOException { String s = new String(); textBereich = new TextArea(s,24,80); try { ein = new LineNumberReader(new FileReader(dateiName)); while ((s = ein.readLine()) != null) { s = "/* " + ein.getLineNumber() + " */" + s + '\n'; textBereich.append(s); } textBereich.setFont(new Font("Helvetica",Font.PLAIN,10)); textBereich.setEditable(false); this.add("Center",textBereich); } catch ( FileNotFoundException a) { throw a; } catch ( IOException e ) { throw e; } this.show(); }

class OeffnenL implements ActionListener { public void actionPerformed(ActionEvent e) { FileDialog d = new FileDialog( Ueb111.this, "Welche Datei soll geoeffnet werden?"); d.setFile("*.java"); d.setDirectory("."); // Aktuelles Verzeichnis d.show(); dateiName = "*.*";

if ((dateiName = d.getFile()) != null) { dateiN.setText(dateiName); verzeichnis.setText(d.getDirectory()); try { Ueb111.this.dateiDarstellen(); } catch ( IOException a) { } }


120

else { dateiN.setText("Cancel wurde gedrueckt!"); verzeichnis.setText(""); } } }

class SichernL implements ActionListener { public void actionPerformed(ActionEvent e) { } }

class SchliessenL implements ActionListener { public void actionPerformed(ActionEvent e) { FileDialog d = new FileDialog(Ueb111.this, "Welche Datei soll gesichert werden?", FileDialog.SAVE); d.setFile("*.java"); d.setDirectory("."); // Aktuelles Verzeichnis d.show(); String datei = "*.*";

if ((datei = d.getFile()) != null) { dateiN.setText(datei); verzeichnis.setText(d.getDirectory()); } else { dateiN.setText("Cancel wurde gedrueckt!"); verzeichnis.setText(""); } } }

public static void main(String args[]) throws IOException { try { Ueb111 f = new Ueb111(); f.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); f.setSize(350,400); f.setVisible(true); } catch (IOException e) { System.out.println(e); } }}


121

Uebung 14

Conway's Game of Life

Game of Life ist eine Simulation, welche Zellen, die am Bildschirm als kleine Rechtecke, Pixel oderandere Grafiksymbole dargestellt. Jede einzelne Zelle kann entweder am Leben oder tot sein.(Dargestellt durch zwei unterschiedliche Farben) Ob eine einzelne Zelle am Leben ist oder nicht,entscheidet folgendes (Conway's) Regelwerk:

♦ Eine Zelle, die nicht am Leben ist wird genau dann geboren, wenn 3 Nachbarszellen am Lebensind.

♦ Eine Zelle, die bereits am Leben ist, kann nur dann überleben, wenn sie 2 oder 3 Nachbarzellenhat, die am Leben sind.

♦ (Jede Zelle hat 8 Nachbarzellen => Es sind auch diejenigen Zellen, die diagonal liegensogenannte Nachbarzellen)

Der Startwert einer Zelle ist eine Zufallsgröße. Sie können die Simulation entweder mit einem "totenRand" oder einem "Wrap-Around Rand" erstellen. "Toter Rand" bedeutet, daß eine Zelle die am Randoder einer Ecke des Feldes liegt, die nicht vorhandenen Nachbarzellen als "Tot" betrachtet; "WrapAround" bedeutet, daß die Randzellen diejenigen als Nachbarzellen betrachten, die am Spielfeldgegenüber liegen. (Testen Sie dies am folgenden Applet mit Gliders und ein- bzw. ausgeschaltetenWrap Around)


122

Aufgabenstellung:

Implementieren Sie eine Applikation, die ein Spielfeld von 100*100 Zellen simuliert. Eine Zelle hat eineGröße von 4x4 Pixel unddie Größe des gesamten Frames sollte sinnvollerweise ca. 415 * 470 Pixel betragen.

Der Button "Random" belegt das Spielfeld mit einer Zufallswerten.Der Button "Next" simuliert einen GenerationswechselDer Button "100 Steps" führt 100 Generationswechsel durch

Zusatzaufgabe:

Implementieren Sie einen Button, der das Spielfeld mit Gleitern besetzt (siehe Applet)Mit einem Checkbox-Element kann man "Wrap Around" ein- und ausschalten.

Hinweis:

Denken Sie bevor Sie zu programmieren beginnen darüber nach wie das "Rand-Problem" am bestenzu bewältigen ist (Sowohl "Toter Rand" als auch "Wrap-Around".)

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

public class Life extends Appletimplements ActionListener, WindowListener, ItemListener{

static final byte DEAD = (byte)0;static final byte ALIFE = (byte)1;

byte generation1[ ][ ];byte generation2[ ][ ];

Panel unten = new Panel ();Button next = new Button ("Next");Button random = new Button ("Random");Button gliders = new Button ("Gliders");Button steps = new Button ("100 Steps");Checkbox wrapAround = new Checkbox ("Wrap Around",true);static Color colorTab[] = {Color.black, Color.yellow};int x=100,y=100;

public void windowOpened(WindowEvent e) {}public void windowClosing(WindowEvent e) {System.exit(0);}public void windowClosed(WindowEvent e) {}public void windowIconified(WindowEvent e) {}public void windowDeiconified(WindowEvent e) {}public void windowActivated(WindowEvent e) {}public void windowDeactivated(WindowEvent e) {}

public void init (){

setLayout (new BorderLayout()); add ("South", unten); unten.setLayout (new FlowLayout ()); generation1 = new byte[x+2][y+2]; generation2 = new byte[x+2][y+2];

unten.add (random);unten.add (gliders);unten.add (next);unten.add (steps);unten.add (wrapAround);


123

random.addActionListener (this);gliders.addActionListener (this);next.addActionListener (this);steps.addActionListener (this);wrapAround.addItemListener (this);unten.setBackground (Color.yellow);wrapAround.setBackground (Color.yellow);setBackground (Color.black);for (int y=0;y<this.y+2;y++)

for (int x=0;x<this.x+2;x++)generation2[x][y]=generation1[x][y]=DEAD;

randomGeneration();}

public void actionPerformed (ActionEvent ae){

if (ae.getSource()==random) {randomGeneration ();

} else if (ae.getSource()==next) { nextGeneration ();} else if (ae.getSource()==steps) {

for (int i=0;i<100;i++) nextGeneration ();} else if (ae.getSource()==gliders) {

setGliders ();}

}

public void itemStateChanged(ItemEvent ie) { for (int x=1;x<=this.x;x++) { generation1[x][0]=DEAD; generation1[x][this.y+1]=DEAD; generation2[x][0]=DEAD; generation2[x][this.y+1]=DEAD; } for (int y=0;y<this.y+2;y++) { generation1[0][y]=DEAD; generation1[this.x+1][y]=DEAD; generation2[0][y]=DEAD; generation2[this.x+1][y]=DEAD; } }

public void paint (Graphics g) { for (int y=1;y<=this.y;y++) { for (int x=1;x<=this.x;x++) { g.setColor (colorTab[generation1[x][y]]);

g.fillRect (x*4,y*4,3,3);}

} }


124

void setGliders (){

killAll ();long gliderData[] = {0x0436, 0x0562, 0x0361, 0x0235};for (int count=0;count<10;count++) {

int x = (int)(Math.random()*(this.x-10)+5);int y = (int)(Math.random()*(this.y-10)+5);long glider = gliderData [(int)(Math.random()*4)];for (int i=0;i<4;i++) {

for (int j=0;j<4;j++) {generation1 [x+i][y+j] = (byte)(glider&1);glider>>=1;

}}

}paint(getGraphics());

}

void killAll (){

for (int y=0;y<this.y+2;y++) {for (int x=0;x<this.x+2;x++) {

generation1[x][y] = DEAD;}

}}

void randomGeneration (){

for (int j=1;j<=y;j++) {for (int i=1;i<=x;i++) {

generation1 [i][j] = (Math.random()<0.5)?ALIFE:DEAD; }}repaint ();

}

void nextGeneration (){ if (wrapAround.getState()) { for (int x=1;x<=this.x;x++) { generation1[x][0]=generation1[x][this.y]; generation1[x][this.y+1]=generation1[x][1]; } for (int y=0;y<this.y+2;y++) { generation1[0][y]=generation1[this.x][y]; generation1[this.x+1][y]=generation1[1][y]; } }

Graphics g = getGraphics(); byte sum,result; for (int y=1;y<=this.y;y++) { sum = generation1[0][y-1]; sum += generation1[0][y ]; sum += generation1[0][y+1]; sum += generation1[1][y-1]; sum += generation1[1][y ]; sum += generation1[1][y+1];


125

for (int x=1;x<=this.x;x++) { sum += generation1[x+1][y-1]; sum += generation1[x+1][y ]; sum += generation1[x+1][y+1];

if (sum==3) result = ALIFE; else if (sum==4) result = generation1[x][y]; else result = DEAD; generation2[x][y] = result;

if (result != generation1[x][y]) {g.setColor (colorTab [result]);g.fillRect (x*4,y*4,3,3);

} sum -= generation1[x-1][y-1]; sum -= generation1[x-1][y ]; sum -= generation1[x-1][y+1]; } } byte swap[][] = generation1; generation1 = generation2; generation2 = swap;}

static public void main (String args[]){

Frame life = new Frame("Game of Life");Life applet = new Life();applet.init();life.add (applet);life.addWindowListener (applet);life.setBounds (100,100,415,470);life.setVisible (true);

}}


126

15. Übung

1. Aufgabe

Entwurf und Implementierung eines Programms zur Darstellung einer Funktion y = f(x), z.B.

y e xx= −0 3 2. cos( ) . Die Darstellung der Funktion soll auf dem Bildschirm erfolgen und dort folgende

Form annehmen:

Die Funktion ist in einem Rechteck darzustellen, das die maximale Bildschirmbreite undBildschirmhöhe umfaßt. Zur Einbettung ist der Ursprung des Koordinatensystems auf die AngabenXBreiteMin,. XBreiteMax, YHoeheOben, YHoeheUnten abzustimmen. Die vorliegende Skizze zeigtbspw. die Lage des Koordinatensystems für folgende Angaben:

XBreiteMin = -2, XBreiteMax = 2, YHoeheOben = 1, YHoeheUnten = -1

Die Angaben zu der Einteilung der Koordinatenachsen sind im vorliegenden Fall

DX = 0.5 bzw DY = 0.5

Die angegebenen Abmessungen sind im Dialog vom Benutzer des Programms einzugeben. DieEingabe erfolgt in sog. Weltschirmkoordinaten, d.h. unabängig von der tatsächlichen Darstellung inden vorliegenden Bildschirmkoordinaten. Entwurf und Implementierung einer Umrechnungsroutine(„Weltschirmkoordinaten in Bildschirmkoordinaten“) ist Bestandteil der Aufgabe. Die Benutzereingabebestimmt weiterhin die Lage des Ursprungs des Koordinatensystems. So führt bspw.

XBreiteMin = 0, XBreiteMax = 4, YHoeheOben = 1, YHoeheUnten = -1

zu der folgenden Darstellung:


127

Schließlich gibt der Benutzer noch die Anzahl der Stützstellen vor. Für diese Stellen wird derFunktionswert berechnet und nach der Umrechnung (Weltschirmkoordinaten in Bildschirmkoordinaten)in die Graphik eingetragen.

a) Zunächst sollen nur die Koordinatenachsen gemäß der Vorgabe dargestellt werden. Die dafürnotwendigen Funktionen sind zu entwerfen und zu implementieren.

b) Danach soll die „Funktion“ eingezeichnet werden. Die Funktion ist Bestandteil des Programms.

c) Ein Beschriftung der Koordinatenachsen ist vorzunehmen. Die Beschriftung soll mindestens dieWerte zu

XBreiteMin, XBreiteMax, YHoeheOben, YHoeheUnten

enthalten.


class Ueb152 extends Frame{ final static double MAXX = 5.0; final static double MAXY = 1;

Ueb152 () { super ("Funktions-Plotter"); setBounds (40,40,640,480); addWindowListener (new WindowAdapter() {

public void windowClosing (WindowEvent we) {

System.exit(0); } });

}

public double function (double x) { return Math.sin(x) * Math.cos(x); // return Math.sin(x)*Math.sin(x)*Math.sin(x); // return Math.tan(x)/Math.pow(Math.sin(x),3); }


128

public double screenToWorldX(int x) {

double midX = getSize().width/2;return ((x-midX)/midX)*MAXX;

}

public int worldToScreenX (double x) {

double midX = getSize().width/2; return (int)((x/MAXX)*midX+midX);}

public int worldToScreenY (double y) {

double midY = getSize().height/2-30; return getSize().height - (int)((y/MAXY) * midY + midY)-20;}

public void paint (Graphics g) {

// horizontale Linie g.drawLine (

0, worldToScreenY(0), getSize().width, worldToScreenY(0) );

// Verticale Linieg.drawLine (

worldToScreenX(0),worldToScreenY(MAXY),worldToScreenX(0),worldToScreenY(-MAXY)

); // Unterteilung der horizontalen Linie in 1er Schritte for (int i=(int)-MAXX;i<=(int)MAXX;i++)

{g.drawLine (

worldToScreenX(i),worldToScreenY(0)-5,worldToScreenX(i),worldToScreenY(0)+5

);}// Unterteilung der verticalen Linie in 1er Schrittefor (int i=(int)-MAXY;i<=(int)MAXY;i++) {

g.drawLine (worldToScreenX(0)-5,worldToScreenY(i),worldToScreenX(0)+5,worldToScreenY(i)

);}// Zeichnen der Funktionfor (int i=10;i<getSize().width-10;i++) {

double x1 = screenToWorldX(i);double x2 = screenToWorldX(i+1);double y1 = function (x1);double y2 = function (x2);


129

g.drawLine (i,worldToScreenY(y1),i+1,worldToScreenY(y2)

);}

}


Ueb152 test = new Ueb152();test.show();

}}

2. Aufgabe

Darstellung des Random-Walk-Algorithmus in der Simulationstechnik am Beispiel des „drunkenSailor“. Ein Seemann mit viel Alkohol im Blut verläßt eine Kneipe und mach sich auf dem Weg zuseinem Schiff:

Die Kneipe liegt in der Mitte des Darstellungsrahmens. Der Betrunkene macht immer gleich großeSchritte (25 Pixeleinheitem) nur die Richtung ändert sich dauernd. Zur Vorhersage der Richtungbenutzt man eine Zufallszahl zwischen 0 und 359 (Winkel zwischen Bewegungsrichtung und y-Achse).Schreibe ein Applet, das die Position des Betrunkenen auf dem Weg von der Kneipe berechnet, dieDarstellung soll über die nächstliegenden Bildschirmkoordinaten erfolgen. Sobald der Heimkehrer diezur Verfügung stehende Zeichenfläche verlassen hat, wird in der Bildmitte eine weitere Saufkumpanauf den Weg geschickt, der seine Spur in einer anderen Farbe hinterläßt (insgesamt 16 Heimkehrer).

import java.awt.*;import java.util.*;

public class BetrSeemann extends java.applet.Applet implements Runnable{ Thread faden; int xMax, yMax, xPos, yPos; Random rand = new Random(); Color farbe;


130

// Eigene Methoden int zRand(int mod) { return Math.abs(rand.nextInt() % mod); }

// Ueberschriebene Methoden public void init() { setBackground(Color.lightGray); xMax = size().width; yMax = size().height; xPos = xMax / 2; yPos = yMax / 2; }

public void start() { if (faden == null) { faden = new Thread(this); faden.start(); } }

public void run() { for (int i = 1; i <= 16; i++) { farbe = new Color(255 / i, 16 * i - 1, (16 * i) % 255); repaint(); try { Thread.sleep(1000); } catch(InterruptedException e) { } xPos = xMax / 2; yPos = yMax / 2; } }

public void update(Graphics g) { g.setColor(farbe); do { int winkel = zRand(359); g.drawLine(xPos,yPos, (int) (xPos+25*Math.cos(winkel*Math.PI/180.0)), (int) (yPos+25*Math.sin(winkel*Math.PI/180.0))); xPos = (int) (xPos+25*Math.cos(winkel*Math.PI/180.0)); yPos = (int) (yPos+25*Math.sin(winkel*Math.PI/180.0)); } while ((xPos < xMax) && (xPos > 0) && (yPos < yMax) && (yPos > 0)); }

public void paint(Graphics g) { g.setColor(farbe); }}


131

16. Übung

1. Aufgabe

Schreibe ein Programm, das eine Textdatei (z.B. *.java“) aus dem aktuellen Verzeichnis über eine„TextArea“ auf ein Fenster des Bildschirms abbildet. Jede Zeile soll dabei durchnummeriert werden.Die Nummerierung ist in Kommentarzeilen einzuschließen. Zur Ermittlung der abzubildenen Datei istein „FileDialog“ heranzuziehen. Die Abbildung soll ein einem speziellen Font „Helvetica“, im StilFont.Plain“ und mit der Fontgröße 10 erfolgen. Das Fenster soll nach der Anzeige vergrößert werdenkönnen und schließlich auch wieder geschlossen werden können.

import java.awt.*;import java.io.*;import java.awt.event.*;

public class Aufg1 extends Frame{ private LineNumberReader ein;

public Aufg1() throws IOException { FileDialog d = new FileDialog( this, "Welche Datei soll geoeffnet werden?"); d.setFile("*.java"); d.setDirectory("."); // Aktuelles Verzeichnis d.show(); String datei = "*.*";

if ((datei = d.getFile()) != null) { try { ein = new LineNumberReader(new FileReader(datei)); } catch ( FileNotFoundException a) { throw a; }

// dateiName.setText(datei); // verzeichnis.setText(d.getDirectory()); try { dateiDarstellen(); } catch (IOException a ) { throw a; } } else { } }


132

public void dateiDarstellen() throws IOException { try { String s = new String(); TextArea textBereich = new TextArea(s,24,80);

while ((s = ein.readLine()) != null) { s = "/* " + ein.getLineNumber() + " */ " + s + '\n'; textBereich.append(s); }

textBereich.setFont(new Font("Helvetica",Font.PLAIN,10)); textBereich.setEditable(false); this.add("Center",textBereich); } catch (IOException e) { } this.show(); }

public static void main(String args[]) throws IOException { Frame f = new Aufg1();


f.setVisible(true); }}


133

2. Aufgabe

Erstelle eine Java-Anwendung, die ein Fenster mit einem grünen Oval zeigt:

Der Fensterinhalt soll als Button fungieren. Falls dieser Button gedrückt wird (Mausklick) soll auf derKonsole „Befehlsausführung“ ausgegeben werden. Falls mit der Maus die Fensterfläche überstrichenwird, soll der Hintergrund „rot“ werden. Falls die Maus die Fensterfläche verlässt, soll der Anfangs-zustand, d.h. ein Hintergrung mit der Farbe „orange“, wiederhergestellt werden.


class MeinButton extends Button { Aufg2 a;

public MeinButton() { super(); setBackground(Color.orange); // Aktivierung des Filters enableEvents(AWTEvent.MOUSE_EVENT_MASK); }

public MeinButton(Aufg2 a) { this(); this.a = a; }

protected void processEvent(AWTEvent ae) { if (ae.getID() == MouseEvent.MOUSE_ENTERED) { setBackground(Color.red); } else if (ae.getID() == MouseEvent.MOUSE_EXITED) { setBackground(Color.orange); } else if (ae.getID() == MouseEvent.MOUSE_CLICKED) { a.test(); } super.processEvent(ae); }


134

public void paint(Graphics g) { Rectangle r = getBounds(); g.setColor(Color.green); g.fillOval(2,2,r.width-4,r.height-4); } }

public class Aufg2{ public void test() { System.out.println("Befehsausfuehrung"); }

public static void main(String [] args) { Aufg2 anw = new Aufg2(); Frame f = new Frame("ButtonTest");


MeinButton mb = new MeinButton(anw); f.add(mb); f.setSize(100,100); f.setVisible(true); }}


135

3. Aufgabe

Lies zwei ganze Zahlen über eine Eingabezeile ein und bestimme das Maximum dieser Zahlen. DieAusgabe soll auf die Konsole erfolgen.

// import java.lang.*;import java.io.*;import java.util.*;

public class MaxTest{ public static void main(String [ ] args) { BufferedReader ein = new BufferedReader( new InputStreamReader(System.in)); String eineZeile; StringTokenizer str; int x; int y; System.out.println("Eingabe 2er ganzen Zahlen auf eine Zeile");

try { eineZeile = ein.readLine(); str = new StringTokenizer(eineZeile); if (str.countTokens() != 2) throw new NumberFormatException(); x = Integer.parseInt(str.nextToken()); y = Integer.parseInt(str.nextToken()); System.out.println("Max: " + Math.max(x,y)); } catch(Exception e) { System.err.println( "Fehler: Zwei Eingaben sind noetig!"); } }}


136

4. Aufgabe

Schreibe eine Java-Anwendung, die Dateinamen über die Kommandozeile einliest und den Inhaltdieser (Text-) Dateien zeilenweise auf der Konsole ausgibt. Exceptions bzw. Fehlerbehandlungs-maßnahmen sind aufzufangen bzw. einzurichten.

import java.io.*;

public class Aufg4{ public static void listeDateien(String dateiName) { FileReader dieDatei; BufferedReader dateiEin = null; String eineZeile; System.out.println("Datei: " + dateiName);

try { dieDatei = new FileReader(dateiName); dateiEin = new BufferedReader(dieDatei); while ((eineZeile = dateiEin.readLine()) != null) System.out.println(eineZeile); } catch(Exception e) { System.out.println(e); }

try { if (dateiEin != null) dateiEin.close(); } catch(Exception e) { System.out.println(e); } }

public static void main(String [] args) { if (args.length == 0) System.out.println("Keine Dateinamen angegeben!");

for (int i = 0; i < args.length; i++) listeDateien(args[i]); }}


137

5. Aufgabe

Schreibe ein Java-Anwendung, die den Text „Ein gutes, erfolgreiches neues Jahr“ in einemLauffenster der Größe „300 mal 100“ ausgibt

import java.awt.*;import java.util.*;

public class Aufg5 extends Frame implements Runnable{ Thread t; int x;

public Aufg5() { x = 0; t = new Thread(this); t.start(); }

public void paint(Graphics g) { g.drawString("Ein gutes, erfolgreiches neues Jahr",x,50); }

public void run() { while (true) { try { if (x > getSize().width) x = 0; else x += 5; repaint(); t.sleep(100); } catch(InterruptedException e) { t.stop(); } } }

public static void main(String [] args) { Aufg5 a = new Aufg5(); a.setSize(300,100); a.setVisible(true); }}

Documents

Programmieren in Java - IM-Wikifbim.fh-regensburg.de/~saj39122/pgj/ueb/loesungen.pdf · Programmieren in Java 1. Übung 7 1. Übung 1. Aufgabe Gegeben ist das folgende Programm in