Programmieren in Java - oth

Prof. Jürgen Sauer
Programmieren in Java
Übungen mit Lösungen
Programmieren in Java
Inhaltsverzeichnis
2
Programmieren in Java
Inhaltsverzeichnis
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
3
Programmieren in Java
Inhaltsverzeichnis
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
4
Programmieren in Java
Inhaltsverzeichnis
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
5
Programmieren in Java
Inhaltsverzeichnis
6
Programmieren in Java
1. Übung
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 speziell
eingerichteten Arbeitsverzeichnis liegen soll. Beachte, daß in diesem Verzeichnis die Datei für die
Bearbeitung durch den Java-Compiler einen speziellen Namen erhalten muß. Zum Übertragen
des Quellcode nutze man einen auf dem System vorhandenen Editor.
b) Nachdem die Datei mit dem Quelltext erstellt wurde, übersetze den Quellcode mit dem JavaCompiler
c) Welche Datei wurde in dem unter a) eingerichteten Arbeitsverzeichnis durch den Compiler nach
fehlerfreier Übersetzung erzeugt.
ErstesProgramm.class
d) Rufe das Java-Laufzeitsystem zur Ausführung der im Arbeitsverzeichnis vorliegenden
ausführbaren Datei auf.
7
Programmieren in Java
1. Übung
2. Aufgabe
Erzeuge 100 Zufallszahlen zwischen 0 und 1 und ermittle aus diesen 100 Zufallszahlen die größte
Zahl (das Maximum).
Die Routine Math.random() aus dem Paket java.lang liefert eine (Pseudo-) Zufallszahl vom Typ double
zwischen 0 und 1. Die beiden Endwerte kommen nicht vor, die Zahlen sind ansonsten gleichmäßig im
Intervall 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);
}
}
8
Programmieren in Java
1. Übung
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
9
2 3 4 5 6 7 8 9
4 6 8 10 12 14 16 18
6 9 12 15 18 21 24 27
8 12 16 20 24 28 32 36
10 15 20 25 30 35 40 45
12 18 24 30 36 42 48 54
14 21 28 35 42 49 56 63
16 24 32 40 48 56 64 72
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
9
Programmieren in Java
1. Übung
4. Aufgabe
Schreibe ein Programm, das in einer „for“-Schleife insgesamt 100 Sternchen („*“) hintereinander
ausdruckt. Übergib als Kommandozeilenparameter einen „int“-Wert, der festlegt, nach wiviel Zeichen
ein Zeilenvorschub erfolgen soll. So soll z.B nach folgendem Aufruf „java Aufg04 25“ die folgende
Bildschirmausgabe 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. Das
Programm erwartet den Parameter n in der Kommandozeile und berechnet das Produkt 1*2*3*...*n.
Das Resultat soll auf die Standardausgabeeinheit ausgegeben werden.
public class Aufg05
{
public static void main (String args[])
{
int erg = 1;
int n = Integer.parseInt( args[0] );
for (int i = 1; i <= n; i++)
erg *= i;
System.out.println( "Ergebnis: " + erg );
}
}
10
Programmieren in Java
1. Übung
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, das
Resultat 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 );
}
}
11
Programmieren in Java
2. Übung
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 der
Kommandozeile 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 spezielle
Behandlung 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.
12
Programmieren in Java
2. Übung
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 so
umgestalten, daß die Zahlen, von der ersten zu letzen Komponente gesehen, eine aufsteigende
Sortierung zeigen
b) Ergänze die main()-Methode durch Anweisungen, die das Datenfeld (Array) vor und nach der
Sortierung in einer Zeile ausgeben.
c) Wie müssen die Anweisungen für das Sortieren verändert werden, wenn das folgende Datenfeld
zu 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();
}
}
13
Programmieren in Java
2. Übung
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 und
anschließend mit diesen beiden Zahlen alle binären und unären Operationen auf ganzen Zahlen
ausführt. Die Demonstration binärer und unärer Arithmetik mit ganzen Zahlen soll den Namen
IntDemo 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 Programm
anschließend aus. Welches Resultat ergibt sich für 1/0.
/ by zero
14
Programmieren in Java
2. Übung
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());
}
}
}
15
Programmieren in Java
2. Übung
4. Aufgabe
Gib über die Kommandozeile eine natürliche Zahl ein. Das über die Kommandozeile ebenfalls
aufzurufende Programm soll den kleinsten Teiler der natürlichen Zahl bestimmen und angeben. Falls
kein Teiler existiert, soll ausgegeben werden, daß die Zahl eine Primzahl ist.
public class Aufg04
{
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);
}
}
}
16
Programmieren in Java
2. Übung
5. Aufgabe
Schreibe ein Programm zur Berechnung der Iterationsvorschrift:
x(n+1) = (x(n) + 2/x(n)) / 2
x(0) = 2
Die Vorschrift wird häufig für die Berechnung von
das dies korrekt ist.
2 herangezogen. Bestätige durch das Programm,
public class Aufg05
{
public static void main (String args[])
{
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 );
}
}
17
Programmieren in Java
3. Übung
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
n
(Datentyp int) eingelesen werden. Mit Hilfe einer for-Schleife soll a berechnet und ausgegeben
werden. 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 die
Standard-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);
18
Programmieren in Java
3. Übung
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(" )");
}
}
}
19
Programmieren in Java
3. Übung
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 Programms
auf?
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 spezielle
Behandlung 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!");
}
}
}
}
20
Programmieren in Java
3. Übung
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 und
anschließend mit diesen beiden Zahlen alle binären und unären Operationen auf ganzen Zahlen
ausführt. Die Demonstration binärer und unärer Arithmetik mit ganzen Zahlen soll den Namen
DoubleDemo 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);
21
Programmieren in Java
3. Übung
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());
}
}
}
22
Programmieren in Java
4. Übung
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 Ausgabezeile
im Fenster vermerkt.
a) Schreibe das zugehörige Applet, das das vorliegende Fenster mit den unterschiedlichen Schriften
produziert.
import java.awt.Font;
import java.awt.Graphics;
public class
{
public void
{
Font f
=
Font fb =
Font fi =
Font fbi =
Aufg1 extends java.applet.Applet
paint(Graphics g)
new
new
new
new
Font("TimesRoman",Font.PLAIN,18);
Font("TimesRoman",Font.BOLD,18);
Font("TimesRoman",Font.ITALIC,18);
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",
23
Programmieren in Java
10,100);
g.setFont(f2);
g.drawString(
"Normaler Font (Arial)
10,125);
g.setFont(f2b);
g.drawString(
"Fetter Font (Courier)
10,150);
g.setFont(f2i);
g.drawString(
"Kursiver Font (Arial)
10,180);
4. Übung
in Schriftgroesse 10",
in Schriftgroesse 12",
in Schriftgroesse 30",
}
}
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 WebBrowser.
24
Programmieren in Java
4. Übung
2. Aufgabe
Der Spruch „Aller Anfang ist schwer!“ soll mit Hilfe eines Applets in dem zu dem Applet zugeordneten
Fenster dargestellt werden. Die Darstellung soll folgende Gestalt annehmen.
a) Bestimme den Quellcode zu diesem Applet, das die vorliegende Darstellung über einen WebBrowser bzw. einen „Appletviewer“ ermöglicht. Die Abmessungen des Fensters, des Ovals im
Fenster 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);
}
}
25
Programmieren in Java
4. Übung
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.
26
Programmieren in Java
4. Übung
3. Aufgabe
a) In dem einem Applet zugeordneten Fenster soll der Buchstabe „F“, wie die folgende Abbildung
zeigt, abgebildet werden:
Die Abmessungen des Fensters, die Konstruktionsmaße zur Darstellung des Buchstabens sollen
der folgenden Abbildung direkt entnommen werden. In der oberen, linken Ecke des Fensters
befindet sich der Bezugspunkt.
27
Programmieren in Java
4. Übung
1) Bestimme den Quellcode zu dem Applet, das die vorliegende Darstellung über einen WebBrowser 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.
<HTML>
<HEAD>
<TITLE>3. Aufgabe</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Aufg3.class" WIDTH=200 HEIGHT=200>
</APPLET>
</BODY>
</HTML>
3) Überprüfe die Lösung zu dieser Aufgabe durch eine Implementierung
28
Programmieren in Java
4. Übung
b) Die Darstellung soll farbig ausgestattet werden. Der Hintergrund des Bildes soll gelb (Größe: 200
x 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 Methode
getSize() 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.
29
Programmieren in Java
a)
4. Übung
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);
}
}
<HTML>
<HEAD>
<TITLE>4. Aufgabe</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Aufg4.class" WIDTH=300 HEIGHT=300>
</APPLET>
</BODY>
</HTML>
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>
30
Programmieren in Java
5. Übung
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 der
Paramter 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 einen
Wert besitzt, zeige ihn, wie die vorliegende Darstellung zeigt, an. Im anderen Fall gib irgend etwas
anderes aus.
31
Programmieren in Java
5. Übung
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:
32
Programmieren in Java
5. Übung
Bei genauer Betrachtung sieht man, daß diese Darstellung sich aus Ellipsen und Bögen
zusammensetzt.
a) Schreibe ein Applet, das diese Darstellung realisiert. Die Abmessungen der Tasse (für die Bögen
bzw. Ellipsen) können frei gewählt werden, es soll nur eine möglichst große Ähnlichkeit zum
vorliegenden 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.
<HTML>
<HEAD>
<TITLE>2. Aufgabe</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Aufg2.class" WIDTH=200 HEIGHT=200>
</APPLET>
</BODY>
</HTML>
c) Überprüfe die Lösung zu dieser Aufgabe durch einen Test mit dem „appletviewer“ oder einem
„Java“-fähigen Web-Browser.
33
Programmieren in Java
5. Übung
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, und
lassen sich mit Hilfe der trigonometrischen Funktionen bestimmen.
34
Programmieren in Java
5. Übung
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
yKoord = new
for (int i =
{
xKoord[i] =
int[eckenAnz];
int[eckenAnz];
0; i < eckenAnz; 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.
<HTML>
<HEAD>
<TITLE>3. Aufgabe</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Aufg3.class" WIDTH=200 HEIGHT=200>
</APPLET>
</BODY>
</HTML>
c) Überprüfe die Lösung zu dieser Aufgabe durch einen Test mit dem „appletviewer“ oder einem
„Java“-fähigen Web-Browser.
35
Programmieren in Java
5. Übung
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 jedem
anderen 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]);
}
}
36
Programmieren in Java
5. Übung
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;
37
Programmieren in Java
5. Übung
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.
<HTML>
<HEAD>
<TITLE>5. Aufgabe</TITLE>
</HEAD>
<BODY>
<APPLET CODE="Aufg4.class" WIDTH=300 HEIGHT=300>
</APPLET>
</BODY>
</HTML>
c) Überprüfe die Lösung zu dieser Aufgabe durch einen Test mit dem „appletviewer“ oder einem
„Java“-fähigen Web-Browser.
38
Programmieren in Java
6. Übung
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, die
einzelnen 3D-Quadrate haben eine Größe von 40 Pixel. Auf dem Schachbrett sind 8 Damen
positioniert. Die Symbole zu den 8 Damen sind aus Polygone aufgebaut. Das zu schreibende Applet
soll 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;
39
Programmieren in Java
6. Übung
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 );
}
}
40
Programmieren in Java
6. Übung
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();
}
}
41
Programmieren in Java
6. Übung
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.
42
Programmieren in Java
6. Übung
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 Teiler
besitzt (1 und sich selbst). Die Zahl ist 1 ist keine Primzahl, weil sie keine zwei verschiedene
Teiler 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 2
ab bis kurz vor der Zahl selbst. War die Zahl nie teilbar, dann ist sie eine Primzahl, anderenfalls
nicht. Primzahlen startet man mit der Zahl 2 und wiederholt das Verfahren so oft, bis die
gewü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 eine
davon abweichende Größe gewünscht, so soll das über die Kommandozeile bestimmt werden
können.
c) Die so ermittelten Primzahlen sollen in einen Array ausgegeben werden. Die in diesem Array
gespeicherten Primzahlen sollen auf der Standardausgabeeinheit protokolliert werden. Dabei
sollen 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;
}
43
Programmieren in Java
6. Übung
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();
}
}
}
44
Programmieren in Java
7. Übung
7. Übung
1. Aufgabe
Schreibe ein Programm, das Methoden zum Berechnen der Fakultät enthält und aufruft. Die
Berechnung der Fakultät soll
a) iterativ
b) 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
}
45
Programmieren in Java
7. Übung
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 die
Taylor-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);
}
}
46
Programmieren in Java
7. Übung
3. Aufgabe
Schreibe ein Programm, das über die folgenden Summe
∞
∑ (−1)
n =1
n +1
⋅
1
n
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());
}
}
47
Programmieren in Java
7. Übung
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();
}
}
}
48
Programmieren in Java
7. Übung
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 jedes
weitere Glied aus der Summe der beiden vorhergehenden Glieder berechnet werden. Die Ausgabe
der 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);
}
}
49
Programmieren in Java
7. Übung
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 = 13 + 53 + 33
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 Zahlen
vertikal 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
3
6
1
Der Aufruf von bspw. gibausVertikal(1234) führt zu der folgenden Ausgabe
1
2
3
4
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);
}
}
50
Programmieren in Java
7. Übung
8. Aufgabe
a) Welche Ausgabe zeigt das folgende Programm, wenn die in diesem Programm enthaltenen
rekursive 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);
}
}
Hip
Hip
Hip
Hip
Hurra
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);
}
}
51
Programmieren in Java
8. Übung
8. Übung
1. Aufgabe
a) Implementiere eine Klasse Complex zur Bearbeitung komplexer Zahlen. Die Struktur, die die
Klasse Complex annehmen soll, zeigt das folgende Klassendiagramm:
Complex
private double real;
// Realteil
private double imaginaer; // Imaginaerteil
public double real();
public double imaginaer();
public double betrag()
// Zugriff Realteil
// Zugriff Imaginaerteil
// 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 soll
ein 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;
}
52
Programmieren in Java
8. Übung
// 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");
}
}
53
Programmieren in Java
8. Übung
b) Zum Test der unter a) entwickelten und implementierten Klasse Complex soll eine Klasse
ComplexTest implementiert werden, die über eine Instanz einer komplexen Zahl alle Operationen
mit komplexen Zahlen der Klasse Complex aufruft, die Berechnungen durchführt und auf dem
Standardausgabegerä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);
}
}
54
Programmieren in Java
8. Übung
2. Aufgabe
a) Implementiere eine Klasse Rational zur Bearbeitung rationaler Zahlen. Die Struktur, die die
Klasse Rational annehmen soll, zeigt das folgende Klassendiagramm:
Rational
private long num;
private long den;
// Numerator (Zaehler)
// 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;
long den = 1L;
// Numerator
// 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;
}
55
Programmieren in Java
8. Übung
// 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;
}
56
Programmieren in Java
8. Übung
// 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);
}
}
57
Programmieren in Java
8. Übung
b) Zum Test der unter a) entwickelten und implementierten Klasse Rational soll eine Klasse
RationalTest implementiert werden, die alle unter a) angegebenen Methoden anhand geeigneter
Instanzen 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);
}
}
58
Programmieren in Java
8. Übung
3. Aufgabe
Das folgende Klassendiagramm beschreibt die Klasse Turtle.
Turtle
private double turtleX;
private double turtleY;
private double turtleR;
private double turtleTheta;
// x-Koordinate des aktuellen Endpunkts vom Turtle-Fahrstrahl
// y-Koordinate des aktuellen Endpunkts vom Turtle-Fahrstrahl
// Länge des Fahrstrahls der aktuellen Turtle
// 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. Von
einem Ausgangspunkt kann im Rahmen der Turtle-Grafik ein Pfeil bestimmter Länge gezeichnet
werden:
Die Spitze des Pfeils gibt die Richtung an, die über eine Winkelangabe verändert werden kann. Ein
negativer Winkel dreht den Pfeil entgegen dem Uhrzeigersinn, ein positiver Winkel dreht den Pfeil im
Uhrzeigersinn.
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;
}
59
Programmieren in Java
8. Übung
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;
}
}
60
Programmieren in Java
8. Übung
Die soeben entwickelte Klasse Turtle kann
a) zum Zeichnen eines regelmäßigen Vielecks mit gegebener Anzahl Ecken (z.B. 3 bzw. 12) und
Seitenlänge (100 Pixel bzw. 50 Pixel) benutzt werden. Schreibe ein Applet, das mit Hilfe der
Klasse Turtle ein regelmäßiges Vieleck zeichnet.
import java.awt.*;
import java.applet.*;
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);
}
}
}
61
Programmieren in Java
8. Übung
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 einzelnes
Quadrat hat eine Seitenlänge von 100 Pixel.
import java.awt.*;
import java.applet.*;
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);
}
}
62
Programmieren in Java
8. Übung
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);
}
}
}
63
Programmieren in Java
9. Übung
9. Übung
1. Aufgabe
a) „Damen“-Problem
Aufgabenstellung: Acht Damen sollen so auf einem Schachbrett positioniert werden, daß sie sich
nicht schlagen können, d.h.: Zwei Damen stehen nie in derselben Zeile oder Spalte oder
Diagonale.
Algorithmus zur Lösung: Zu Beginn wird ein zweidimensionales Feld mit 0 gefüllt.
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Danach wird zufällig im zweidimensionalen Feld eine „Dame“ gesetzt. Das Setzen der Dame wird
durch eine 9 markiert.
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
9
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Durch das Positionieren der Dame sind Positionierungen von weiteren Damen in derselben Zeile
und Spalte wie die soeben positionierte Dame, aber auch in den zugehörigen Diagonalen nicht
erlaubt. Die nicht mehr zulässigen Positionen werden mit 1 markiert.
1
0
0
1
0
0
1
0
0
1
0
1
0
1
0
0
0
0
1
1
1
0
0
0
1
1
1
9
1
1
1
1
0
0
1
1
1
0
0
0
0
1
0
1
0
1
0
0
1
0
0
1
0
0
1
0
0
0
0
1
0
0
0
1
64
Programmieren in Java
9. Übung
Damen dürfen jetzt nur noch auf die mit 0 markierten Komponenten des zweidimensionalen Felds
gebracht werden. Das geschieht solange bis alle Komponenten des zweidimensionalen Felds mit 1
oder 9 gefüllt sind. Wurden beim Füllen des Felds insgesamt 8 Damen positioniert, dann wurde
eine Lösung erreicht, die so aussehen könnte:
1
1
1
1
9
1
1
1
1
9
1
1
1
1
1
1
1
1
1
9
1
1
1
1
1
1
1
1
1
9
1
1
1
1
1
1
1
1
1
9
1
1
9
1
1
1
1
1
9
1
1
1
1
1
1
9
1
1
1
1
1
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;
}
}
65
Programmieren in Java
9. Übung
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++;
}
66
Programmieren in Java
9. Übung
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();
}
67
Programmieren in Java
9. Übung
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();
}
}
68
Programmieren in Java
9. Übung
b) Die unter a) ermittelte Positionsangaben für Damen sollen jetzt, wie die folgende Darstellung
zeigt, in ein Schachbretts eingebracht werden.
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;
Damen dame;
public void init()
{
// Bestimmen der Applet-Fenstergroesse
d = getSize();
// Berechnen der Positionen fuer die Damen
dame = new Damen();
dame.erzeugeDamen();
}
69
Programmieren in Java
9. Übung
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 );
}
}
70
Programmieren in Java
9. Übung
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()-Funktion
aufgerufen werden können. Der Aufruf der Sortierroutinen soll ein ganzzahliges Feld mit unsortiert
vorliegenden Zahlen übergeben, die in den Sortierroutinen aufsteigend sortiert werden sollen. Das
Füllen des Datenfeldes soll mit Zufallszahlen im Bereich 0 bis 100 erfolgen, eine entsprechende
Ausgabe 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;
}
}
71
Programmieren in Java
9. Übung
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]);
}
}
}
72
Programmieren in Java
9. Übung
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];
73
Programmieren in Java
9. Übung
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]);
}
}
}
74
Programmieren in Java
9. Übung
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. Die
beiden 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 Zeichenketten
bereitstellt, der durch Aufruf einer Sortierroutine (Methode: „Quicksort“) der Klasse Sort die in dem
Array 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);
}
}
75
Programmieren in Java
9. Übung
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]);
}
}
}
76
Programmieren in Java
9. Übung
d) Die unter c) ermittelte Lösung läßt sich verallgemeinern, indem anstatt eines Datenfelds eine
Instanz der Klasse Vector (enthalten im Paket „java.util“) verwendet wird. Gib auch hierfür ein
komplette Anwendung an.
3. Aufgabe
Mit Hilfe der in Java implementierten mehrdimensionalen Datenfelder lassen sich Datenstrukturen zur
Lösung komplexer Probleme realisieren. Eine solche Datenstruktur, die eine Lösung für das bekannte
Pascalsche 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 Pascalschen
Dreiecks 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;
}
77
Programmieren in Java
9. Übung
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();
}
}
}
78
Programmieren in Java
10. Übung
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ß die
unter 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-Anwendungen
geschlossen werden?
RuntimeException bestimmt Programmfehler mit folgenden Eigenschaften:
1. Sie können nicht eingefangen werden
2. Sie müssen im Programm vom Programmierer speziell überprüft und behandelt werden
79
Programmieren in Java
10. Übung
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 vorliegenden
Programms. Gib einen Grund für dieses Programmverhalten an.
Eingefangen in main() wird eine Ausnahme der Klasse Exception, ausgeworfen wird von diesem
Programm eine Ausnahme der Klasse Throwable
Ausgabe:
java.lang.Throwable
at WirfAus.main(WirfAus.java:7)
80
Programmieren in Java
10. Übung
3. Aufgabe
Welche Schlußfolgerung kann für das Wiederauswerfen von Ausnahmen aus der Ausgabe zu dem
folgenden 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)
at
java.lang.NullPointerException.<init>(NullPointerException.java:64)
at Wiederauswurf.main(Wiederauswurf.java:18)
81
Programmieren in Java
10. Übung
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
82
Programmieren in Java
10. Übung
b) Implementiere das vorliegende Programm und überprüfe dessen Wirkungsweise.
Welche Ausgabe erzeugt dieses Programm?
Ausgabe: Test
Auswurf 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)
83
Programmieren in Java
11. Übung
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)
84
Programmieren in Java
11. Übung
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) auf
die Standardausgabe ausgibt.
b) Überprüfe anhand des unter a) entwickelten und implementierten Programms, welche Ausgaben
zu 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);
}
}
85
Programmieren in Java
11. Übung
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;
}
}
}
86
Programmieren in Java
11. Übung
4. Aufgabe
Bestimme die Größe einer Datei (in Bytes), deren Name über die Kommandozeile angegeben werden
soll.
Hinweis zur Lösung: Die Klasse InputStream des JDK 1.0 im Paket java.io enthält eine Methode
available(), 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();
}
}
87
Programmieren in Java
11. Übung
5. Aufgabe
Eine Textdatei, z.B. die Datei "EinAus.java", soll bis zum Dateiende (EOFException) sequentiell
eingelesen werden. Jede einzelne Zeile soll nach dem Einlesen mit Hilfe der im Paket "java.io"
vorliegenden Klasse LineNumberReader durchnummeriert und in eine Ausgabedatei geschrieben
werden. 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 der
Eingabezeilen beim Einlesen zählen kann. Beim Einlesen ist ein vorzeitiges Ende der Eingabedatei abzufangen
und 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");
}
}
}
88
Programmieren in Java
12. Übung
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 ist
ein „FileDialog“ heranzuziehen. Die Abbildung soll ein einem speziellen Font „Helvetica“, im Stil
Font.Plain“ und mit der Fontgröße 10 erfolgen. Das Fenster soll nach der Anzeige vergrößert werden
kö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 { }
}
89
Programmieren in Java
12. Übung
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);
}
}
90
Programmieren in Java
12. Übung
2. Aufgabe
a) Schreibe ein Programm, das Celsius-Grade in Fahrenheit bzw. Fahrenheit- in Celsius-Grade
umrechnet. Zur Eingabe bzw. zur Darstellung der Umrechnung benutze die folgenden beiden
Textfelder. 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 Fenster
einer 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);
}
});
91
Programmieren in Java
12. Übung
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);
}
}
92
Programmieren in Java
12. Übung
b) Schreibe ein Programm, das die Temperturwerte von 0 bis 300 Fahrenheit-Graden in Schritten
von 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);
}
}
}
93
Programmieren in Java
12. Übung
3. Aufgabe
Schreibe ein Programm, das das folgende Fenster erzeugt:
Beim Aktivieren (Drücken einer der Schaltknöpfe soll die Hintergrundfarbe gemäß der auf den
Schaltknöpfen angegebenen Farbe sich ändern, z.B.: „Beim Drücken des mit „rot“ beschrifteten
Schaltknopfs, soll die Hintergrundfarbe des Fensters „rot“ werden.
import java.awt.*;
import java.awt.event.*;
public class
{
Button b1 =
Button b2 =
Button b3 =
Button b4 =
Button b5 =
Button b6 =
Button b7 =
Ueb603 extends Frame
new
new
new
new
new
new
new
Button("rot");
Button("blau");
Button("gruen");
Button("pink");
Button("orange");
Button("gelb");
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();
}
94
Programmieren in Java
12. Übung
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);
}
}
95
Programmieren in Java
12. Übung
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 CheckboxKomponenten:
Label und Status der jeweils zuletzt aktivierten Komponente sollen in das im oberen Teil der
Darstellung befindliche Textfeld eingetragen werden.
Realisiere die Inplementierung der vorliegendenen Darstellung.
import java.awt.*;
import java.awt.event.*;
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);
96
Programmieren in Java
12. Übung
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();
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
// f.setVisible(false);
System.exit(0);
}
});
f.setSize(150,150);
f.setVisible(true);
}
}
97
Programmieren in Java
12. Übung
5. Aufgabe
Die folgende Darstellung zeigt ein Textfeld, dann auf der linken Seite eine CheckboxGroup mit drei
Radio-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.
import java.awt.*;
import java.awt.event.*;
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);
}
98
Programmieren in Java
12. Übung
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);
}
}
*/
}
}
99
Programmieren in Java
12. Übung
public static void main(String args[])
{
Ueb704 f = new Ueb704();
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
// f.setVisible(false);
System.exit(0);
}
});
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 Bereich
zur Darstellung der ausgewählten Farben im Hintergrund. Es sollen folgende Farben über das
Auswahlmenü ausgewählt werden können: „rot“, „blau“, „gruen“, „orange“, „pink“, „gelb“, „cyan“. Die
aktivierte Auswahl ist über Index und ItemEvent im Textfeld zu protokollieren.
Realisiere eine Implementierung der vorliegenden Darstellung.
import java.awt.*;
import java.awt.event.*;
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());
}
100
Programmieren in Java
12. Übung
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);
}
}
}
public static void main(String args[])
{
Ueb705 f = new Ueb705();
f.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
f.setBackground(Color.lightGray);
f.setSize(200,100);
f.setVisible(true);
}
}
101
Programmieren in Java
12. Übung
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. Weitere
Einträge sollen über Aktivierung derSchlatfläche mit dem Label „Test“ übernommen werden. Diese
Eintä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 der
Komponente List, wie die Abbildung zeigt, übernommen werden.
Realisiere eine Implementierung des vorliegenden Fensters im Rahmen einer grafischen
Benutzeroberfäche.
import java.awt.*;
import java.awt.event.*;
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());
}
102
Programmieren in Java
12. Übung
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);
}
}
}
public static void main(String args[])
{
Ueb706 f = new Ueb706();
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
// f.setVisible(false);
System.exit(0);
}
});
f.setBackground(Color.lightGray);
f.setSize(240,160);
f.setVisible(true);
}
}
103
Programmieren in Java
13. Übung
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 255
abdecken. Der linke Schieberegler dient zum Einstellen der Farbe „rot“, der mittlere zum
Einstellen der Farbe „grün“, der rechte Schieberegler dient zum einstellen der Farbe blau. Die drei
Farben bilden die Grundlage des RBG-Farbmodells. Der wert 0 bedeutet, daß diese Grundfarbe
nicht in das Farbmodell eingeht, der Wert 255 zeigt die maximale Intensität dieser Farbe an. RGBFarben werden durch das Tripel (r,g,b) dargestellt, die den jeweiligen Anteil der jeweiligen
Grundfarbe in der Reihenfolge „rot“, gruen“, blau darstellen. Je nach Position des Schiebers soll
das rechte Zeichenfeld die Hintergrundfarben annehmen, die dem jeweiligen Anteil an der
Grundfarbe 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 jeweiligen
Schieberegler an.
einem Zeichenfeld, das durch seine Hintergrundfarbe die Mischung der Anteile der Farben nach
dem RBG-Farbmodell anzeigt.
einer mit Ruecksetzen beschriftete Schaltfläche. Das Drücken dieses Button bewirkt das
Ruecksetzen des Schiebers und das Eintragen des Werts 0 in die Textfelder. Der Hintergrund des
Zeichenfelds wird auf Color.lightGray gesetzt.
import java.awt.*;
import java.awt.event.*;
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();
104
Programmieren in Java
13. Übung
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);
}
}
105
Programmieren in Java
13. Übung
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;
}
}
public static void main(String args[])
{
Ueb91 f = new Ueb91();
f.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
f.setSize(300,200);
f.setBackground(Color.lightGray);
f.setVisible(true);
}
}
106
Programmieren in Java
13. Übung
2. Aufgabe
Gesucht ist das Java-Programm, das eine grafische Benutzeroberfläche für ein bekanntes Spiel
implementiert. Das Spiel besteht in dem wechselnden Einträgen von Kreuzen und Kreisen in ein
zweidimensionales 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 die
abwechselnd ein Kreuz und danach ein Kreis eingetragen werden muß. „Kreuz“ und „Kreis“ werden in
die 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.
import java.awt.*;
import java.awt.event.*;
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;
107
Programmieren in Java
13. Übung
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);
}
}
108
Programmieren in Java
13. Übung
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();
}
}
public static void main(String args[])
{
Ueb101 f = new Ueb101();
f.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
f.setSize(200,100);
// f.setBackground(Color.lightGray);
f.setVisible(true);
}
}
109
Programmieren in Java
13. Übung
3. Aufgabe
Das folgende Fenster ist in 4 Bereiche aufgeteilt. Die farbigen Flächen können auf alle möglichen
Low-Level-Ereignisse reagieren. Die weiße Fläche reagiert nicht. Das jeweilige „Low-Level-Ereignis
wird 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 hat
das Fenster folgende Gestalt:
Im Laufe der weiteren Verarbeitung kann das Fenster dann z.B. folgende Gestalt annehmen.
import java.awt.*;
import java.awt.event.*;
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();
}
110
Programmieren in Java
13. Übung
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);
}
*/
111
Programmieren in Java
13. Übung
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);
}
112
Programmieren in Java
13. Übung
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);
}
113
Programmieren in Java
13. Übung
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();
}
}
}
114
Programmieren in Java
13. Übung
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);
}
});
f.setSize(800,400);
f.setVisible(true);
}
}
115
Programmieren in Java
13. Übung
4. Aufgabe
Die folgende Abbildung
Zeigt einige der wesentlichen Komponenten einer grafischen Benutzeroberfläche. Dafür ist ein JavaProgramm zu erstellen, das diese Komponenten der grafischen Benutzeroberfläche in einem Fenster
realisiert. 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. Das
Aktivieren 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 der
angegebenen Art zeigen. Der Canvas auf der rechten Seite soll eine Linie zeigen, die drei Punkte
verbindet. Die Punkte sind markiert und beschriftet. Die übrigen Komponenten sind durch die
Beschriftung 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");
116
Programmieren in Java
13. Übung
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();
}
}
117
Programmieren in Java
13. Übung
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ügesteuert
erfolgen. 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 Sicherung
geschlossen.
„Sichern“ bewirkt die Aktion: Die unter „Oeffnen“ ausgewählte und in den Textbereich mit einem
bestimmten Format kopierte Datei wird aus dem Textbereich über den File-Dialog in eine speziell
ausgewä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");
118
Programmieren in Java
13. Übung
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) { }
}
119
Programmieren in Java
13. Übung
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); }
}
}
120
Programmieren in Java
14. Übung
Uebung 14
Conway's Game of Life
Game of Life ist eine Simulation, welche Zellen, die am Bildschirm als kleine Rechtecke, Pixel oder
andere 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 Leben
sind.
Eine Zelle, die bereits am Leben ist, kann nur dann überleben, wenn sie 2 oder 3 Nachbarzellen
hat, die am Leben sind.
(Jede Zelle hat 8 Nachbarzellen => Es sind auch diejenigen Zellen, die diagonal liegen
sogenannte Nachbarzellen)
Der Startwert einer Zelle ist eine Zufallsgröße. Sie können die Simulation entweder mit einem "toten
Rand" oder einem "Wrap-Around Rand" erstellen. "Toter Rand" bedeutet, daß eine Zelle die am Rand
oder einer Ecke des Feldes liegt, die nicht vorhandenen Nachbarzellen als "Tot" betrachtet; "Wrap
Around" bedeutet, daß die Randzellen diejenigen als Nachbarzellen betrachten, die am Spielfeld
gegenüber liegen. (Testen Sie dies am folgenden Applet mit Gliders und ein- bzw. ausgeschalteten
Wrap Around)
121
Programmieren in Java
14. Übung
Aufgabenstellung:
Implementieren Sie eine Applikation, die ein Spielfeld von 100*100 Zellen simuliert. Eine Zelle hat eine
Größe von 4x4 Pixel und
die 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 Generationswechsel
Der 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 besten
zu bewältigen ist (Sowohl "Toter Rand" als auch "Wrap-Around".)
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class Life extends Applet
implements 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
public
public
public
public
public
public
void
void
void
void
void
void
void
windowOpened(WindowEvent e) {}
windowClosing(WindowEvent e) {System.exit(0);}
windowClosed(WindowEvent e) {}
windowIconified(WindowEvent e) {}
windowDeiconified(WindowEvent e) {}
windowActivated(WindowEvent e) {}
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);
122
Programmieren in Java
14. Übung
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);
}
}
}
123
Programmieren in Java
14. Übung
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];
124
Programmieren in Java
14. Übung
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);
}
}
125
Programmieren in Java
15. Übung
15. Übung
1. Aufgabe
Entwurf und Implementierung eines Programms zur Darstellung einer Funktion y = f(x), z.B.
y = e − 0. 3 x cos( 2 x ) . 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 und
Bildschirmhöhe umfaßt. Zur Einbettung ist der Ursprung des Koordinatensystems auf die Angaben
XBreiteMin,. XBreiteMax, YHoeheOben, YHoeheUnten abzustimmen. Die vorliegende Skizze zeigt
bspw. 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. Die
Eingabe erfolgt in sog. Weltschirmkoordinaten, d.h. unabängig von der tatsächlichen Darstellung in
den vorliegenden Bildschirmkoordinaten. Entwurf und Implementierung einer Umrechnungsroutine
(„Weltschirmkoordinaten in Bildschirmkoordinaten“) ist Bestandteil der Aufgabe. Die Benutzereingabe
bestimmt weiterhin die Lage des Ursprungs des Koordinatensystems. So führt bspw.
XBreiteMin = 0, XBreiteMax = 4, YHoeheOben = 1, YHoeheUnten = -1
zu der folgenden Darstellung:
126
Programmieren in Java
15. Übung
Schließlich gibt der Benutzer noch die Anzahl der Stützstellen vor. Für diese Stellen wird der
Funktionswert 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ür
notwendigen 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 die
Werte zu
XBreiteMin, XBreiteMax, YHoeheOben, YHoeheUnten
enthalten.
import java.awt.*;
import java.awt.event.*;
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);
}
127
Programmieren in Java
15. Übung
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 Linie
g.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 Schritte
for (int i=(int)-MAXY;i<=(int)MAXY;i++) {
g.drawLine (
worldToScreenX(0)-5,
worldToScreenY(i),
worldToScreenX(0)+5,
worldToScreenY(i)
);
}
// Zeichnen der Funktion
for (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);
128
Programmieren in Java
15. Übung
g.drawLine (
i,
worldToScreenY(y1),
i+1,
worldToScreenY(y2)
);
}
}
public static void main (String args[])
{
Ueb152 test = new Ueb152();
test.show();
}
}
2. Aufgabe
Darstellung des Random-Walk-Algorithmus in der Simulationstechnik am Beispiel des „drunken
Sailor“. Ein Seemann mit viel Alkohol im Blut verläßt eine Kneipe und mach sich auf dem Weg zu
seinem Schiff:
Die Kneipe liegt in der Mitte des Darstellungsrahmens. Der Betrunkene macht immer gleich große
Schritte (25 Pixeleinheitem) nur die Richtung ändert sich dauernd. Zur Vorhersage der Richtung
benutzt 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, die
Darstellung soll über die nächstliegenden Bildschirmkoordinaten erfolgen. Sobald der Heimkehrer die
zur Verfügung stehende Zeichenfläche verlassen hat, wird in der Bildmitte eine weitere Saufkumpan
auf 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;
129
Programmieren in Java
15. Übung
// 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);
}
}
130
Programmieren in Java
16. Übung
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 ist
ein „FileDialog“ heranzuziehen. Die Abbildung soll ein einem speziellen Font „Helvetica“, im Stil
Font.Plain“ und mit der Fontgröße 10 erfolgen. Das Fenster soll nach der Anzeige vergrößert werden
kö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 { }
}
131
Programmieren in Java
16. Übung
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.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
f.setVisible(true);
}
}
132
Programmieren in Java
16. Übung
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 der
Konsole „Befehlsausführung“ ausgegeben werden. Falls mit der Maus die Fensterfläche überstrichen
wird, soll der Hintergrund „rot“ werden. Falls die Maus die Fensterfläche verlässt, soll der Anfangszustand, d.h. ein Hintergrung mit der Farbe „orange“, wiederhergestellt werden.
import java.awt.*;
import java.awt.event.*;
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);
}
133
Programmieren in Java
16. Übung
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");
f.addWindowListener(
new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
MeinButton mb = new MeinButton(anw);
f.add(mb);
f.setSize(100,100);
f.setVisible(true);
}
}
134
Programmieren in Java
16. Übung
3. Aufgabe
Lies zwei ganze Zahlen über eine Eingabezeile ein und bestimme das Maximum dieser Zahlen. Die
Ausgabe 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!");
}
}
}
135
Programmieren in Java
16. Übung
4. Aufgabe
Schreibe eine Java-Anwendung, die Dateinamen über die Kommandozeile einliest und den Inhalt
dieser (Text-) Dateien zeilenweise auf der Konsole ausgibt. Exceptions bzw. Fehlerbehandlungsmaß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]);
}
}
136
Programmieren in Java
16. Übung
5. Aufgabe
Schreibe ein Java-Anwendung, die den Text „Ein gutes, erfolgreiches neues Jahr“ in einem
Lauffenster 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);
}
}
137