Sie sind auf Seite 1von 24

Informatik mit Java 2010/11

Vorbemerkungen

Mit Java lernen wir nach PHP eine vollständig objektorientierte Sprache kennen.

Konkret heisst dies, dass es keine Java-Programme sondern nur neue Klassen gibt, die von den schon
vorhandenen Klassen abgeleitet werden und damit ohne diese nicht lauffähig sind. Aus dem Quelltext
programmname.java wird zwar ein Zwischencode programmname.class kompiliert, dieser ist jedoch ohne die
Java-Runtime (JRE) nicht lauffähig. Dafür läuft der Zwischencode ohne irgendwelche Änderungen unter
jedem Betriebsssystem, in dem die JRE vorhanden ist, weil diese die notwendigen Anpassungen an die
verschiedenen Windows-, Linux- oder Mac-Betriebssysteme enthält. Der Zwischencode
programmname.class ist also vollständig betriebssystemunabhängig. Es müssen allerdings alle benötigten
Klassen vorhanden sein.

Die Unterschiede zu PHP liegen ansonsten mehr im Detail. Im Vergleich zu PHP ist der Befehlsumfang von
Java allerdings wesentlich mächtiger.

Es existieren eigenständige Programme und Applets, die im Browser (lokal - bei PHP auf dem Server)
ausgeführt werden.

Diese Anleitung ist ursprünglich für einen Kurs entstanden, bei dem Eclipse nicht verwendet wurde.

Kostenlose Anleitungen und Bücher zu Java finden sich im Internet z.B. bei www.javabuch.de oder bei
www.galileocomputing.de/katalog/openbook.

1. Erstes Programm und erstes Applet

Lade in einen Editor (z.B. kate) das erste Programm, die Datei CHallowelt.java :
// Datei CHalloWelt.java

class CHalloWelt
{
public static void main (String args[])
{
System.out.println("Hallo OHG!");
}
}
Hinter // steht ein Kommentar, CHalloWelt ist der Name der erzeugten Klasse (ersetzt das 
Erzeugen eines Programms) und main (mit den Zusätzen) ist das „Hauptprogramm“ (die 
Hauptmethode  oder Funktion), das beim Aufruf von CHallowelt ausgeführt wird.
Mit den geschweiften Klammern { } werden zusammengehörende Befehle (vom Anfang bis zum 
Ende) geklammert ­ was dazwischen steht, zählt als ein Befehl. Mit dem Strichpunkt muss eine Zeile 
beendet werden.
Mit dem Befehl javac CHallowelt.java wird kompiliert (es entsteht CHalloWelt.class) und die 
entstandene Klasse kann dann mit java Challowelt ausgeführt werden.

Das erste Applet mit dem gleichen Ergebnis ist CHalloWWW.java :
// Datei CHalloWWW.java
// Dies ist das erste Applet

public class CHalloWWW extends java.applet.Applet


{
public void paint(java.awt.Graphics g)
{
g.drawString("Hallo GKs Informatik weltweit!",150,100);
}

1
Informatik mit Java 2010/11

}
Bei einem Applet erweitert das Programm die vordefinierte Klasse java.applet.Applet um neue 
Eigenschaften, deshalb extends ....  .
Es wird auch nicht das Hauptprogramm main aufgerufen, sondern entweder init, start,stop, destroy 
oder wie hier paint zum Zeichnen des Applets. Paint verlangt als Parameter eine Variable vom Typ 
java.awt.Graphics, die wir hier g getauft haben.
Die Variable g hat eine ganze Reihe nützlicher Eigenschaften, wie drawstring zur Textausgabe, 
aufgerufen mit g.drawstring , dem Text und den x­ und y­Koordinaten des Textes.

Das Applet wird wie üblich mit javac CHalloWWW.java kompiliert, kann jedoch nur aus einer 
Internetseite (am besten mit dem Firefox ­ Java aktivieren!) aufgerufen werden :
<html>
<body>
<applet code = "CHalloWWW.class"
width = 400
height = 200
> </applet>
</body>
</html>

2. Variablendeklaration
Alle Variablen, die im Programm gebraucht werden, müssen zuerst deklariert und dann mit einem 
Wert versehen werden. Dies kann auch auf einmal in einer Zeile geschehen, wie unten bei der 
Variablen z :

// Datei COperatoren.java

public class COperatoren


{
public static void main(String[] args)
{
int x,y;
int ergebnis_1,ergebnis_2;

x = 2;
y = 3;
int z = 4;

ergebnis_1 = x + y * z;
ergebnis_2 = (5 - 3) * z;
System.out.println("x+y*z ergibt" + ergebnis_1);
System.out.println("(5-3)*z ergibt" + ergebnis_2);

x = x + z;
System.out.println(x);
x += z;
System.out.println(x);
x += 1;
System.out.println(x);
x++;
System.out.println(x);
}
}

Die wichtigsten Variablentypen sind :

2
Informatik mit Java 2010/11

boolean ... wahr/falsch.... true/false


int ... ganze Zahlen mit 32 Bit... etwa bis 4 Milliarden
double .... Kommazahlen
char ... 1 Zeichen im Unicode (16bit)
String ... Text

Außer den üblichen Operatoren sind noch wichtig :

x++ um x um 1 zu erhöhen, z­­ um z um 1 zu verkleinern, +=, ­= , *=, /= um eine Wertzuweisung und 
eine Rechnung gleichzeitig durchzuführen ­ so ist x +=a gleichbedeutend mit x = x+a. Mit % erhält 
man den Divisionsrest. So liefert 111 % 7 den Rest bei der Division von 111 durch 7.

Die Umwandlung verschiedener Datentypen ineinander erfolgt automatisch, sofern dies problemlos


möglich ist :
int a=5; double x;
x = a;
In Gegenrichtung muß die Umwandlung mit einem casting­Operator erzwungen werden (dies ist 
auch zu empfehlen, wenn man auf Nummer sicher gehen will) :
int a; double x=3.14;
a = (int) x; (bzw. x = (double) a;)

3. Ein- und Ausgabe


Während eine einfache Ausgabe mit den Standardsystembefehlen System.out.println() und 
System.out.print() problemlos möglich ist, ist die Eingabe erheblich aufwändiger. Dies liegt daran, dass 
Java hier die aus der Unix­Welt bekannten Byte­Ströme (streams) einsetzt. Man muß also zuerst den 
Eingabestrom lesen und das möglichst noch über einen Zwischenspeicher, den Buffer. Dies erfolgt mit 
der Deklaration :
BufferedReader eingabe = new BufferedReader(new
InputStreamReader(System.in));

Damit das funktioniert, muss allerdings ganz am Anfang des Programms mit
import java.io.*;
der Befehlsvorat für die Eingabe aktiviert werden.

Damit ist ein Objekt eingabe vorhanden, mit dem dann die tatsächliche Eingabe erfolgen kann. Bei 
einem Text (string) ist das sofort erledigt ­ mit den untenstehenden Befehlen wird eine ganze Textzeile 
eingelesen :
String zeile;
zeile = eingabe.readLine();

Bei Zahlen müssen diese noch vom String den eingabe.readline liefert mit einem Parse­Befehl in das 
entsprechende Zahlenformat gewandelt werden :
int a;
a = Integer.parseInt(eingabe.readLine());
oder
double x;
x = Double.parseDouble(eingabe.readLine());

Noch komplizierter wird das Ganze, wenn die einzelnen Eingaben in einer Zeile erfolgen und nur 
durch Leerzeichen getrennt sind. Dann muss die Zeile nämlich zuerst in ihre Teile zerlegt werden :
String eingabezeile;
eingabeZeile = eingabe.readLine(); // eingabeZeile muß als String deklariert
sein.
StringTokenizer teilstrings = new StringTokenizer(eingabeZeile); // Zeile
zerlegen

3
Informatik mit Java 2010/11

int a = Integer.parseInt(teilstrings.nexttoken()); // der erste Teilstring


double a = Double.parseDouble(teilstrings.nexttoken()); // der zweite
Teilstring;
String Name = teilstrings.nexttoken();

Um auf Nummer sicher zu gehen, muss noch die Fehlerbehandlung aktiviert werden. Dazu ergänzt 
man die Zeile mit der Hauptprogrammfestlegung main noch durch throws IOException :
public static void main(String args[]) throws IOException

Ab Java 5 kann man sich die Eingabe durch Benutzung des Objektes Scanner erleichtern :

import java.util.Scanner;
import java.io.IOException;

public class Listing0203


{
public static void main(String[] args)
throws IOException
{
int a, b, c;

Scanner scanner = new Scanner(System.in);

System.out.println("Bitte a eingeben: ");


a = scanner.nextInt();
System.out.println("Bitte b eingeben: ");
b = scanner.nextInt();
c = a + b;
System.out.println("a+b="+c);
}
}

Aufgaben :
1) Schreibe ein Programm zur Berechnung der Summe zweier einzugebender ganzer Zahlen.
2) Schreibe ein Programm zur Berechnung des Produkts zweier einzugebender Kommazahlen.
3) Berechne die Kosten für den Stromverbrauch. Der alte und der neue Zählerstand (ganze Zahlen) 
sind einzugeben, die kWh koste 11 Cents und der Grundpreis liege bei 150 EUR.
4) Schreibe ein Programm, das nach Eingabe der Seitenlängen eines Quaders dessen Volumen und 
Oberfläche berechnet.

4
Informatik mit Java 2010/11

4. Arbeiten mit Dateien


Die Verwendung von Streams in Java hat den Vorteil, dass alle Ein-/Ausgaben - gleichgültig ob per Tastatur,
Dateien oder Weboberfläche - ähnlich erfolgen. So lassen sich nach obigem Vorbild einfach die Ein- und Ausgabe
in eine Datei schreiben :

import java.io.*

public class AusgabeinDatei


{
public static void main(String[] args) throws IOException
{
File datei = new File(“Test.txt“); //neue Datei erschaffen
FileWriter ausgabestrom = new FileWriter(datei);
//eine Möglichkeit schaffen in diese Datei zu schreiben
PrintWriter ausgabe = new PrintWriter(ausgabestrom);
//damit der Befehl print existiert

ausgabe.println(“Mein erster Text“);


ausgabe.print(“Es geht auch ohne Zeilenvorschub“);
ausgabe.println(“Wie man sieht“);
ausgabe.println(); // eine Leerzeile
ausgabe.println(“Nach der Leerzeile ist Schluss“);

ausgabe.close(); // nicht vergessen die Datei zu schließen


}
}

Das Einlesen aus einer Datei sieht ganz ähnlich aus – allerdings nur für eine Zeile:

import java.io.*;

public class EinlesenausDatei


{
public static void main(String[] args) throws IOException
{
File datei = new File(“Test.txt“); //Datei auswählen
FileReader eingabestrom = new FileReader(datei);
//eine Möglichkeit schaffen diese Datei zu lesen
BufferedReader eingabe = new BufferedReader(eingabestrom);
//damit der Befehl readln existiert

String eingabezeile;

eingabezeile = eingabe.readLine();
System.out.println(eingabezeile);

}
}

5
Informatik mit Java 2010/11

Soll mehr als eine Zeile eingelesen werden, so erfolgt dies am schnellsten Zeichen für Zeichen. Gleichzeitig
soll beim Aufruf der Dateinamen als Parameter übergeben werden. Das Listing könnte dann so aussehen :

import java.io.*;
public class LeseDatei {

public void lese(String quelldatei) { // Erstellen eines Eingabestroms


try {
DataInput quelle = new DataInputStream(new FileInputStream(quelldatei));
while(true) { // Einlesen aus der Quelle Byte für Byte
byte zeichen = quelle.readByte();
System.out.print((char)zeichen);
}
}

// Dateiende der Quelldatei erreicht.


// Explizite Verwendung einer Exception um
// die while()-Schleife abzubrechen
catch (EOFException e) {
System.out.println();
System.out.println("Alles klar! Lesen der Datei beendet.");
}
catch (IOException e) // allgemeiner IO-Fehler
{
System.out.println(e.getMessage()); }
}
public static void main(String[] args) {
LeseDatei a = new LeseDatei();
try {
a.lese(args[0]);
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println(e.toString());
System.out.println("Bitte eine Datei als Parameter angeben");
}
}
}

Jetzt ist es nur noch ein kleiner Schritt zu einem Programm, das eine Datei kopiert :

/* Ein Kopierprogramm, das eine Datei Zeichen für Zeichen liest und dann
eine Zieldatei schreibt.*/

import java.io.*;
public class KopiereDatei
{

/* Die Kopiermethode: Als Übergabeargumente werden die Quelldatei und die


zu erstellende Zieldatei verwendet. Diese Parameter müssem beim Aufruf
angegeben werden.Das wird über das Exceptionhandling direkt in der main()-
Methode sichergestellt. */

public static void kopiere(String quelldatei, String zieldatei) throws


IOException
{
// Erstellen eines Eingabestroms und eines Ausgabestroms
DataInput quelle = new DataInputStream(new FileInputStream(quelldatei));
DataOutput ziel = new DataOutputStream(new FileOutputStream(zieldatei));

6
Informatik mit Java 2010/11

try {
while(true)
{
// Einlesen eines Char aus der Quelle
char zeichen = quelle.readChar();
// Schreibe Char in Zieldatei
ziel.writeChar(zeichen);
}
}
catch (EOFException e) // Dateiende der Quelldatei erreicht.
{
System.out.println("Alles klar! Kopieren der Datei beendet.");
}

catch (IOException e) // allgemeiner IO-Fehler


{
System.out.println(e.getMessage());
}
} //Ende von kopiere()

public static void main (String args[]) throws IOException


{
// Fange fehlende Übergabeparameter ab
try
{
kopiere(args[0], args[1]);
}
catch (ArrayIndexOutOfBoundsException uebergabeEx)
{
// Keine Übergabeparameter.
System.out.println("Das Programm benoetigt zwei Uebergabeparameter.");
System.out.println("Sie muessen folgende Syntax eingeben:");
System.out.println("java KopiereDatei [Name der Quelldatei] [Name der
Zieldatei]");
}
}
}

Die Klasse File enthält auch noch die Befehle zu den Operationen mit Dateien wie :

public boolean isFile() und public boolean isDirectory() Überprüfen des Datei-Typs
public boolean canRead()und public boolean canWrite() - Schreib- und Leserechte
public boolean exists() ob die Datei überhaupt existiert
public String getName() um den Dateinamen zu lesen
public String getParent() gibt den (Verzeichnis-) Pfad ohne Dateinamen aus
public boolean renameTo(File <neuer Name>) Umbenennen einer Datei
public boolean delete() zum Löschen der Datei
public boolean mkdir() zum Erstellen eines Verzeichnisses.

Aufgabe: Teste die obigen Befehle.

7
Informatik mit Java 2010/11

5. Grafik mit der Turtle


Als Einstieg in die Grafik wählen wir das einfachste Grafikmodell, die Turtle­Grafik, in einem 
Applet (obwohl es genau so gut auch in einem Programm funktioniert ­ wenn man es anpasst).

Vorgeben ist eine schon fix und fertige Klasse Turtle, die alle wichtigen Methoden enthält:
Ist t die Turtle (das Turtle-Objekt), so liefert :
t.home() // die Turtle geht wieder zum Startpunkt und dreht
sich so, dass sie nach rechts blickt
t.fd(double s) // die Turtle geht um s Punkte vorwärts
t.bk(double s) // die Turtle geht um s Punkte zurück
t.rt(double w) // die Turtle dreht sich um den Winkel w nach rechts
t.lt(double w) // die Turtle dreht sich um den Winkel w nach links
t.pu() // die Turtle hört auf zu zeichnen
t.pd() // die Turtle zeichnet wieder

Weitere genauere Informationen stehen in Interface.html

Das Grundprogramm für die Turtlegrafik ist :
import java.awt.*;
import java.applet.*;

public class TurtleApplet extends Applet


{
Turtle t;
public void paint(Graphics g)
{
t = new Turtle(this,150, 150, 0);
zeichne();
}

void zeichne()
{

} // zeichne
} // class TurtleApplet

In dieses Grundprogramm werden wir in die Funktion (Methode) zeichne() von Fall zu Fall die 
auszuführenden Befehle hineinschreiben. Auch werden wir das Programm durch zusätzliche 
Funktionen ergänzen.
Ein erstes Beispiel dazu (Zeichnen eines Rechtecks mit den Seitenlängen 80 und 50) :
void zeichne()
{
t.stiftfarbe(Color.red);
t.fd(80); t.rt(90); t.fd(50); t.rt(90); t.fd(80); t.rt(90);
t.fd(50);t.rt(90);
}

Aufgaben :
Zeichne ebenso
1) Ein Quadrat mit der Seitenlänge 100
2) Ein regelmäßiges Sechseck mit den Seitenkängen 80
3) Ein gleichseitiges Dreieck mit der Seitenlänge 120
4) Ein Häuschen mit Giebel

8
Informatik mit Java 2010/11

6. Schleifen

Beim Quadrat und Sechseck stört, dass 4­ bzw. 6-mal die gleichen Befehle in den Programmtext


geschrieben werden müssen. Um das zu vereinfachen, verwendet man Schleifen, wie z.B. die Zählschleife :
int i;
for(i = <Anfangswert>; i <= <Endwert>; i++ )
{
<Anweisungen>
}

allgemeiner : for(<Anfangswert>; <Abbruchbedingung>; <Erhöhung>) { .... };


und für das Quadrat mit der Seitenlänge a:
int i;
for(i = 1; i<=4; i++)
{
t.fd(a); t.rt(90);
}

Aufgabe : Lasse mit Zählschleifen ein regelmäßiges Dreieck, Sechseck, Achteck zeichnen.

Zählschleifen lassen sich auch ineinander schachteln. So liefert das nächste Programmfragment der 
Reihe nach das regelmäßige Dreieck, Quadrat, Fünfeck, Sechseck, .... bis zum Zwölfeck mit der 
Seitenlänge a:
int i, j;
double winkel;
for(j = 3; j<=12; j++)
{
winkel = 360/j;
for(i = 1; i<=j; i++)
{
t.fd(a); t.rt(winkel);
}
}

Weiter zerlegen lassen sich die Aufgaben, wenn Teile in einzelne Funktionen (Methoden) 
ausgelagert werden, wie bei dieser Definition von sechseck :
void sechseck(double a)
{
int i;
for(i = 1; i<=6; i++)
{ t.fd(a); t.rt(60); }
} // Ende der Funktion Sechseck
Augerufen wird das Sechseck dann mit secheck(<gewünschte Seitenlänge>).

Aufgaben :
1) Formuliere eine Methode quadrat(double Seite), die ein Quadrat gewünschter Seitenlänge 
zeichnet.
2) Formuliere eine Methode spirale1(), die 36 Quadrate zeichnet, die um einen gemeinsamen 
Eckpunkt um 10 Grad gegeneinander gedreht wurden.
3) Formuliere eine Methode spirale2(), die die Größe der Quadrate während des Drehens bis auf 
Null verkleinert.
4) Formuliere eine Methode spirale3(), bei der sich während des Drehens die Größe des Quadrates 
und der Drehwinkel ändern.
5) Formuliere eine Methode nEck(double Seitenlänge, int Eckenzahl), die ein n­Eck zeichnet.
6) Schreibe das obige Beispiel mit dem Dreickeck, Quadrat, Fünfeck, ... neu mit Hilfe der Methode 
nEck.
7) Schöne Muster erhält man, wenn man n­Ecke gleichzeitig verschiebt und dreht. Experimentiere.

9
Informatik mit Java 2010/11

Der große Nachteil der Zählschleife ist, dass man schon am Anfang wissen muss, wie oft sie 
durchlaufen wird und dass man die Schrittweite beim Schleifendurchlauf nicht verändern kann. 
Deswegen gibt es noch 2 weitere Schleifenarten :
while(<Bedingung erfüllt>)
{
<Anweisungen>
}
und 
do
{
<Anweisungen>
}
while(<Bedingung>);

Die Überprüfung, ob die Bedingung erfüllt ist, erfolgt entweder am Anfang oder am Schluß der 
Schleife. Der wichtige Unterschied zwischen beiden Schleifenarten ist, dass im Fall der do­Schleife die 
Anweisungen auf jeden Fall mindestens einmal ausgeführt werden 

Bsp :
int i = 1;
while(i <= 1000)
{
i = i*2;
System.out.println(i);
}
und 
int i = 99;
do
{
i -=3;
System.out.println(i);
}
while(i>100);

Obwohl in der letzten Schleifen die Bedingung i>100 nie erfüllt wird, wird sie einmal durchlaufen.

Aufgaben :
8) Schreibe ein Programm, das alle Dreierpotenzen kleiner 1 000 000 ausgibt.
9) Nach wievielen Jahren sind aus 10 000 € 20 000 € geworden, wenn der Zinssatz 5% ist ?
10)Ein Darlehen von 100 000€ zu 6% Jahreszinsen soll mit jährlichen Raten von 10 000€ getilgt 
werden. Wie lange braucht man dazu ?
11)1987 hatte China 990 Millionen Einwohner bei einer jährlichen Wachstumsrate von 1,4%, Indien 
dagegen 700 Millionen Einwohner bei 2,1% jährlicher Wachstumsrate. Wann hat Indien mehr 
Einwohner als China ?
12)Zeichne ineinandergeschachtelte Quadrate (im Applet), die mit einer Seitenlänge a=200 
beginnen, jeweils um 10o gedreht sind und deren Seitenlänge von einem Quadrat zum anderen  

auf 80% abnimmt. Beendet werden soll die Schleife, wenn die Seitenlänge 20 unterschreitet.

13)Wie Aufgabe 5, nur mit Sechsecken, beginnend mit a=10 und mit der Zunahme der Seitenlänge 
auf 120%. Ende bei Seitenlänge >=150.
14)Löse die Aufgabe „NochEineSpirale.html“ aus dem Verzeichnis Turtle.

Bem.:
Eine Schleife wird vorzeitig verlassen, wenn der Rechner auf die Anweisung break trifft. Mit 
continue wird der aktuelle Schleifendurchlauf bei der Zählschleife mit for(...) vorzeitig beendet und mit 
dem nächsten Wert der Schleifenvariablen fortgesetzt.

10
Informatik mit Java 2010/11

7. Verzweigungen

Bisher wurden alle Anweisungen in unseren Programmen der Reihe nach durchlaufen. Oft soll aber 
je nach dem Wert einer Variablen ein Teil abgehandelt werden oder auch nicht. Das einfachste 
Hilfsmittel dafür ist die Verweigung mit if ­ else :
if(<Bedingung>)
{
// wenn Bedingung erfüllt
<Anweisungen>
}
else
{
// wenn Bedingung nicht erfüllt
<Anweisungen>
}
Der Teil mit else darf auch fehlen. Als Beispiel nun der Test, ob eine Zahl n (Integer) gerade ist :
if((n % 2) == 0)
{
System.out.println("eine gerade Zahl“)
}
else
{
System.out.println("eine ungerade Zahl“)
}

Mit dem Operator % erhält man den Divisionsrest, genau: a%b liefert den Rest bei der Division von 
a durch b. Mit dem doppelten Gleichheitszeichen == wird auf Gleichheit des Restes mit 0 (Division 
geht auf) überprüft. Weitere Operatoren zur Überprüfung sind <, >, <=, >=, und != für ungleich (Das ! 
steht für die Verneinung).

Verzweigungen dürfen auch geschachtelt werden, d.h. innerhalb einer Verzweigung liegt eine neue 
Verzweigung.

Aufgaben :
1) Bei einer Bestellung wird bei einem Bestellwert von weniger als 20 € ein 
Mindermengenaufschlag von 5 € berechnet.
2) Wie Aufgabe 1, nur wird zusätzlich bei einem Bestellwert von mehr als 500 € ein Rabatt von 10 €
gewährt.
3) Zwei einzugebende Zahlen a und b sollen so sortiert werden, dass a den größeren und b den 
kleineren Zahlenwert hat.
4) Nach Eingabe der Koeffizienten a, b und c soll der Rechner die quadratische Gleichung ax 2+bx+c=0 
lösen.

Sind bei der Bedingung nach if mehrere Werte möglich, verwendet man am besten die 
Mehrfachverzweigung mit switch :

switch(<Variable>)
{
case <1.Wert> : <Anweisung>;
break;
case <2.Wert> : <Anweisung>;
break;
case <3.Wert> : <Anweisung>;
break;
.....................
default : <Anweisung>;
break;
}

11
Informatik mit Java 2010/11

Bei der Mehrfachverzweigung mit switch sucht der Rechner einfach den ersten zutreffenden Wert 
und fährt dort mit der Programmausführung fort. Deshalb muß am Ende nach jedem case ein break 
stehen, damit jetzt die Abarbeitung des switch­Befehls beendet wird. Sonst würden alle (nicht 
zutreffenden) Anweisungen bis zum Ende der switch­Konstruktion ausgeführt.
Mit default, das auch fehlen kann, wird dem Rechner gesagt, was er tun soll, wenn die Variable 
keinen der obigen Werte angenommen hat.

Achtung : Als Variable für switch dürfen nur byte, short, int oder char verwendet werden ­ damit 
eindeutige Werte bei case vorliegen. Andere Variable müssen per casting in diese Variablentypen 
gewandelt werden. 

Bsp .: Umwandlung der Punktezahlen in Noten

int punkte;
.......
switch(punkte)
{
case 15 : System.out.println("sehr gut“); break;
case 14 : System.out.println("sehr gut“); break;
case 13 : System.out.println("sehr gut“); break;
case 12 : System.out.println("gut“); break;
case 11 : System.out.println("gut“); break;
.................
default : System.out.println("diese Punktezahl gibt es nicht);
}

Aufgaben :
5) Schreibe ein Programm, mit dem von einem Würfel nach Eingabe einer der 3 Größen a, O oder V 
die anderen beiden ermittelt werden. Dabei soll gefragt werden, ob a,O oder V (char) eingegeben 
wird. Math.sqrt(x) liefert die Quadratwurzel von x, Math.pow(x,y) die Potenz xy.
6) Ein einfacher Taschenrechner (mit +, ­, * und /) ist zu simulieren, der nach Eingabe von <Zahl>, 
<Rechenzeichen>, <Zahl> das Ergebnis ausgibt.
7)  Von einer natürlichen Zahl n soll ausgegeben werden, welchen Rest sie bei der Division durch 7 
hat.

Weiterführende Aufgaben :
8) Ein Rechentrainer fürs große Einmaleins. Nach Eingabe der gewünschten Zahl von Aufgaben 
ermittelt der Rechner mit (int) 10*Math.random() eine Zufallszahl zwischen 0 und 9 sowie mit 
10+(int) 10*Math.random() eine zweite Zufallszahl zwischen 10 und 19 (Math.random liefert 
eine double­Zufallszahl zwischen 0 und 1). Der Benutzer soll dann das Produkt berechnen und 
eingeben. Ihm wird dann angezeigt, ob er richtig gerechnet hat oder nicht. Am Schluß soll dann 
noch der prozentuale Anteil der richtigen Aufgaben ausgegeben werden.
9) Zu einer gegebenen Zahl n sollen alle Teiler ermittelt werden.
10)In einer Simulation mit 1000 Würfen soll festgestellt werden, wie lange man im Schnitt warten 
muß, bis beim Würfeln zum ersten Mal eine 6 fällt.
11)Ermittle die Seitenlängen aller rechtwinkligen Dreiecke, bei denen a,b und c natürliche Zahlen 
sind und bei denen die Hypotenuse c<=100 ist (pythagoräische Zahlentripel).
12)Lass zu den Zahlen 1 bis 255 die dazugehörigen Zeichen ausgeben (ASCII­Code).

12
Informatik mit Java 2010/11

8. Methoden (oder Funktionen)


Ein größeres Programm wird sofort unübersichtlich, wenn es keine Möglichkeiten gibt, es in einzelne 
unabhängige Teile aufzuspalten. In der Mathematik wurden deshalb schon vor langer Zeit die 
Funktionen entwickelt, wie x4 statt x*x*x*x. Genau das gleiche ist auch in allen ernstzunehmenden  

Programmiersprachen geschehen. In Java haben die Funktionen (oder Methoden, wie sie hier genannt  

werden) eine einfache Form :

<Typ der Methode> Methodenname(<Parameterliste>


{
<Anweisungen>
return <Rückgabewert>
}

Aufgerufen werden sie (z.B. im Hauptprogramm) durch :
<Variable> = Methodenname(.......);
 
Als Beispiel nun die Methode hoch , die für eine natürliche Hochzahl xa berechnet :

double hoch(double Basis, int Hochzahl)


{
int i;
double x =1.0;

for (i=1; i<=Hochzahl; i++)


{ x *= Basis; }

return x;
}

Im Hauptprogramm (main) kann sie nun wie folgt aufgerufen werden:
Potenz = hoch (x, 3);

Das x vom Aufruf stört das x in der Definition der Methode hoch nicht, da letzteres eine sogenannte 
lokale Variable ist, die außerhalb von hoch absolut unbekannt ist. Und der Eingabewert von x bei 
hoch(x,3) ist intern in der Variablen Basis gespeichert.

Aufgaben :
1) Schreibe ein vollständiges Programm, das nach Eingabe von Basis und Hochzahl die n­te Potenz 
berechnet.
2) Erweitere das Programm aus 1) so, dass auch negative Hochzahlen erlaubt sind.
3) Schreibe ein Programm mit einer Methode Fakultät(n) zur Berechnung der Fakultät n! = 
1*2*3*...*n.
4) Schreibe ein Programm Sparbuch, dass es erlaubt, während 10 Jahren einmal am Anfang jedes 
Jahres Geld einzuzahlen und am Ende jedes Jahres abzuheben. Es soll automatisch die Zinsen 
(Zinssatz 4%) berechnen und das Sparbuch führen und dazu am Ende jedes Jahres den 
Kontostand ausgeben.
5) Schreibe eine Methode double DInput(), mir der du eine Gleitkommazahl einlesen kannst. Mache 
das gleiche für Integerzahlen. 

Wie aus der letzten Aufgabe ersichtlich gibt es durchaus Methoden, denen keine Parameter 
übergeben werden. Dann folgt eine leere Klammer () auf den Namen.

Im Zusammenhang mit der Turtlegrafik haben wir schon Methoden kennengelernt, die zwar etwas 
tun, aber keinen Rückgabewert haben. Ihnen wird das Schlüsselwort void vorangestellt. Das 
bekannteste Beispiel dafür ist das Hauptprogramm :
public static void main (String args[])

13
Informatik mit Java 2010/11

Eine Funktion darf sich selber aufrufen, man spricht dann von Rekursion. Ein einfaches Beispiel 
dafür ist die rekursive Definition der Fakultät n! = 1*2*3*...*n durch : 

1! = 1 (oder 0! = 1) und n! = n*(n­1)! 

Im Javaprogramm sieht dies dann so aus :
double Fakultät(int n)
{
if (n==1)
return 1;
else
return n*Fakultät(n-1);
}

Entsprechend lässt sich auch eine Schachtelung von immer kleiner werdenden Quadraten rekursiv 
formulieren :
void Quadrate()
{
double a=200.0;
if (a>20)
{ Quadrat(a); a = a*0.8;}
}

Aufgaben :
6) Schreibe die Programme zu den beiden obigen Fragmenten zur Fakultät und den Quadraten.
7) In turtle.html gibt es die Aufgaben Binärer Baum, Baum des Pythagoras und Kochsche Kurve 
mit mehreren Varianten. Versuche dafür selbständig eine Lösung zu finden (wobei die 
Beispiellösungen zu Rate gezogen werden dürfen).
 

Für die Sichtbarkeit von Variablen gilt folgendes :

Alle Variablen, die innerhalb einer Methode deklariert werden, sind lokale Variablen. Der Compiler 
schafft für sie eigene Speicherbereiche. Damit können sie andere Variable nie beeinflußen, auch wenn 
diese den gleichen Namen tragen. Und nach Beendigung der Methode wird der Speicher wieder 
freigegeben. Damit ist auch ihr Wert verloren.

Eine Methode darf durchaus auch Variable benutzen, die außerhalb deklariert wurden, sogenannte 
globale Variable. Da jetzt beim Aufruf der Methode kein neuer Speicherplatz für die Variable angelegt 
wird, bleiben Veränderungen an diesen Variablen auch nach Beendigung der Methode erhalten.

Beim Aufruf einer Methode wird der Wert der als Parameter übergebenen Variablen in die 
entsprechende lokale Variable kopiert (call by value). Damit sind Parameter immer auch lokale 
Variable. Dies gilt allerdings nicht bei Objekten als Parametern, da hier nur ein Zeiger auf den 
verwendeten Speicherbereich übergeben wird.
 

14
Informatik mit Java 2010/11

9. Graphische Benutzeroberfläche GUI - Einführung


Der Teil von Java, der für das Erstellen von Programmen mit graphischer Benutzeroberfläche (GUI ­ 
graphical user interface) zuständig ist, heißt AWT (abstract window toolkit). Die Hunderte von 
Klassen und Methoden, die hier angeboten werden, liegen alle in java.awt.

Wichtige Gruppen dieser Bausteine sind :
Container : enthalten andere Komponenten wie Frame (Programmfenster) oder Panel (Bereich 
innerhalb eines Fensters)
Components : Schaltflächen (Buttons), Menübalken (Menubar), Pulldown­Menus (Menu), 
Markierungskästchen (Checkbox), Textfelder (Textfield), Rollbalken (Scrollbar) usw.
Layout­Manager : Anordnung der Elemente im Fenster
Canvas : Zeichenfläche
Eventlistener : Reaktionen auf Mausklicks, Tasteneingaben usw.

Als Einstieg nun ein ganz einfaches Programm :

import java.awt.*;

public class GUI1 extends Frame


{
GUI1(String titel) //Konstruktor
{
super(titel); //Fenstertitel über den Konstruktor von Frame

// Buttons deklarieren
Button eins = new Button("eins");
Button und = new Button("und");
Button zwei = new Button("zwei");

// Einen Layout Manager zum Anordnen der Schalter festlegen


setLayout(new FlowLayout());

// Buttons zum Frame hinzufügen


add(eins);
add(und);
add(zwei);
} // Ende des Konstruktors

public static void main(String[] args)


{
// eine Instanz der Fensterklasse anlegen
GUI1 Fenster = new GUI1("Mein erstes GUI-Programm");

Fenster.pack();
Fenster.show();
}
}

Die Hauptklasse GUI1 des Programms wird von Frame abgeleitet und erhält ihren eigenen 
Konstruktor. Darin wird nicht nur der Rahmentitel über den Konstruktor von Frame erzeugt 
(deswegen super(..)) sondern es erfolgt auch noch die Anordnung der Knöpfe usw. im Fenster.

Nach der Deklaration der Buttons (und Belegung mit der Beschriftung)  müssen sie mit add() dem 
Layout hinzugefügt werden. Als Layout wurde das FlowLayout benutzt, bei dem die einzelnen 
Komponenten einfach der Reihe nach angeordnet werden.  Weitere wichtige Layouts sind :
BorderLayout() : die Elemente werden in die 5 „Himmelsrichtungen“ Central, North, East, South,  
West mit add("East", <Komponente>), add("Center", <Komponente>) usw. eingefügt.

15
Informatik mit Java 2010/11

GridLayout(n,m) : Einfügen der Elemente der Reihe nach in eine Tabelle mit n Zeilen und m Spalten
In der Hauptklasse main wird dann ein konkretes Fenster erzeugt und mit fenster.pack() auf kleinste 
sinnvolle Größe gebracht und dann mit fenster.show() angezeigt.

Das Programm in der vorliegenden Form funktioniert zwar, lässt sich aber leider nur mit 
<Strg+Alt+Esc> abschießen, da es auf sonst nichts reagiert !!! Wir müssen es also noch mit einer 
Event­Behandlung, der Reaktion auf äußere Ereignisse versehen :

Dazu muß zuerst die Ereignisbehandlung ermöglicht werden :
import java.awt.event.*; 

Dann ist für das ganze Fenster (Frame) die Reaktion auf das Anklicken in der oberen Leiste zu 
deklarieren (und zwar in der Hauptklasse GUI2, vor dem Konstruktor), damit es sich nicht nur 
vergrößern oder verkleinern sondern auch noch schließen lässt :

class FensterLauscher extends WindowAdapter


{
public void windowClosing(WindowEvent e) // hier wird überschrieben
{
// Das Programm beenden
System.exit(0);
}
}
  
Jetzt lässt sich das Programm mit einem Klick auf das Kreuz beenden (System.exit(0)).

Beim Drücken der Buttons soll gepiepst werden. Deshalb wird direkt unter der obigen Klasse 
eingefügt :

class AktionLauscher implements ActionListener


{
public void actionPerformed(ActionEvent e) // hier wird überschrieben
{
// einmal piepen beim Drücken des Buttons
java.awt.Toolkit.getDefaultToolkit().beep();
}
}

Dass hier implements und nicht extends steht liegt einfach daran, dass die Klasse ActionListener 
zwar deklariert war, aber keinen Inhalt hatte (abstrakte Klasse).

Auch der Konstruktor muss noch um die Verwendung dieser beiden Klassen ergänzt werden :

 // den Frame bei einem WindowListener anmelden


addWindowListener(new FensterLauscher());

// ActionListener für die Schalter registrieren


// Es wird jedes Mal eine neue Instanz angelegt. Man
// kann aber auch eine Instanz mehrfach verwenden
eins.addActionListener(new AktionLauscher());
und.addActionListener(new AktionLauscher());
zwei.addActionListener(new AktionLauscher());

Damit sind jetzt die Schaltknöpfe im graphischen Design vorhanden, aber die Möglichkeiten zur Ein­ 
und Ausgabe fehlen noch. Diese liefern unsere nächsten Objekte : TextField, TextArea und Label.
Mit dem Textfeld (TextField) können einzeilige Ein­ und Ausgaben gestaltet werden :

16
Informatik mit Java 2010/11

TextField t;
t = new TextField(int n); // maximal n sichtbare Zeichen
t.setText(String s); // Beschriftung mit der Zeichenkette s
String s = t.getText(); // eingegebene Zeichenkette
t.setEditable(false); // jetzt ist hier keine Eingabe mehr möglich
t.requestFocus(); // Cursor ins Feld t

Für die Beschriftung (Überschriften usw.) nimmt man am besten ein Label :

Label l;
l = new Label(String s); // Label mit Beschriftung durch einen String
l.setText(String s); // neue Beschriftung
String s = l.getText(); // Beschriftung lesen
l.setBackground(Color c); // Hintergrundfarbe setzen
l.setForeground(Color c); // Schriftfarbe setzen

Damit lässt sich ein einfaches Programm zur Bestimmung von Kubikzahlen wie folgt schreiben :

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

public class GUI3 extends Frame


{
// Variablendeklaration außerhalb des Konstruktors !!
Button ok;
Label Überschrift;
TextField eingabe;
TextField ausgabe;

class FensterLauscher extends WindowAdapter


{
public void windowClosing(WindowEvent e)
{
// Das Programm beenden
System.exit(0);
}
}

class AktionLauscher implements ActionListener


{
public void actionPerformed(ActionEvent e)
{
String input = eingabe.getText();
int a = Integer.parseInt(input);
int x =a*a*a;
String aus = String.valueOf(x);
ausgabe.setText(aus);
}
}
GUI3(String titel) //Konstruktor
{
super(titel); //Fenstertitel über den Konstruktor von Frame

// Buttons deklarieren
ok = new Button(" hoch 3 = ");
Überschrift = new Label("Berechnung der dritten Potenz");
eingabe = new TextField(3); // Maximal 3 Stellen
ausgabe = new TextField(10); // Maximal 10 Stellen

17
Informatik mit Java 2010/11

// Einen Layout Manager zum Anordnen der Schalter festlegen


setLayout(new BorderLayout());

// Elemente anordnen
add("North", Überschrift);
add("West", eingabe);
add("Center", ok);
add("East", ausgabe);

// den Frame bei einem WindowListener anmelden


addWindowListener(new FensterLauscher());

// ActionListener für die Schalter registrieren


ok.addActionListener(new AktionLauscher());

// Anfangswerte setzen
Überschrift.setBackground(Color.yellow);
eingabe.requestFocus();
ausgabe.setEditable(false);

} // Ende des Konstruktors

public static void main(String[] args)


{
// eine Instanz der Fensterklasse anlegen
GUI3 Fenster = new GUI3("Berechnung der 3. Potenz");

Fenster.pack();
Fenster.show();
}

Aufgaben :
1) Schreibe ein Programm, das die Fakultät n! einer Zahl n ermittelt.
2) Schreibe ein Programm, das das Produkt zweier Zahlen berechnet.
3) Schreibe ein Programm zur Tilgungsberechnung.
Eingaben : Schuld, Zinssatz, Jahresrate
Ausgabe : Zeit bis zur vollständigen Tilgung in Jahren.
4) Schreibe ein Programm, das nach Eingabe der Seitenlängen eines Quaders dessen Volumen und 
Oberfläche berechnet.
5) Ein Rechentrainer fürs große Einmaleins. Nach Eingabe der gewünschten Zahl von Aufgaben 
ermittelt der Rechner mit (int) 10*Math.random() eine Zufallszahl zwischen 0 und 9 sowie mit 10+
(int) 10*Math.random() eine zweite Zufallszahl zwischen 10 und 19 (Math.random liefert eine 
double­Zufallszahl zwischen 0 und 1). Der Benutzer soll dann das Produkt berechnen und eingeben. 
Ihm wird dann angezeigt, ob er richtig gerechnet hat oder nicht. Am Schluß soll dann noch der 
prozentuale Anteil der richtigen Aufgaben ausgegeben werden.

18
Informatik mit Java 2010/11

10) GUI und Applet


Bei einem Applet und einer Anweisung sind die Javaklassen und Befehle gleich. Unterschiede 
ergeben sich nur dadurch, dass jedes Applet zwar auch über einen Konstruktor verfügt, aber zusätzlich 
noch die Methode init() enthält, die ganz am Anfang aufgerufen wird. Die Klassen für das Layout 
können also sowohl in den Konstruktor als auch in die Methode init() geschrieben werden. Es ist 
allerdings üblich, nur init() zu verwenden. 
Die Reihenfolge beim Starten eines Applets ist : Konstruktor ­ init() ­ start(). Dabei entspricht start() 
in etwa der Methode main() einer Anwendung.

Als Beispiel für ein Applet mit (grafischer) Ein­ und Ausgabe wollen wir ein solches schreiben, das 
vom Anwender Name, Vorname und Ort einliest und zur Kontrolle wieder ausgibt. Um Ein­ und 
Ausgabe auch optisch zu trennen, verwenden wir im Frame 2 getrennte Bereiche, 2 Panels mit 
Gridlayout im ersten Panel :

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

public class GUIApplet extends Applet


{
// Variablendeklarationen am Anfang
Button ok;
Label name, vorname, ort;
TextField namef, vornamef, ortf;
TextArea ausgabe;
Panel Feld1, Feld2;

class AktionLauscher implements ActionListener


{
public void actionPerformed(ActionEvent e)
{
Auswertung();
}
}

public void init()


{
// Variablen mit Werten belegen
ok = new Button("OK");
name = new Label("Name :");
vorname = new Label("Vorname :");
ort = new Label("Ort :");
namef = new TextField(25);
vornamef = new TextField(25);
ortf = new TextField(25);
ausgabe = new TextArea(3,25);
Feld1 = new Panel();
Feld2 = new Panel();

ok.addActionListener(new AktionLauscher());

Feld1.setLayout(new GridLayout(4,2)); // 4 Zeilen und 2 Spalten


Feld1.add(name);
Feld1.add(namef);

19
Informatik mit Java 2010/11

Feld1.add(vorname);
Feld1.add(vornamef);
Feld1.add(ort);
Feld1.add(ortf);
Feld1.add(ok);

Feld2.add(ausgabe);

setLayout(new BorderLayout());
add("North", Feld1);
add("Center", Feld2);
}

public void Auswertung()


{
String nameein = namef.getText();
String vornameein = vornamef.getText();
String ortein = ortf.getText();

ausgabe.setText(vornameein+"\n"+nameein+"\n"+ortein);
}
}

Bei der Ausgabe wird eine TextArea verwendet. Der große Unterschied zum TextField ist, dass eine 
TextArea mehrere Zeilen besitzen kann und Möglichkeiten zum Scrollen bietet, wenn der Text nicht 
ganz in den vorgesehenen Bereich passt. In init() bei der Initialisierung der Variablen geben wir dann 
die Zahl der vorgesehenen Zeilen und Spalten ein. Zusätzlich könnte noch ein Anfangstext eingegeben 
werden. Es heißt dann z.B. ausgabe = new TextArea("Hier erscheint ihre Eingabe", 3,
25); .

Aufgaben :
6) Schreibe ein Applet zur Lösung der quadratischen Gleichung ax2 + bx +c = 0 mit Überschrift und  

Eingabe der Werte von a, b und c. Bei der Ausgabe soll in einer TextArea ein Text der Form „Diese  

Gleichung hat die beiden Lösungen x 1 = 1 und x 2 = 5 erscheinen.


7) Nach Eingabe einer natürlichen Zahl sollen alle ihre Teiler ausgegeben werden.

Bemerkungen :

Mit ausgabe.append(String s) lässt sich der String s an den bereits vorhandenen Text in der 
TextArea ausgabe anhängen. Ebenso lässt sich  mit ausgabe.insert(String s, int i) der String s an der 
Position i in den vorhandenen Text einfügen.  Und mit ausgabe.replaceRange(String s, int anfang, int  
ende) kann der Text zwischen dem Zeichen mit der Nummer anfang und dem Zeichen mit der Nummer 
ende überschrieben werden.

Um ein besseres Aussehen zu erreichen, ist es vorteilhaft, die Beschriftung der Label richtig zu 
plazieren. Mit name = new Label("Name :", Label.RIGHT) wird sie rechts orientiert (die anderen 
Möglichkeiten sind Label.LEFT und Label.CENTER).

Beim Button (und auch beim Label) besteht auch noch die Möglichkeit, die Position mit der Methode 
setLocation(int x, int y) sowie Position und Größe mit setBounds(int x, int y, int Breite, int Höhe) 
festzulegen. Allerdings sollte man dazu die absolute Lage des Applets kennen :­(( .

Auch die Farben können mit setBackground(Color c) und setForeground(Color c) geändert werden.

20
Informatik mit Java 2010/11

11) Grafik in Programmen(und Applets)


Um eine Grafik in einem Programm zu benutzen, braucht man als Zeichenfläche eine Canvas aus 
java.awt. Diese hat zum Zeichnen eine Methode paint(), die überschrieben werden muss. Die 
Zeichenobjekte selber ( Strecke, Rechteck, Kreis ...) stammen aus der Klasse Graphics, einer 
abstrakten Basisklasse. Damit erhält man als Grundkonstruktion :

// Definition der eigenen Canvas-Klasse :


class Zeichenfläche extends Canvas
{
....
// die Methode paint muss überschrieben werden :
public void paint(Graphics g)
{
// es folgen die eigenen Zeichenbefehle
g.setColor(Color.red);
g.drawString("ich kann auch schreiben", 10, 150);
g.drawLine(50, 0, 150, 300);
.....
}
}

// eine neue Malfläche definieren und ins Fenster aufnehmen


Zeichenfläche malfläche = new Zeichenfläche();
getContentpane.add(malfläche);

Mit getContentpane bekomme ich das umgebende Fenster. 

Die Klasse Graphics enthält u.a. folgende Methoden :
clearRect(...) Rechteck mit Hintergrundfarbe füllen
drawArc(...) Bogen zeichnen
drawImage(...) Bild einfügen
drawLine(...) Linie
drawOval(...) Kreis und Ellipsen
drawRect(...) Rechteck
drawString(...) Textausgabe
setColor(...) Zeichenfarbe
setFont(...) Zeichensatz

Genaueres dazu siehe im Java2 ­Buch in www.ohg­tuttlingen.de (kurz www) unter 
Lokales/Informatik/Java2 im Kapitel 23. Dort finden sich auch ausreichend viele Beispiele, auf die hier 
verwiesen wird.

In Kapitel 24 und 25 dieses Buches werden die Textausgabe mit der Wahl des Zeichensatzes sowie 
die Farben unter Java besprochen.

Als Beispiel soll nun noch ein Funktionsplotter für Parabeln der Form ax 2 + bx + c folgen (in  

Abänderung des Funktionenplotters aus Kap10). Dort wird allerdings nicht nur das AWT sondern  

auch noch das modernere (?) Swing (deswegen JFrame, JButton usw. )benutzt.

// Ein Funktionenplotter für Parabeln


import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

// Hauptfenster von Swing-Klasse JFrame ableiten


public class plotter extends JFrame
{

21
Informatik mit Java 2010/11

CMeineCanvas m_malflaeche;

double a=1;
double b=0;
double c=0;

TextField aeingabe,beingabe,ceingabe;

public static void main(String[] args)


{
plotter Fenster =
new plotter("Funktionenplotter");
Fenster.pack();
Fenster.setSize(400,400);
Fenster.setResizable(false);
Fenster.show();
}
// Im Konstruktor werden die Canvas-Malfläche und
// Schalter zur Auswahl der Funktionen angelegt
plotter(String titel)
{
super(titel);
// Einen Layout Manager einrichten
getContentPane().setLayout(new FlowLayout());
// Die Malfläche aufnehmen
m_malflaeche = new CMeineCanvas();
getContentPane().add(m_malflaeche);
// Schalter anlegen und in Panel aufnehmen
JButton f = new JButton("OK");
getContentPane().add(f);
// Eingabefelder anlegen und ins Panel aufnehmen
aeingabe = new TextField("a=?",6);
beingabe = new TextField("b=?",6);
ceingabe = new TextField("c=?",6);
getContentPane().add(aeingabe);
getContentPane().add(beingabe);
getContentPane().add(ceingabe);

class CMeinWindowAdapter extends WindowAdapter


{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}

// Das Event-Handling für die Schalter


class CMeinActionLauscher implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
a = Double.parseDouble(aeingabe.getText());
b = Double.parseDouble(beingabe.getText());
c = Double.parseDouble(ceingabe.getText());
// Neuzeichnen veranlassen
m_malflaeche.repaint();
}
}

22
Informatik mit Java 2010/11

// Die Lausch-Objekte anlegen


f.addActionListener(new CMeinActionLauscher());
addWindowListener(new CMeinWindowAdapter());
}

class CMeineCanvas extends Canvas


{
// Konstruktor
CMeineCanvas() {
// den Hintergrund auf schwarz setzen
setBackground(Color.black);
// Vordergrund (=Zeichenfarbe) auf grün setzen
setForeground(Color.green);
}

// Die wichtigste Methode: hier wird gezeichnet!


public void paint(Graphics g) {
double x,y;
int xpos,ypos;

// Ursprung umsetzen
g.translate(150,150);

// Koordinatenachsen einzeichnen
g.setColor(Color.red);
g.drawLine(0,-150,0,150);
g.drawLine(-150,0,150,0);
g.drawString("-3",-150,12);
g.drawString("-3",4,147);
g.drawString("+3",135,12);
g.drawString("+3",4,-140);

// Farbe zum Zeichnen der Funktion


g.setColor(new Color(255,255,0));

for(x= -3.0; x<=3; x += 0.005) {


y = a*x*x + b*x + c;
xpos = (int) (x*50);
ypos = (int) (-y*50);

g.fillOval(xpos,ypos,2,2); //kleiner Kreis statt eines Punktes, mit


dem Radius 1 nur einen Punkt zeichnen geht leider nicht
}
}

// Diese Methode liefert die minimale Größe der Canvas (Malfläche)


public Dimension getMinimumSize() {
return new Dimension(300,300);
}

// Die Lieblingsgröße setzen wir auf die Minimalgröße


public Dimension getPreferredSize() {
return getMinimumSize();
}
}
} // Ende der Klasse Plotter

23
Informatik mit Java 2010/11

24