1. Aufgabenblatt zur Medienprogrammierung in Java: Primzahlen

1. Aufgabenblatt zur Medienprogrammierung in Java:

Primzahlen

Schreiben Sie, ausgehend von dem Programm auf S. 15, ein Programm, das eine Zahl einliest und überprüft, ob diese Zahl eine Primzahl ist.

Hinweise: Eine Zahl > 1 ist eine Primzahl, wenn sie nur durch 1 und durch sich selber teilbar ist (die ersten Primzahlen sind: 2, 3, 5, 7, 11, 13).

Überprüfen Sie dies, indem Sie den Rest beim Teilen durch alle möglichen Teiler t testen (eine Zahl n ist durch t teilbar, wenn n % t == 0 ist).

Noch ein Hinweis: Am besten verwenden Sie eine boolean-Variable für die Primzahl-Eigenschaft, die Sie zunächst auf true setzen (Unschulds- vermutung) und dann auf false, wenn Sie einen Teiler gefunden haben.

Erweiterung 1: Verwenden Sie eine Funktion zur Berechnung der Primzahl- Eigenschaft, die eine boolean-Wert zurückgibt. Kopfzeile der

Funktionsdefinition: public static boolean istPrim (int n).

Erweiterung 2: Ändern Sie das Programm so ab, dass alle Primzahlen in einem eingegebenen Bereich ausgegeben werden. Lesen Sie die Unter- und die Obergrenze des Bereichs ein.

Erweiterung 3: Ändern Sie das Programm so ab, dass sogenannte Primzahlenzwillinge ausgegeben werden. Das sind Primzahlen die einen Abstand von 2 haben (z. B.: (11, 13), (17, 19), (29, 31), etc.).

Tipp: Falls Sie mit sehr großen Zahlen rechnen möchten, sollten Sie statt int (32 Bit, geht bis ca. 2·10⁹) den Typ long (64 Bit, geht bis ca. 9·10¹⁸) verwenden.

2. Aufgabenblatt zur Medienprogrammierung in Java:

Funktionstabelle

Geben Sie die Funktion y = e^-x² (Gauß-Funktion) im Bereich -4.0 bis +4.0 mit einer Schrittweite von 0.5 als Tabelle aus. Die Ausgabe soll formatiert, wie nachfolgend angegeben, erfolgen:

x y

--- -4.00 0.00000011 -3.50 0.00000479 .... ...

Zur formatierten Ausgabe siehe S. 16. Die Exponentialfunktion wird als Math.exp() aufgerufen.

Erweiterungen:

1. Anfangs- und Endwert sowie Schrittweite der Tabelle sollen vorher eingegeben werden. Verwenden Sie zur Eingabe die Klasse Scanner (siehe auch S. 15):

Scanner in = new Scanner (System.in);

Ein double-Wert x wird so eingelesen:

x = in.nextDouble ();

2. Damit alle Tabelleneinträge auch bei großen Tabellen lesbar sind, soll die Ausgabe alle 20 Zeilen angehalten werden (in.nextLine()

verwenden).

3. Das ganze Programm ist in einer Schleife zu wiederholen. Am Ende soll abgefragt werden, ob wiederholt werden soll (Eingabe j/n). Ein char-Wert wird so eingelesen:

text = in.nextLine (); // String lesen

ch = text.charAt (0); // und 1. Zeichen daraus holen 4. Es soll sichergestellt werden, dass bei positiver Schrittweite der Endwert

größer als der Anfangswert ist.

5. Das Programm soll so angepasst werden, dass die Tabelle auch in umgekehrter Richtung ausgegeben werden kann (und zwar dann, wenn bei negativer Schrittweite der Endwert kleiner als der Anfangswert ist).

6. Verwenden Sie zur Ausgabe der gesamten Tabelle eine Funktion, die als Parameter Anfangs- und Endwert, Schrittweite und den Scanner in hat.

Die Funktion muss als static vereinbart werden.

3. Aufgabenblatt zur Medienprogrammierung in Java:

Definition einer Rechteck-Klasse

In dieser Aufgabe werden verschiedene Klassen definiert. Legen Sie für jede Klasse eine eigene Datei an (in Eclipse: Rechtsklick auf Projekt, dann New Class).

1. Definieren Sie eine Klasse Rechteck, die folgende Elemente enthält:

• Variablen für die Eigenschaften Breite und Höhe,

• Methoden:

- einen geeigneten Konstruktor mit Breite und Höhe als Parametern,

- Methoden zur Berechnung von Fläche und Umfang,

- eine Methode zur Ausgabe der Eigenschaften, oder, was die Klasse noch flexibler macht: eine toString()-Methode, die das Objekt in einen String umwandelt.

Testen Sie die Klasse Rechteck mit einer eigenen Klasse Rechteck- Test, die das Hauptprogramm enthält: Hier werden zwei Rechteck- Objekte angelegt (die Breiten und Höhen entweder fest ins

Hauptprogramm einbauen oder einlesen), mit der Ausgabe-Methode angezeigt sowie Fläche und Umfang berechnet und ausgegeben.

2. Erweitern Sie das Programm aus Aufgabe 1 folgendermaßen:

Leiten Sie von der Rechteck-Klasse eine Klasse PosRechteck ab, die zusätzlich folgendes enthält:

• Variablen für die Position (Mittelpunkt) des Rechtecks,

• Methoden:

- einen geeigneten Konstruktor mit Breite, Höhe und Mittelpunkts- koordinaten als Parametern,

- eine Methode zum Verschieben des Rechtecks um einen als Parameter übergebenen Vektor,

- eine erweiterte Methode zur Ausgabe bzw. toString()-Methode, in der Sie aber auf die entsprechende Methode der Klasse

Rechteck zurückgreifen können.

Ergänzen Sie das Hauptprogramm: erzeugen Sie auch ein Objekt der Klasse PosRechteck, geben Sie es aus, berechnen Sie Fläche und Umfang, verschieben Sie es und geben Sie es erneut aus.

4. Aufgabenblatt zur Medienprogrammierung in Java:

Taschenrechner

1. Definieren Sie eine Klasse CalcFrame, die ein Textfeld (JTextField) und 20 Buttons (JButton) enthält. Die Anordnung soll folgendermaßen sein:

Verwenden Sie dazu ein geschachteltes Layout (benutzen Sie die Layout- Manager BorderLayout und GridLayout). Um die Buttons in einer Schleife erzeugen zu können, verwendet man zweckmäßigerweise ein Array von Strings mit den Beschriftungen.

2. Vererben Sie das ActionListener-Interface an die Klasse CalcFrame und definieren Sie die actionPerformed()-Methode so, dass Zahlen über die Buttons in das Textfeld eingegeben werden können. Hinweis: Das Textfeld können Sie mit den Methoden getText() und setText() lesen bzw. beschreiben.

Erweiterung: Ordnen Sie auch dem C-, CE- und Del-Button eine Funktion zu (C, CE: Anzeige löschen, Del: letztes eingegebenes Zeichen löschen).

Hinweis: Für die Del-Funktion können Sie aus dem String, der den

Anzeigetext enthält, mit der substring()-Methode das relevante Stück herausschneiden:

text.substring(start, end) gibt von einem String text das Stück zurück, das bei Position start beginnt und bei Position end-1 (inklusive) endet.

5. Aufgabenblatt zur Medienprogrammierung in Java: Smiley

oder

Überschreiben Sie die paintComponent()-Methode und rufen Sie dort die entsprechenden Zeichen-Methoden mit geeigneten Koordinaten auf. Im linken Smiley wurden nur g2.drawLine() und g2.drawOval()

verwendet, im rechten zusätzlich g2.fillOval(), g2.fillPolygon() und g2.drawArc(). Zur Methode drawArc() siehe die Dokumentation von Java (Klasse Graphics2D).

Im Konstruktor können Sie eine geeignete Anfangsgröße für das Objekt festlegen, indem Sie setPreferredSize (new Dimension (w, h)) aufrufen mit geeigneten Werten für die Breite w und die Höhe h.

Erzeugen Sie in der main()-Funktion ein JFrame-Objekt frame und ein SmileyComp-Objekt, das Sie dann dem JFrame-Objekt hinzufügen (frame.add(…) aufrufen). Passen Sie die Frame-Größe mit

frame.pack() an die bevorzugte Komponentengröße an und vergessen Sie nicht, den Frame sichtbar zu machen mit frame.setVisible(true).

Erweiterung: Das Smiley lässt sich nachträglich in der Größe verändern, indem man zu Beginn der paintComponent()-Methode schreibt:

g2.scale(sx, sy). Dabei sind sx und sy reelle Skalierungsfaktoren für die x- und die y-Richtung. Um eine Größenanpassung des Smileys an die Fenstergröße zu erreichen, berechnen Sie sx und sy in geeigneter Weise aus der Größe der Komponente (getWidth() und getHeight()

verwenden).

6. Aufgabenblatt zur Medienprogrammierung in Java: Stern

darstellt, z. B.:

Die Ecken des Sterns haben folgende Koordinaten:

x = radius * Math.cos (i * step*2*Math.PI / ecken) + xm;

y = radius * Math.sin (i * step*2*Math.PI / ecken) + ym;

Dabei sind:

radius: Umkreisradius des Sterns

ecken: Anzahl der Ecken (im Beispiel 5)

step: Gibt an, wie die Ecken verbunden werden (ausprobieren!) xm, ym: Mittelpunktskoordinaten

i: Nummer der Ecke (0 ... ecken-1)

Legen Sie ecken, step, xm, ym und radius als Instanzvariablen an.

Übergeben Sie die Werte für ecken und step im Konstruktor als Parameter.

Die Variablen xm, ym und radius können Sie zunächst mit konstanten Werten initialisieren.

In der paintComponent()-Funktion können Sie dann die Eckpunkte berechnen und den Stern zeichnen. Dazu gibt es zwei Möglichkeiten:

1. Die Punkte durch einzelne Linien verbinden (dazu muss man sich immer den letzten Punkt merken). 2. Die Koordinaten in Arrays schreiben und den Stern mit drawPolygon() zeichnen.

Erweiterung: Berechnen Sie den Radius sowie xm und ym aus der Größe der Komponente (getWidth() und getHeight() verwenden).

7. Aufgabenblatt zur Medienprogrammierung in Java:

Zeigeruhr

In dieser Aufgabe geht es darum, ein Programm zu entwickeln, das eine Zeigeruhr darstellt:

1. Zum Lesen der Uhrzeit können Sie die beiden Klassen Date und GregorianCalendar verwenden (beide im java.util-Paket). Ein Objekt der Date-Klasse enthält die Repräsentation einer Zeit

(Genauigkeit Millisekunden). Wird der Standardkonstruktor verwendet (new Date()), so repräsentiert das Objekt die aktuelle Zeit. Die Klasse GregorianCalendar dient ebenso dazu, eine Zeit zu speichern.

Zusätzlich lassen sich damit aber auch Sekunde, Minute, Stunde, Tag, Monat und Jahr bestimmen. Ein GregorianCalendar-Objekt mit der aktuellen Zeit erhält man durch:

GregorianCalendar greg = new GregorianCalendar ();

Wenn schon ein GregorianCalendar-Objekt (greg) vorliegt, kann man nachträglich dessen Zeit aktualisieren mit:

greg.setTime (new Date ());

Die Werte von Stunde, Minute, etc. lassen sich folgendermaßen lesen:

int h = greg.get (Calendar.HOUR_OF_DAY);

int m = greg.get (Calendar.MINUTE);

int s = greg.get (Calendar.SECOND);

► Lesen Sie in einem Testprogramm (einmal) die Uhrzeit und geben Sie Stunde, Minute und Sekunde aus.

2. Um die Uhrzeit periodisch auszulesen, kann man die Klasse Timer (aus dem javax.swing-Paket) verwenden. Ein solcher Timer wird erzeugt durch

Timer tim = new Timer (ms, listener);

Dabei ist ms das Zeitintervall in Millisekunden, listener ist ein ActionListener-Objekt. Am einfachsten ist es, bei der aktuellen Klasse das ActionListener-Interface implementieren (dann muss man als Listener this angeben). Der Timer tim wird mit

tim.start ();

gestartet. Die Timer-Events werden an die actionPerformed()- Methode des Listeners geschickt. Tipp: Um ein zeitlich exaktes

Umschalten der Sekunde zu erreichen, kann man den Timer schneller als im Sekundentakt laufen zu lassen (z. B. 100 ms) und die Zeit nur dann anzuzeigen, wenn sich der Sekundenwert geändert hat.

► Ändern Sie das Testprogramm so ab, dass die Uhrzeit im Sekundentakt ausgegeben wird.

3. Für das Zeigeruhr-Programm definieren Sie eine Klasse Zeigeruhr, die von JComponent abgeleitet ist. Die aktuelle Zeit können Sie in einem GregorianCalendar-Objekt (Instanzvariable) abspeichern.

Verwenden Sie wie in Punkt 2 einen Timer. Wenn sich die Uhrzeit geändert hat, rufen Sie die Funktion repaint() auf, die bewirkt, dass die Komponente neu gezeichnet wird (paintComponent() wird

automatisch aufgerufen). Schreiben Sie eine Methode drawClock(), die die aktuelle Uhrzeit grafisch darstellt. Parameter der Methode können neben dem Graphics2D-Kontext auch der Radius und die Mittelpunktskoordinaten des Zifferblatts sein.

Es ist sinnvoll, eine Methode drawZeiger() zu definieren, die einen Zeiger mit einem bestimmten Winkel zeichnet. Die Kopfzeile dieser Methode könnte so aussehen:

public void drawZeiger (Graphics2D g2, double xm, double ym, double len1, double len2, double winkel, double dicke, Color c)

4. Dabei sind xm und ym die Koordinaten des Zentrums, len1 und len2 sind der Abstand des Anfangs- bzw. Endpunkts vom Zentrum, winkel ist der Winkel relativ zu 12 Uhr im Uhrzeigersinn, dicke und c sind Dicke und Farbe des Zeigers. Diese Funktion lässt sich auch zum Zeichnen der Sekundenmarkierungen am Rand des Zifferblatts verwenden.

Tipp: Wenn die Zeiger etwas über das Zentrum überstehen sollen, muss man einfach nur len1 negativ wählen.

Der Endpunkt (x, y) des Zeigers wird wie folgt berechnet:

x = (int) (xm + len2 * Math.sin (b));

y = (int) (ym - len2 * Math.cos (b));

Dabei ist b der ins Bogenmaß umgerechnete Winkel (b = winkel * Math.PI / 180).

Die Typumwandlung (int) ist nur notwendig, wenn x und y int- Variablen sind.

Es sind verschiedene Erweiterungen bzw. Änderungen des Programms denkbar:

• Statt eines Timers kann ein Thread verwendet werden, der in einer Endlosschleife die Uhrzeit überprüft (und dazwischen mit

Thread.sleep (millisecs) wartet).

• Es können zum Zeichnen Shape-Objekte verwendet werden (Line2D, Ellipse2D). Dies hat den Vorteil, dass man die Koordinaten als

double-Werte angeben kann (dies ist für den nächsten Punkt notwendig).

• Man kann in der Methode drawClock() eine Einheitsuhr zeichnen (Radius 1, Mittelpunkt (0, 0)). Diese lässt sich dann mit Hilfe von Transformationen (Funktionen translate(), scale()) an die Fensterkoordinaten anpassen.

• Um die Uhr realistischer aussehen zu lassen, kann man Zeigerschatten malen (s. Abb. am Anfang). Dazu muss man eine Farbe mit

Transparenz wählen.

8. Aufgabenblatt zur Medienprogrammierung in Java:

Multithreading

1. Ändern Sie das Programm mit der Zeigeruhr (Aufgabe vom letzten Mal) so ab, dass anstelle des Timers ein eigener Thread verwendet wird, der die Uhrzeit liest und bei Änderungen die repaint()-Methode aufruft.

2. Schreiben Sie ein Programm, das einen Ball (oder eine Billardkugel) simuliert, der in zwei Dimensionen ohne Reibung in seinem Fenster bewegt und an den Seiten reflektiert wird. Verwenden Sie dazu wie in Aufgabe 1 einen Thread, der die Ball-Koordinaten berechnet.

• Definieren Sie eine Klasse BallComp, abgeleitet von JComponent, die das Runnable-Interface implementiert. Diese Klasse enthält dann die run()-Methode und die paintComponent()-Methode. Im

Hauptprogramm können Sie einen Frame erzeugen und ein BallComp- Objekt hinzufügen.

• Ändern Sie das Programm so ab, dass Sie die run()-Methode in eine eigene Klasse Ball auslagern, die nur die Koordinatenänderung des Balls berechnet. Die Ball-Klasse soll Methoden zum Lesen der Ball- koordinaten enthalten. Übergeben Sie im Konstruktor als Parameter das BallComp-Objekt, damit vom Ball-Objekt aus Zugriff auf das BallComp-Objekt haben (um die repaint()-Funktion aufzurufen).

• Ändern Sie das Programm so ab, dass mehrere Bälle sich in der Komponente bewegen. Dazu sollten Sie mehrere Ball-Objekte anlegen, von denen jedes in einem eigenen Thread läuft. Im Idealfall legen Sie dazu ein Array von Ball-Objekten an.

• Mögliche Erweiterungen sind: Individuelle Ballgröße, -geschwindigkeit und -farbe, die in der Ball-Klasse abgespeichert werden.

So könnte das Ganze aussehen:

9. Aufgabenblatt zur Medienprogrammierung in Java:

Erzeugen und Zeichnen von Shape-Objekten

In dieser Aufgabe geht es darum, verschiedene Formen mit Hilfe von Shape- Objekten zu zeichnen. Ein Shape-Objekt beschreibt eine beliebige Form, deren Umriss gezeichnet oder gefüllt werden kann. Gegenüber den bisherigen

Zeichen-Methoden ergeben sich verschiedene Vorteile:

• Man benötigt nur noch zwei Methoden (draw() und fill()) zum Zeichnen.

• Verschiedenartige Formen lassen sich zeichnen, ohne dass man wissen muss, um welche konkrete Form es sich handelt.

• Die zu zeichnenden Objekte müssen nur einmal erzeugt werden und können dann beliebig oft gezeichnet werden.

• Es können reellwertige Koordinaten angegeben werden. Dies ist

insbesondere im Zusammenwirken mit Koordinatentransformationen nützlich.

Shape ist keine Klasse, sondern ein Interface, so dass Shape-Objekte nicht direkt als Instanzen von Shape erzeugt werden können. Es gibt aber eine Reihe von Klassen, die das Shape-Interface implementieren und von denen sich

Objekte erzeugen lassen. Dies sind z. B.:

Rectangle2D Rechteck

RoundRectangle2D Rechteck mit abgerundeten Ecken Ellipse2D Ellipse

Arc2D Ellipsenbogen

Line2D Gerade Linie

QuadCurve2D Kurve 2. Ordung (Parabel) CubicCurve2D Kurve 3. Ordung (Bezier-Kurve)

Path2D Aus Stücken zusammengesetzte Form Shape ist definiert im Paket java.awt, die oben aufgelisteten Klassen sind definiert im Paket java.awt.geom .

Achtung: für die Konstruktoren können nicht die obigen Klassennamen verwendet werden (da es abstrakte Klassen sind). Stattdessen muss an den Klassennamen noch .Double oder .Float (großgeschrieben!) angehängt werden. Die Konstruktoren erwarten dann double- bzw. float-Parameter.

Hat man ein Shape-Objekt erzeugt, so kann dieses mit Hilfe der draw()- und fill()-Funktionen von Graphics2D gezeichnet werden, z. B.:

. . .

Graphics2D g2 = (Graphics2D) g;

Shape s = new Ellipse2D.Double (...);

g2.draw (s); // Umriss der Ellipse zeichnen g2.fill (s); // Ellipse füllen

. . .

1. a) Finden Sie mit Hilfe der Java-Dokumentation oder anderer Quellen heraus, welche Parameter die Konstruktoren der obigen Klassen (mit .Double am Ende) benötigen.

b) Schreiben Sie ein Beispielprogramm, in dem die Objekte der oben

genannten Klassen Rectangle2D.Double bis CubicCurve2D.Double erzeugt und angezeigt werden.

c) Speichern Sie die Shape-Objekte in einem Shape-Array ab. Verwenden Sie zum Zeichnen der Objekte eine for-Schleife (mit Index oder als foreach- Schleife).

2. Erzeugen Sie ein Path2D.Double-Objekt (Konstruktor ohne Parameter).

Damit lässt sich eine beliebige Form zusammenbauen. Sie können dazu folgende Funktionen verwenden:

moveTo (double x, double y)

Bewegt den aktuellen Punkt nach (x, y) ohne etwas zu zeichnen.

lineTo (double x, double y)

Zieht eine gerade Linie vom letzen Punkt zum Punkt (x, y).

quadTo (double xc, double yc, double x, double y) Zeichnet eine Parabel vom letzten Punkt zum Punkt (x, y) mit dem Kontrollpunkt (xc, yc).

curveTo (double xc1, double yc1,

double xc2, double yc2, double x, double y) Zeichnet eine Bézier-Kurve 3. Ordnung vom letzten Punkt zum Punkt (x, y) mit den Kontrollpunkten (xc1, yc1) und (xc2, yc2).

closePath ()

Verbindet den Anfangspunkt mit dem letzten Punkt um eine geschlossene Form zu erzeugen.

append (Shape s, boolean connect)

Damit lässt sich ein Shape-Objekt s an das Path2D.Double- Objekt anhängen. Durch wiederholte Anwendung von append() können so komplizierte Path2D.Double-Objekte erzeugt werden.

Der Parameter connect gibt an, ob vom letzten Punkt eine Verbindungslinie zum Objekt s gezogen wird.

• Erzeugen Sie die Formen von verschiedenen Großbuchstaben als Path2D.Double-Objekte und zeichnen Sie diese.

• Erzeugen Sie mit Hilfe von append() ein Smiley als Path2D.Double- Objekt und zeichnen Sie es.

10. Aufgabenblatt zur Medienprogrammierung in Java:

Bézier-Kurve

Darstellung und Editierung einer so

genannten Bézier-Kurve (s. Abb. rechts).

Dies ist eine Kurve, die durch vier

Kontrollpunkte (Kreise in der Abb.) definiert wird. Zwei der Punkte sind Anfangs- und Endpunkt der Kurve. Die anderen beiden geben die Richtung der Kurve am Anfangs- bzw. Endpunkt vor.

In Java gibt es eine Klasse zur Darstellung solcher Bézier-Kurven:

CubicCurve2D.Double (definiert im Paket java.awt.geom). Ein Objekt dieser Klasse kann wie folgt erzeugt werden:

CubicCurve2D.Double bezier =

new CubicCurve2D.Double ();

Die Kontrollpunkte lassen sich folgendermaßen setzen:

bezier.setCurve (x0, y0, x1, y1, x2, y2, x3, y3);

Dabei ist (x0, y0) der Anfangspunkt, (x3, y3) ist der Endpunkt. (x1, y1) und (x2, y2) sind die Punkte, die die Richtung vorgeben. Alle Koordinaten müssen als double-Werte angegeben werden. Um das Objekt zu zeichnen, schreibt man: g2.draw (bezier); wobei g2 der Graphics2D-Kontext ist.

Die Klasse BezierComp

Programmieren Sie eine Klasse BezierComp, die von JComponent abgeleitet ist. In dieser Klasse (Methode paintComponent()) soll die Bézier-Kurve gezeichnet werden. Außerdem sollen die Kontrollpunkte durch Kreise dargestellt werden.

Als Instanzvariablen sollten Sie die Koordinaten der Kontrollpunkte und das Bézier-Kurven-Objekt (vom Typ CubicCurve2D.Double) definieren.

Durch Klicken innerhalb eines Kreises und Ziehen der Maus (bei gedrückter Maustaste) soll der entsprechende Kontrollpunkt verschoben werden. Dies geschieht am besten mit Hilfe des MouseMotionListener-Interfaces, das die Klasse BezierComp implementieren sollte. Damit die Maus-Events an das BezierComp-Objekt geschickt werden, muss man im Konstruktor

addMouseMotionListener (this);

aufrufen.

Das MouseMotionListener-Interface hat zwei Methoden:

public void mouseMoved (MouseEvent e) und public void mouseDragged (MouseEvent e)

Die erste wird aufgerufen, wenn die Maus bei nicht gedrückter Maustaste bewegt wird, die zweite, wenn sie bei gedrückter Maustaste bewegt wird. Die Position der Maus kann man in den beiden Funktionen folgendermaßen erhalten:

int ex = e.getX (); bzw. int ey = e.getY ();

Überprüfen Sie in der mouseDragged()-Funktion, ob sich der Punkt (ex, ey) in einem der Kreise befindet (Abstand vom jeweiligen Kontrollpunkt z. B. mit Math.hypot() berechnen). Setzen Sie in diesem Fall den Kontrollpunkt auf (ex, ey) und rufen Sie repaint() auf.

Erzeugen Sie im Hauptprogramm einen JFrame, der das BezierComp- Objekt enthält.

Erweiterung: Wird eine Stelle außerhalb der vier Kontrollpunkte angeklickt und die Maus gezogen, so sollen alle vier Punkte verschoben werden, d. h.

die ganze Bézier-Kurve wird komplett parallel verschoben (die Form ändert sich nicht). Dazu ist es nützlich, die letzten Maus-Koordinaten in zwei

Instanzvariablen abzuspeichern. Man kann dann den Verschiebungsvektor als Differenz der aktuellen und der abgespeicherten Koordinaten berechnen.

Verbesserte Ein- und Ausgabemöglichkeiten seit Java JDK 5.0

Eingabe

Die Eingabe von Texten und Zahlen über das Konsolenfenster war vor JDK 5.0 sehr mühsam (vgl. Skript V0.7). Dies hat sich in Version 5.0 wesentlich verbessert. Im Paket java.util gibt es die Klasse Scanner, die sich dafür verwenden lässt. Die Klasse Scanner dient zum Einlesen von Werten aus Dateien, Eingabe-Streams oder Strings.

Erzeugen eines Scanner-Objekts zur Standardeingabe:

Scanner in = new Scanner (System.in);

Methoden der Scanner-Klasse zum Lesen von Daten:

Aufruf Rückgabetyp Funktion

in.next () String Liest ein Wort (bis zum nächsten Trennzeichen) in.nextLine () String Liest eine Textzeile

in.nextShort () in.nextInt () in.nextLong ()

short int long

Liest einen short-, int-, bzw.

long-Wert in.nextFloat ()

in.nextDouble ()

float double

Liest einen float-, bzw.

double-Wert

Beispiel: Einlesen eines Texts und einer Zahl von der Standardeingabe:

import java.util.*;

class EingScan {

public static void main (String [] args) {

String name;

int alter;

Scanner in = new Scanner (System.in);

System.out.print ("Wie heisst Du: ");

name = in.nextLine ();

System.out.print ("Wie alt bist Du: ");

alter = in.nextInt ();

System.out.println ("Hallo, " + name + ", Du bist "

+ alter + " Jahre alt.");

in.close ();

} }

Ausgabe

Die von C++ her bekannten Formatierungen können seit SDK 1.5 mit Hilfe der Methode printf () (angelehnt an die gleichnamige C-Funktion) in Java-Code umgesetzt werden:

C++ Java

int n;

cout << setw (5) << n;

int n;

System.out.printf ("%5d", n);

double x;

cout << setw (10) << fixed << setprecision (2) << x;

cout << setw (10) << scientific << setprecision (2) << x;

double x;

System.out.printf ("%10.2f", x);

System.out.printf ("%10.2e", x);

Die printf-Methode hat als ersten Parameter einen Format-String, der angibt, in welchem Format die weiteren Parameter ausgegeben werden. Der Format-String kann aus normalen Textzeichen bestehen, die dann unverändert ausgegeben werden, und aus Sequenzen, die mit einem %-Zeichen beginnen. Letztere beziehen sich meist auf einen Parameter.

Aufbau der %-Sequenzen: % Flag Breite .Präzision Konversionszeichen

Dabei sind Flag, Breite und .Präzision optionale Angaben. Flag steht in der Regel für ein Zeichen (z. B. - für "linksbündig", der Standard ist "rechtsbündig"). Breite steht für die Feldbreite (Anzahl der Zeichen) mit der ein Parameterwert ausgegeben wird. Die Angabe .Präzision ist nur für reelle Werte sinnvoll und gibt die Anzahl der Nachkommastellen an.

Hier eine Auswahl von Konversionszeichen:

Konversions- zeichen

Parametertyp Formatierung

d ganze Zahl Dezimalzahl

x ganze Zahl Hexadezimalzahl f reelle Zahl ohne Exponent e reelle Zahl mit Exponent

g reelle Zahl mit oder ohne Exp. (kürzeres) a reelle Zahl Hexadezimalwert

s String

c Einzelzeichen

b boolescher Wert true / false

tZeichen Datum / Uhrzeit je nach Zeichen nach t

% - Prozentzeichen

n - neue Zeile

Mehrere %-Sequenzen beziehen sich in der Regel auf aufeinanderfolgende Parameter, es sei denn, als Flag ist n$ angegeben (n steht für eine Zahl): Dann bezieht sich die Sequenz auf den Parameter Nummer n (gezählt ab 1). Wenn als Flag < angegeben ist, wird der gleiche Parameter wie bei der vorangehenden %-Sequenz verwendet.