GKJava 13.1

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
}
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 yKoordinaten 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;
x += 1;
x++;
}
}
Die wichtigsten Variablentypen sind :
2
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 castingOperator 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 UnixWelt bekannten ByteStrö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 ParseBefehl 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
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

{
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
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
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
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
5. Grafik mit der Turtle

Als Einstieg in die Grafik wählen wir das einfachste Grafikmodell, die TurtleGrafik, 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
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 nEck 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 nEcke gleichzeitig verschiebt und dreht. Experimentiere.
9
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 doSchleife 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
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;
break;
break;
.....................
default : <Anweisung>;
break;
}
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 switchBefehls beendet wird. Sonst würden alle (nicht
zutreffenden) Anweisungen bis zum Ende der switchKonstruktion 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 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 doubleZufallszahl 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 (ASCIICode).
12
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 nte 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
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*(n1)!
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
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), PulldownMenus (Menu),
Markierungskästchen (Checkbox), Textfelder (Textfield), Rollbalken (Scrollbar) usw.
LayoutManager : 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

{
// 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
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
EventBehandlung, 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
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.*;
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);
}
}

{
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
// 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

{
// 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
doubleZufallszahl 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
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.*;
public class GUIApplet extends Applet

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

{
{
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
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
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.ohgtuttlingen.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.*;
// Hauptfenster von Swing-Klasse JFrame ableiten

public class plotter extends JFrame
{
21
CMeineCanvas m_malflaeche;
double a=1;
double b=0;
double c=0;
TextField aeingabe,beingabe,ceingabe;

{
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
{
{
a = Double.parseDouble(aeingabe.getText());
b = Double.parseDouble(beingabe.getText());
c = Double.parseDouble(ceingabe.getText());
// Neuzeichnen veranlassen
m_malflaeche.repaint();
}
}
22
// 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
24

GKJava 13.1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

GKJava 13.1

Uploaded by

Copyright:

Available Formats

Informatik mit Java 2010/11

1. Erstes Programm und erstes Applet

public class CHalloWWW extends java.applet.Applet

public class COperatoren

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

Die Umwandlung verschiedener Datentypen ineinander erfolgt automatisch, sofern dies problemlos

3. Ein- und Ausgabe

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

public class Listing0203

Scanner scanner = new Scanner(System.in);

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

4. Arbeiten mit Dateien

public class AusgabeinDatei

ausgabe.println(“Mein erster Text“);

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

public class EinlesenausDatei

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

// Dateiende der Quelldatei erreicht.

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

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

catch (IOException e) // allgemeiner IO-Fehler

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

Aufgabe: Teste die obigen Befehle.

5. Grafik mit der Turtle

public class TurtleApplet extends Applet

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

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

8. Methoden (oder Funktionen)

<Typ der Methode> Methodenname(<Parameterliste>

double hoch(double Basis, int Hochzahl)

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

9. Graphische Benutzeroberfläche GUI - Einführung

public class GUI1 extends Frame

// Einen Layout Manager zum Anordnen der Schalter festlegen

// Buttons zum Frame hinzufügen

public static void main(String[] args)

class FensterLauscher extends WindowAdapter

class AktionLauscher implements ActionListener

// den Frame bei einem WindowListener anmelden

// ActionListener für die Schalter registrieren

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

public class GUI3 extends Frame

class FensterLauscher extends WindowAdapter

class AktionLauscher implements ActionListener

// Einen Layout Manager zum Anordnen der Schalter festlegen

// den Frame bei einem WindowListener anmelden

// ActionListener für die Schalter registrieren

} // Ende des Konstruktors

public static void main(String[] args)

10) GUI und Applet

public class GUIApplet extends Applet

class AktionLauscher implements ActionListener

public void init()

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

public void Auswertung()

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

11) Grafik in Programmen(und Applets)

// Definition der eigenen Canvas-Klasse :

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

// Ein Funktionenplotter für Parabeln

// Hauptfenster von Swing-Klasse JFrame ableiten

public static void main(String[] args)

class CMeinWindowAdapter extends WindowAdapter

// Das Event-Handling für die Schalter

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