Für die folgenden Programmbeispiele wird BlueJ benutzt. BlueJ ist eine integrierte Entwicklungsumgebung für Java, die speziell für Ausbildungszwecke konzipiert wurde. Insbesondere das Vermitteln von
Zusammenhängen in der objektorientierten Programmierung steht im Mittelpunkt des
Systems. Nach der Installation des Programmes benötigen wir noch die Basisbibliothek
basisSwing130203UTF8.jar. Diese befindet sich in dem
Programmpaket, dass im Link angegeben ist. In den entpakten
Dateien befinden sich alle Materialien, die in der EF im
Unterricht benötigt werden. Als Programm kommt hier jedoch der
JavaEditor zum Einsatz. Ich weiche zum Teil von den Beispielen
ab und greife auch auf das Material aus "Von Stiften und Mäusen"
zurück. Letztere benutzt eine etwas andere Klassenbibliothek.
Die Klasse Fenster
Mit Hilfe der Klasse Fenster können Ausgaben auf dem Computerbildschirm angezeigt werden. Die Größe des Fensters ist frei wählbar und wird nur durch die Anzeigekapazität des vorhandenen
Monitors begrenzt. Auf
ihm kann mit
Stiften gezeichnet werden. Zu diesem Zweck ist
die Zeichenebene auf dem Bildschirm mit einem
Koordinatensystem versehen, dessen Ursprung sich in der
oberen linken Ecke der Zeichenebene befindet und dessen Achsen
horizontal nach rechts und vertikal nach unten gerichtet
sind. Die Einheit ist ein Pixel.
Die zur Basisklasse gehörende Dokumentation gibt Auskunft
darüber, mit welcher Befehlsfolge die Konstruktoren und
Methoden aufgerufen werden. Da ich nicht auf alle
Programmierdetails eingehe, empfehle ich, sich die beiden
oben genannten Dokumentationen auszudrucken.
Beginnen wir mit einem einfachen Beispiel. Auf dem
Monitor soll ein Fenster der Breite 400 und der Höhe 200,
welches einigermaßen mittig auf dem Computerdisplay
dargestellt wird, mit blauer Hintergrundfarbe erzeugt
werden.
import basis.*;
public class aufgabe
{
//
Instanzvariablen
Fenster Bildschirm;
//Konstruktor
für Objekte der Klasse Fenster
public aufgabe()
{
// Instanzvariable initialisieren
Bildschirm = new
Fenster(600,400);
}
//Methoden
public void
fuehreAus() {
// tragen Sie hier den Code ein
Bildschirm.setzePosition(690,400);
Bildschirm.setzeHintergrundFarbe(Farbe.BLAU);
}
}
Die Klasse Farbe stellt folgende Farben zur Verfügung
(bitte auf die Gr0ßschreibung achten!): BLAU,
CYAN,DUNKELGRAU,DURCHSICHTIG, GELB, GRAU, GRUEN, GRÜN,
HELLGRAU, MAGENTA, ORANGE, PINK, ROT, SCHWARZ und WEISS.
Andere Farben lassen sich über den Farbbefehl
Farbe.rgb(r,g,b) auswählen. r, g und b können Werte zwischen
0 und 255 annehmen.
Die Klasse Stift
Der Stift ist ein Werkzeug, das sich auf dem Bildschirm
bewegen kann. Er befindet sich stets auf einer genau
definierten Position des Bildschirms, die durch
Zeichenkoordinaten (horizontal nach rechts, vertikal nach
unten) angegeben wird, und zeigt in eine Richtung, die durch
Winkel beschrieben wird (0° entspricht der Richtung nach
rechts, Drehsinn ist mathematisch positiv). Der Stift kennt
zwei Zustände: Ist der Stift abgesenkt (runter) und bewegt
er sich über den Bildschirm, so hinterlässt er eine Spur,
die von einem Zeichenmodus abhängig ist. Ist der Stift
angehoben (hoch hinterlässt er keine Spur. Beim Zeichnen
kennt der Stift drei Modi:
- Normal: der Stift zeichnet
eine Linie in der Stiftfarbe;
- Wechseln: der Stift
zeichnet eine Linie, wobei die Untergrundfarbe in die
Stiftfarbe und die Stiftfarbe in die Untergrundfarbe
geändert wird;
- Radieren: der Stift zeichnet eine Linie
in der Farbe des Untergrunds.
Beispiel 1
import basis.*;
public class Aufgabe2
{
//
Instanzvariablen - ersetzen Sie das folgende Beispiel mit
Ihren Variablen
private Fenster bi;
private Stift st;
public Aufgabe2()
{
// Instanzvariable
initialisieren
bi = new Fenster(500,200);
st = new
Stift();
}
public void fuehreAus()
{
//
tragen Sie hier den Code ein
st.bewegeBis(10,90);
st.schreibeText("Dreieck");
st.bewegeBis(10,70);
st.runter();
st.bewegeBis(40,70);
st.bewegeBis(25,10);
st.bewegeBis(10,70);
st.hoch();
st.bewegeBis(100,120);
st.schreibeText("Fünfeck");
st.bewegeBis(100,100);
st.runter();
st.bewegeUm(50);
st.dreheUm(72);
st.bewegeUm(50);
st.dreheUm(72);
st.bewegeUm(50);
st.dreheUm(72);
st.bewegeUm(50);
st.dreheUm(72);
st.bewegeUm(50);
st.dreheUm(72);
st.hoch();
st.bewegeBis(180,120);
st.schreibeText("Rechteckbreite: ");
st.schreibeZahl(60);
st.bewegeBis(200,80);
st.zeichneRechteck(60,20);
st.bewegeBis(300,110);
st.schreibeText("Kreisradius: ");
st.schreibeZahl(40);
st.bewegeBis(330,50);
st.zeichneKreis(40);
st.bewegeBis(410,105);
st.schreibeText("Stern");
st.bewegeBis(400,70);
st.runter();
st.bewegeUm(50);
st.dreheUm(144);
st.bewegeUm(50);
st.dreheUm(144);
st.bewegeUm(50);
st.dreheUm(144);
st.bewegeUm(50);
st.dreheUm(144);
st.bewegeUm(50);
st.dreheUm(144);
st.hoch();
//
Aufraeumen
//st.gibFrei();
//bi.gibFrei();
}
}
Beispiel 2
Es soll ein Haus gezeichnet werden. xPos und yPos sollen
die Koordinaten der linken oberen Ecke des Hauses
sein. Höhe und Breite sind gleich, dafür soll die Variable
breite genutzt werden. Fenster und Tür sollen jeweils 1/5
der Breite und 2/5 bzw. 1/5 der Höhe einnehmen. Der Abstand
zwischen den Fenstern und der Tür beträgt 1/5 der Breite bzw.
der Höhe.
Der Quelltext dazu lautet:
import basis.*;
public class Aufgabe3
{
//
Instanzvariablen - ersetzen Sie das folgende Beispiel mit
Ihren Variablen
private double breite,xPos, yPos;
private Stift st;
private Fenster bi;
public
Aufgabe3()
{
// Instanzvariable initialisieren
bi = new Fenster(500,300);
st = new Stift();
}
public void zeichneDich()
{
// tragen Sie hier den
Code ein
xPos=100;
yPos=100;
breite=100;
st.rechteck(xPos,yPos,breite,breite);
st.rechteck(xPos+breite/5,yPos+breite/5,breite/5,breite/5);
st.rechteck(xPos+breite/5,yPos+3*breite/5,breite/5,2*breite/5);
st.rechteck(xPos+3*breite/5,yPos+breite/5,breite/5,breite/5);
st.rechteck(xPos+3*breite/5,yPos+3*breite/5,breite/5,breite/5);
st.hoch();
st.bewegeBis(xPos-breite/5,yPos+breite/5);
st.runter();
st.bewegeBis(xPos+breite/2,yPos-breite/2);
st.bewegeBis(xPos+breite+breite/5,yPos+breite/5);
}
}
Prozeduren mit Parametern
Wir ändern das Programm jetzt etwas um:
import basis.*;
public class Aufgabe3
{
//
Instanzvariablen - ersetzen Sie das folgende Beispiel mit
Ihren Variablen
private Stift st;
private Fenster bi;
public Aufgabe3()
{
// Instanzvariable
initialisieren
bi = new Fenster(500,300);
st = new
Stift();
}
public void fuehreAus()
{
zeichneHaus(100,100,100);
}
public void
zeichneHasu(double xPos, double yPos, double breite)
{
st.rechteck(xPos,yPos,breite,breite);
st.rechteck(xPos+breite/5,yPos+breite/5,breite/5,breite/5);
st.rechteck(xPos+breite/5,yPos+3*breite/5,breite/5,2*breite/5);
st.rechteck(xPos+3*breite/5,yPos+breite/5,breite/5,breite/5);
st.rechteck(xPos+3*breite/5,yPos+3*breite/5,breite/5,breite/5);
st.hoch();
st.bewegeBis(xPos-breite/5,yPos+breite/5);
st.runter();
st.bewegeBis(xPos+breite/2,yPos-breite/2);
st.bewegeBis(xPos+breite+breite/5,yPos+breite/5);
}
}
Die Instanzenvariablen xPos, yPos und breite wurden
entfernt. Sie wurden in den Methodenaufruf zeichneHaus
verlagert. Wir haben jetzt eine Methode mit Parametern. Sie
wird in einem anderen programmteil (void fuehreAus)
aufgerufen. In diesem Aufruf werden die gewünschten Werte
auf die Methode übertragen. Worin liegt jetzt der Vorteil?
Dazu fügen wir in die Methode void fuehreAus() mehrmals den
Befehl zeichneHaus() ein. Allerdings verwenden wir
unterschiedliche Parameter.
public void fuehreAus()
{
zeichneHaus(100,100,100);
zeichneHaus(250,120,80);
zeichneHaus(350,150,50);
zeichneHaus(100,100,10);
}
Ein und dieselbe Prozedur erlaubt uns, verschiedene
Größen eines Hauses zu zeichnen ohne jeweils für jedes Haus
eine neue Methode zu deklarieren
