Java/Turtle-Grafik: Unterschied zwischen den Versionen

Aus ZUM-Unterrichten
main>Ugh
(neu)
 
KKeine Bearbeitungszusammenfassung
Markierung: 2017-Quelltext-Bearbeitung
 
(31 dazwischenliegende Versionen von 6 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
Die folgenden Beispiele basieren auf der in [[Java]] geschriebenen [[Turtle-Grafik]]-Engine von A. Hermes, die sich problemlos in [[BlueJ]] einbinden lässt.
{{Fortsetzung|
vorher=Algorithmik<br>Operatoren|vorherlink=Java/Algorithmik|
weiter=if ... else mit PQ-Formel|weiterlink=Java/PQ-Formel|
übersicht=Einstieg in Java<br>(Übersicht)|übersichtlink=Java#Übersicht|}}


Es fehlen zu den Aufgaben einige Beispielbilder, die ich aus Copyrightgründen nicht einfügen kann.
Die folgenden Beispiele basieren auf der in Java geschriebenen [[Turtle-Grafik]]-Engine [http://studsemjuel.nw.lo-net2.de/if/basiskurs/Materialien/Libary.zip (Download)] von Alfred Hermes, die sich in [[BlueJ]] einbinden lässt (Werkzeuge > Einstellungen > Bibliotheken).


==Elementare Methoden==
==Elementare Methoden==
zumStart (x,y) - setzt die Turtle nach (x|y)
[[Bild:TurtleUML.png|right]]
vor (länge) - geht um „länge“-Punkte vorwärts
* zumStart (x,y) - setzt die Turtle nach (x|y)
drehe (winkel) - dreht bei positiven Zahlen rechts, bei negativen links herum.
* vor (länge) - geht um „länge“-Punkte vorwärts
schreibe (text) - schreibt einen String text an die aktuelle Position
* drehe (winkel) - dreht bei positiven Zahlen rechts, bei negativen links herum.
hebeStift() - zeichnet nicht beim Bewegen
* schreibe (text) - schreibt einen String text an die aktuelle Position
senkeStift() - zeichnet beim Bewegen
* hebeStift() - zeichnet nicht beim Bewegen
setzeFarbe(Turtle.rot) - Farben: .schwarz, .grün, .blau, .gelb, .rot, .grau, .hellgrau, .orange, .weiß;
* senkeStift() - zeichnet beim Bewegen
* setzeFarbe(Turtle.rot) - Farben: .schwarz, .grün, .blau, .gelb, .rot, .grau, .hellgrau, .orange, .weiß;


==Erstes Beispiel==
==Erstes Beispiel==
<java>
<source lang="java">
public class Figuren
public class Figuren
{
{
Zeile 44: Zeile 48:
     // ... hier weitere Methoden einfügen
     // ... hier weitere Methoden einfügen
} // Ende der Klasse Figuren
} // Ende der Klasse Figuren
</java>
</source>


{{Übung|
{{Übung|
Zeile 67: Zeile 71:
==Nach Einführung der for-Schleife==
==Nach Einführung der for-Schleife==
===Zweites Beispiel: Ein Zahlenstrahl===
===Zweites Beispiel: Ein Zahlenstrahl===
<java>
<source lang="java">
   public void zeichneZahlenstrahl (int pErsteZahl, int pLetzteZahl) {
   public void zeichneZahlenstrahl (int pErsteZahl, int pLetzteZahl) {
         for (int i=pErsteZahl; i<=pLetzteZahl; i++) {
         for (int i=pErsteZahl; i<=pLetzteZahl; i++) {
Zeile 74: Zeile 78:
         }
         }
     }
     }
</java>
</source>


{{Übung|
{{Übung|
Zeile 85: Zeile 89:


==Eventsteuerung==
==Eventsteuerung==
<java>
<source lang="java">
import java.awt.event.*;
import java.awt.event.*;
public class Figuren extends Turtle
public class Figuren extends Turtle
Zeile 111: Zeile 115:
}
}
     }
     }
</java>
</source>


{{Übung|
{{Übung|
* Überlegen Sie sich Varianten zu diesen Malprogrammen.
* Überlegen Sie sich Varianten zu diesen Malprogrammen.
* Realisieren Sie ein Hindernisrennen. Leider kann die Turtle nur schlecht abfragen, ob ein Hindernis gerammt wurde. Das müssen Sie selbst realisieren.
* Realisieren Sie ein Hindernisrennen. Leider kann die Turtle nur schlecht abfragen, ob ein Hindernis gerammt wurde ({{wpde|Kollisionserkennung (Algorithmische Geometrie)|Kollisionserkennung}}). Das müssen Sie selbst realisieren.
}}
}}


==Threads==
==Threads==
<java>
<source lang="java">
Ergänzen Sie den Konstruktor von Figuren um folgende Zeilen:
Ergänzen Sie den Konstruktor von Figuren um folgende Zeilen:
     (...)
     (...)
Zeile 147: Zeile 151:
     }
     }
} // Ende von TurtleThread
} // Ende von TurtleThread
</java>
</source>


{{Übung|
{{Übung|
* Realisieren Sie ein Hindernisrennspiel, bei dem der Benutzer mit der Linken Maustaste nach links und der rechten nach rechts dreht. Vorwärts geht die Turtle automatisch.
* Realisieren Sie ein Hindernisrennspiel, bei dem der Benutzer mit der linken Maustaste nach links und der rechten nach rechts dreht. Vorwärts geht die Turtle automatisch.
}}
}}


==Perlenkette==
<source lang="java">
public class Perlenkette
{
    // Eigenschaften
    Turtle t;
    // Konstruktor
    public Perlenkette()
    {
      t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
    }
    // Methoden
    public void zeichneLutscher(double pLänge, double pRadius){
        t.vor(pLänge);
        t.setzeFarbe(Turtle.gelb);
        t.fülleKreis(pRadius);
        t.setzeFarbe(Turtle.blau);
    }
   
    public void zeichnePerlenschnur(int pAnzahl)
    {
        t.zumStart(200,20); // Startposition oben mittig
        for (int k=1; k<=pAnzahl; k++) {
            t.drehe(360/(pAnzahl*2));
            zeichneLutscher(30, k*2);     
        }
        for (int k=pAnzahl-1; k>=1; k--) {
            t.drehe(360/(pAnzahl*2));
            zeichneLutscher(30, k*2);
        }
        t.drehe(360/(pAnzahl*2));
        t.vor(30);
    }
} // Ende der Klasse Figuren
</source>
==Rudimentärer Funktionsplotter==
[[Bild:Fktplotterturtle.gif|thumb|Beispielfunktion y=(x*x*x*x-10*x*x+12);]]
Es folgt der Quelltext eines einfachen Funktionsplotters. <br>
Schade ist, dass Java keinen "eval" Befehl kennt, wie er z.B. in [[JavaScript]] vorliegt. Daher muss man hier die Funktion, die angezeigt werden soll, direkt im Quelltext angeben (es sei denn, man fügt einen Mathe-Parser hinzu). 
<source lang="java">
// Ein rudimentärer Funktionsplotter
public class Figuren
{
// Eigenschaften
Turtle t;
// Konstruktor
public Figuren()
{
    double x,y;
    t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
    t.setzeFarbe(Turtle.blau); // legt Farbe fest
    t.zeige();
}
public void zeichneKoordinatensystem(){
    double pLaenge=15;
    t.setzeFarbe(Turtle.blau);
    setzeTurtleInDieMitte();
    t.vor(-10*pLaenge);
    zeichneStrahl(-10,10,pLaenge);
    t.vor(10*pLaenge);
    t.drehe(-90);
    t.vor(-10*pLaenge);
    zeichneStrahl(-10,10,pLaenge);
    t.drehe(90);
    setzeTurtleInDieMitte();   
}
public void zeichneFunktion(){
    t.setzeFarbe(Turtle.rot);
    double pLaenge=15;
    double y;
    boolean w=false;
    for (double x=-10;x<=10;x=x+0.1){
        y=(x*x-3);
        if (!w) {
            t.zumStart(x*pLaenge+t.liesMaxX()/2,-y*pLaenge+t.liesMaxX()/2);
            w=true;
        }
        else {
        t.geheNach(x*pLaenge+t.liesMaxX()/2,-y*pLaenge+t.liesMaxX()/2);
        }
    }
}
public void setzeTurtleInDieMitte(){
    double x,y;
    x = t.liesMaxX(); y = t.liesMaxX(); // Maximale x-und y-Werte
    t.zumStart(x/2,y/2); // Setzt die Anfangsposition auf die Mitte
}
private void zeichneStrahl(int pSkalenMin, int pSkalenMax, double pLaenge){
    t.schreibe(""+pSkalenMin);
    for (int i=pSkalenMin+1; i<=pSkalenMax; i++){
        t.vor(pLaenge);
        t.schreibe(""+i);
    }
    t.vor(pLaenge);
    zeichnePfeil(20);
    t.vor(-pLaenge*(pSkalenMax-pSkalenMin+1));
}
private void zeichnePfeil(double pLaenge){
    t.drehe(-90);
    t.vor(pLaenge/2);
    t.drehe(120);
    t.vor(pLaenge);
    t.drehe(120);
    t.vor(pLaenge);
    t.drehe(120);
    t.vor(pLaenge/2);
    t.drehe(90);
}
} // Ende der Klasse Figuren
</source>
==Verfolgende Schildkröten==
Eine Turtle verfolgt eine andere auf kürzestem Weg.
<source lang="java">
public class Zufallsturtle
{
// Eigenschaften
private Turtle t,q;
private int qx, qy;
// Konstruktor
    public Zufallsturtle()
    {
        t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
        t.zeige();
        t.setzeFarbe(4);
        q=new Turtle(); // legt eine neue Turtle mit den Namen "q" an.
        q.zeige(); // zufällige Startposition       
    }
// Methoden
    public void starte(){
        boolean ende=false;
       
        qy=gibZufallszahl(400);
        qy=gibZufallszahl(400);
        q.zumStart(qx,qy);
       
        while (!ende) {
            laufeZufaellig(2, 2, 50);
            verfolge(1);
            if (qx==(int) t.liesX()){
                if (qy==(int) t.liesY()){
                    ende=true;
                }
            }
           
        }
        t.schreibe("Gefangen");
    }


==Weblink==
* [http://www.zitadelle.juel.nw.schule.de/if/java/tgrafik/Turtle.html Turtlegrafiklibrary Quelle] - turtle.jar lässt sich in [[BlueJ]] einbinden.


==Siehe auch==
    public void laufeZufaellig(int pSchrittweite, int pSchrittzahl, int pPause)
    {
      int zufallszahl;
      for (int k=1;k<=pSchrittzahl;k++) {
          zufallszahl=gibZufallszahl(3);
          if (zufallszahl==1) {
              t.vor(pSchrittweite);
            }
            else {
                if (zufallszahl==2) {
                    t.drehe(10);
                }
                else {
                    t.drehe(-5);
                }
            }
            t.ruhe(pPause);
      }
    }
   
    public void verfolge(int pSchrittweite)
    {
        int tx = (int) t.liesX();
        int ty = (int) t.liesY();
        if (qx<tx) {
            qx+=pSchrittweite;
        }
        else {
            qx-=pSchrittweite;
        }
        if (qy<ty) {
            qy+=pSchrittweite;
        }
        else {
            qy-=pSchrittweite;
        }
        q.zumStart(qx,qy);
    }
   
    // gibt eine Zufallszahl zwischen 1 und pMaximum zurück
    public int gibZufallszahl(int pMaximum) {
        return  (int) ((Math.random()*pMaximum)+1);
    }
} // Ende von Zufallsturtle
 
 
</source>
 
== Uhr ==
[[Bild:ScreenshotUhr.gif|thumb|Screenshot]]
{{Box|Hinweis|
Leider verschwinden nicht alle schwarzen Striche. Ich nehme an, das sind Rechenungenauigkeiten (Rundungsfehler) der Turtlemethode.
; Benötigt:
* if, for, Turtlegrafik, int, double
* BlueJ, daher keine main-Mathode
|Hervorhebung}}
 
 
<source lang="java">
public class Uhr
{
    private int minute;
    private int stunde;
    private Turtle t;
   
    public Uhr(int pStunde, int pMinute)
    {
        if (stunde==0) {
            stunde=12;
        }
        minute=pMinute;
        stunde=pStunde;
        t=new Turtle();
        t.drehe(-90);
        t.zeige();
    }
 
    public void laufe15Sekunden(){
        for (int k=1;k<=15;k++){
            zeichneUhr(100,8);
            stelleWeiter();
            zeichneUhr(100,0);
            t.ruhe(1000);
        }       
    }
   
    public void stelleWeiter()
    {
        minute++;
        if (minute>59) {
            minute=0;
            stunde++;
            if (stunde>12) {
                stunde=1;
            }
        }
    }
   
    public void zeichneUhr(double pZeigerlaenge, int pFarbe){
        t.setzeFarbe(pFarbe);
        t.drehe(minute*360/60);
        t.vor(pZeigerlaenge);
        t.vor(-pZeigerlaenge);
        t.drehe(-minute*360/60);
        t.drehe(stunde*360/12);
        t.vor(pZeigerlaenge*0.8);
        t.vor(-pZeigerlaenge*0.8);
        t.drehe(-stunde*360/12);       
    }
   
    public int gibVergangeneMinutenSeitMitternacht() {
        int zwischenspeicher;
        zwischenspeicher = minute + stunde * 60;
        return zwischenspeicher;
    }
}
</source>
 
{{Übung|
Analysieren Sie die Klasse Uhr.
# Klären Sie am Beispiel der Uhr folgende Begriffe:
#*Klasse, Methode, Datentyp, Parameter, Schleife (for), Bedingte Ausführung (if)
# Zeichnen Sie das Klassendiagramm zur Klasse Uhr.
# Implementieren Sie die Methode <code>stelleUhr(int pStunde, int pMinute)</code>, die die Uhrzeit auf die angegebenen Parameter verstellt. Das soll aber nur dann geschehen, wenn eine gültige Uhrzeit übergeben wurde (Stunden bis max. 12 und Minuten bis 59). Falls als Stunde 0 angegeben wurde, soll der Wert auf 12 gestellt werden.
# Implementieren Sie die Methode <code>stelleUmXMinutenVor(int x)</code>, die die Uhrzeit um x-Minuten verstellt. (Hinweis: es gibt zumindest 2 völlig verschiedene Lösungswege!)
# Ergänzen Sie die Uhr um eine Datumsangabe mit Tag und Monat. Implementieren Sie dazu auch <code>stelleDatumWeiter()</code>, die das Datum um einen Tag vorstellt. (Zur Vereinfachung vernachlässigen wir die Schaltjahre).
# Zusatzaufgabe: Ergänzen Sie eine Alarmfunktion.
# Zusatzaufgabe (Übungen zur Turtlegrafik):
#*Lassen Sie ein Ziffernblatt zeichnen.
#*Wahrscheinlich werden Sie die folgenden Befehle benötigen:
#* <code>fuelleKreis(double radius)</code>
#* <code>schreibe(String text)</code>
}}
 
 
[[Kategorie:Unterrichtsidee]]
[[Kategorie:Informatik]]
 
 
{{Fortsetzung|
vorher=Algorithmik<br>Operatoren|vorherlink=Java/Algorithmik|
weiter=if ... else mit PQ-Formel|weiterlink=Java/PQ-Formel|
übersicht=Einstieg in Java<br>(Übersicht)|übersichtlink=Java#Übersicht|}}
 
== Weblinks ==
;Andere Turtlelibraries:
* [http://www.oberstufeninformatik.de/info11/turtle/turtle.html Einstieg in Java mit Turtle.java] Hier wird eine Unterrichtssequenz zur Graphikprogrammierung mit einer Turtle in Java dokumentiert.
 
 
== Siehe auch ==
* [[Turtle-Grafik]]
* [[Turtle-Grafik]]
* [[Java]]


==Weblinks==
[[Kategorie:Java]]
* [http://www.zitadelle.juel.nw.schule.de/if/java/tgrafik/Turtle.html Algorithmik mit der Turtlegrafik]
[[Kategorie:Unterrichtsidee]]
 
[[Kategorie:Informatik]]
[[Kategorie:Informatik]]

Aktuelle Version vom 8. Januar 2020, 19:41 Uhr

Die folgenden Beispiele basieren auf der in Java geschriebenen Turtle-Grafik-Engine (Download) von Alfred Hermes, die sich in BlueJ einbinden lässt (Werkzeuge > Einstellungen > Bibliotheken).

Elementare Methoden

TurtleUML.png
  • zumStart (x,y) - setzt die Turtle nach (x|y)
  • vor (länge) - geht um „länge“-Punkte vorwärts
  • drehe (winkel) - dreht bei positiven Zahlen rechts, bei negativen links herum.
  • schreibe (text) - schreibt einen String text an die aktuelle Position
  • hebeStift() - zeichnet nicht beim Bewegen
  • senkeStift() - zeichnet beim Bewegen
  • setzeFarbe(Turtle.rot) - Farben: .schwarz, .grün, .blau, .gelb, .rot, .grau, .hellgrau, .orange, .weiß;

Erstes Beispiel

public class Figuren
{
    // Eigenschaften
    Turtle t;

    // Konstruktor
    public Figuren() 
    {
       double x,y;
       t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
       x = t.liesMaxX(); y = t.liesMaxX(); // Maximale x-und y-Werte
       t.zumStart(x/2,y/2); // Setzt die Anfangsposition auf die Mitte 
       t.setzeFarbe(Turtle.blau); // legt Farbe fest 
    }

    // Methoden
    public void zeichneQuadrat(int pLänge){
        zeichneRechtenWinkel(pLänge); 
        zeichneRechtenWinkel(pLänge);   
    }
    
    public void zeichneRechtenWinkel(int pLänge) 
    { 
        t.vor(pLänge);
        t.drehe(90);
        t.vor(pLänge);
        t.drehe(90);
    }
    // ... hier weitere Methoden einfügen
} // Ende der Klasse Figuren


Übung
  • Tippen Sie die Klasse Figuren ab.
  • Ergänzen Sie die Klasse Figuren um folgende Methoden:
    • zeichneGrößerwerdendeQuadrate(...)
    • zeichneRechteck(int pLänge, int pBreite)
    • zeichneSchweizerFahne( )
    • zeichneGleichseitigesDreieck(int pLänge)
    • zeichne5Eck(int pLänge)
    • zeichneStern (...)
    • zeichneMittelquadrat(...)
    • zeichneFünfeck(...)
  • Zeichnen Sie das Haus vom Nikolaus. Denken Sie daran, dass Sie für die Berechnung der Länge der Diagonalen und des Dachs den Satz den Pythagoras benutzen können. Hinweis: Befehl für Wurzel aus x: Math.sqrt(x)
  • Lassen Sie eine Uhr mit Zeigern zeichnen: zeichneUhr(int Stunden, int Minuten)
  • Überprüfen Sie vor der Zeichnung, ob die Werte zulässig sind (Stunden 0-23, Minuten 0-59).
  • Profis: Schauen Sie sich das Klassendiagramm der Klasse TestTurtle an . Es enthält alle Methoden, die benutzt werden können. Probieren Sie Methoden aus, die Ihnen praktisch vorkommen.


Nach Einführung der for-Schleife

Zweites Beispiel: Ein Zahlenstrahl

   public void zeichneZahlenstrahl (int pErsteZahl, int pLetzteZahl) {
        for (int i=pErsteZahl; i<=pLetzteZahl; i++) {
            t.vor(20);
            t.schreibe(""+i); // Trick! Einfache Typumwandlung zu String
        }
    }


Übung
  • Analysieren Sie die Methode zum n-Eck.
  • Wie kann ich einen Kreis zeichnen?
  • Lassen Sie eine „Perlenschnur“ zeichnen. Hinweis: t.fülleKreis(double radius)
  • Lassen Sie ein „Standardkoordinatensystem“ zeichnen, das auf beiden Achsen von -5 bis 5 geht. Vergessen Sie die Achsenbeschriftung (x und y) und die Pfeilspitzen nicht.
  • Lassen Sie mit Hilfe einer Schleife Muster wie die folgenden erstellen. Klären Sie dazu auch die Frage, wie man größer werdende Quadrate zeichnen lassen kann (siehe Quadratschnecke).


Eventsteuerung

import java.awt.event.*;
public class Figuren extends Turtle
{
(...)
    public void mouseClicked(java.awt.event.MouseEvent me){
        if (me.isMetaDown()) { t.drehe(10); } // Rechte Maustaste?
        else {
            if (me.getClickCount()==2) { // Doppelklick?
               t.drehe(180); // Falls Doppelklick
            }
            else {
               t.vor(10); // Falls einfacher Mausklick
            }
        }        
    }

// Alternativ: 
    public void mouseClicked(java.awt.event.MouseEvent me){
       	if (me.isMetaDown()) { // rechte Maustaste gedrückt?
		t.drehe(10);
	}
        	else {
		t.vor(10);
	}
    }


Übung
  • Überlegen Sie sich Varianten zu diesen Malprogrammen.
  • Realisieren Sie ein Hindernisrennen. Leider kann die Turtle nur schlecht abfragen, ob ein Hindernis gerammt wurde (KollisionserkennungWikipedia-logo.png). Das müssen Sie selbst realisieren.


Threads

Ergänzen Sie den Konstruktor von Figuren um folgende Zeilen:
    (...)
       t.zeige();// ab hier neu:
       TurtleThread turtleThread;
       turtleThread = new TurtleThread(t);
       turtleThread.start();
    }
Legen Sie eine neue Klasse TurtleThread an

public class TurtleThread extends Thread
{
Turtle t;

    public TurtleThread(Turtle pT)
    {
        t = pT;
    }
    public void run() {
      for(int i = 0; i < 30; i++) {
        try {
          t.vor(10);  
          sleep(1000);
        }
        catch(InterruptedException e) {        }
      }
    }
} // Ende von TurtleThread


Übung
  • Realisieren Sie ein Hindernisrennspiel, bei dem der Benutzer mit der linken Maustaste nach links und der rechten nach rechts dreht. Vorwärts geht die Turtle automatisch.


Perlenkette

public class Perlenkette
{
    // Eigenschaften
    Turtle t;
 
    // Konstruktor
    public Perlenkette() 
    {
       t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
    }
 
    // Methoden
    public void zeichneLutscher(double pLänge, double pRadius){
        t.vor(pLänge);
        t.setzeFarbe(Turtle.gelb);
        t.fülleKreis(pRadius);
        t.setzeFarbe(Turtle.blau);
    }
    
    public void zeichnePerlenschnur(int pAnzahl) 
    { 
        t.zumStart(200,20); // Startposition oben mittig
        for (int k=1; k<=pAnzahl; k++) {
            t.drehe(360/(pAnzahl*2));
            zeichneLutscher(30, k*2);       
        }
        for (int k=pAnzahl-1; k>=1; k--) {
            t.drehe(360/(pAnzahl*2));
            zeichneLutscher(30, k*2);
        }
        t.drehe(360/(pAnzahl*2));
        t.vor(30);
    }

} // Ende der Klasse Figuren

Rudimentärer Funktionsplotter

Beispielfunktion y=(x*x*x*x-10*x*x+12);

Es folgt der Quelltext eines einfachen Funktionsplotters.
Schade ist, dass Java keinen "eval" Befehl kennt, wie er z.B. in JavaScript vorliegt. Daher muss man hier die Funktion, die angezeigt werden soll, direkt im Quelltext angeben (es sei denn, man fügt einen Mathe-Parser hinzu).

// Ein rudimentärer Funktionsplotter

public class Figuren
{
// Eigenschaften
Turtle t;

// Konstruktor

public Figuren()
{
    double x,y;
    t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
    t.setzeFarbe(Turtle.blau); // legt Farbe fest
    t.zeige();
}

public void zeichneKoordinatensystem(){
    double pLaenge=15;
    t.setzeFarbe(Turtle.blau);
    setzeTurtleInDieMitte();
    t.vor(-10*pLaenge);
    zeichneStrahl(-10,10,pLaenge);
    t.vor(10*pLaenge);
    t.drehe(-90);
    t.vor(-10*pLaenge);
    zeichneStrahl(-10,10,pLaenge);
    t.drehe(90);
    setzeTurtleInDieMitte();    
}

public void zeichneFunktion(){
    t.setzeFarbe(Turtle.rot);
    double pLaenge=15;
    double y;
    boolean w=false;
    for (double x=-10;x<=10;x=x+0.1){
        y=(x*x-3);
        if (!w) {
            t.zumStart(x*pLaenge+t.liesMaxX()/2,-y*pLaenge+t.liesMaxX()/2);
            w=true;
        }
        else {
        t.geheNach(x*pLaenge+t.liesMaxX()/2,-y*pLaenge+t.liesMaxX()/2);
        }
    }
}

public void setzeTurtleInDieMitte(){
    double x,y;
    x = t.liesMaxX(); y = t.liesMaxX(); // Maximale x-und y-Werte
    t.zumStart(x/2,y/2); // Setzt die Anfangsposition auf die Mitte
}

private void zeichneStrahl(int pSkalenMin, int pSkalenMax, double pLaenge){
    t.schreibe(""+pSkalenMin);
    for (int i=pSkalenMin+1; i<=pSkalenMax; i++){
        t.vor(pLaenge);
        t.schreibe(""+i); 
    }
    t.vor(pLaenge);
    zeichnePfeil(20);
    t.vor(-pLaenge*(pSkalenMax-pSkalenMin+1));
}

private void zeichnePfeil(double pLaenge){
    t.drehe(-90);
    t.vor(pLaenge/2);
    t.drehe(120);
    t.vor(pLaenge);
    t.drehe(120);
    t.vor(pLaenge);
    t.drehe(120);
    t.vor(pLaenge/2);
    t.drehe(90);
}

} // Ende der Klasse Figuren

Verfolgende Schildkröten

Eine Turtle verfolgt eine andere auf kürzestem Weg.

public class Zufallsturtle
{
// Eigenschaften
private Turtle t,q;
private int qx, qy;

// Konstruktor
    public Zufallsturtle()
    {
        t=new Turtle(); // legt eine neue Turtle mit den Namen "t" an.
        t.zeige();
        t.setzeFarbe(4);
        q=new Turtle(); // legt eine neue Turtle mit den Namen "q" an.
        q.zeige(); // zufällige Startposition        
    }

// Methoden
    public void starte(){ 
        boolean ende=false;
        
        qy=gibZufallszahl(400);
        qy=gibZufallszahl(400);
        q.zumStart(qx,qy);
        
        while (!ende) {
            laufeZufaellig(2, 2, 50);
            verfolge(1);
            if (qx==(int) t.liesX()){
                if (qy==(int) t.liesY()){
                    ende=true;
                }
            }
            
        }
        t.schreibe("Gefangen");
    }


    public void laufeZufaellig(int pSchrittweite, int pSchrittzahl, int pPause)
    {
       int zufallszahl;
       for (int k=1;k<=pSchrittzahl;k++) {
           zufallszahl=gibZufallszahl(3);
           if (zufallszahl==1) {
               t.vor(pSchrittweite);
            }
            else {
                if (zufallszahl==2) {
                    t.drehe(10);
                }
                else {
                    t.drehe(-5);
                }
            }
            t.ruhe(pPause);
       }
    }
    
    public void verfolge(int pSchrittweite)
    {
        int tx = (int) t.liesX();
        int ty = (int) t.liesY();
        if (qx<tx) {
            qx+=pSchrittweite;
        }
        else {
            qx-=pSchrittweite;
        }
        if (qy<ty) {
            qy+=pSchrittweite;
        }
        else {
            qy-=pSchrittweite;
        }
        q.zumStart(qx,qy);
    }
    
    // gibt eine Zufallszahl zwischen 1 und pMaximum zurück
    public int gibZufallszahl(int pMaximum) {
        return  (int) ((Math.random()*pMaximum)+1);
    }
} // Ende von Zufallsturtle

Uhr

Screenshot
Hinweis

Leider verschwinden nicht alle schwarzen Striche. Ich nehme an, das sind Rechenungenauigkeiten (Rundungsfehler) der Turtlemethode.

Benötigt
  • if, for, Turtlegrafik, int, double
  • BlueJ, daher keine main-Mathode


public class Uhr
{
    private int minute;
    private int stunde;
    private Turtle t;
    
    public Uhr(int pStunde, int pMinute)
    {
        if (stunde==0) {
            stunde=12;
        }
        minute=pMinute;
        stunde=pStunde;
        t=new Turtle();
        t.drehe(-90);
        t.zeige();
    }

    public void laufe15Sekunden(){
        for (int k=1;k<=15;k++){
            zeichneUhr(100,8);
            stelleWeiter();
            zeichneUhr(100,0);
            t.ruhe(1000);
        }        
    }
    
    public void stelleWeiter()
    {
        minute++;
        if (minute>59) {
            minute=0; 
            stunde++;
            if (stunde>12) {
                stunde=1;
            }
        }
    }
    
    public void zeichneUhr(double pZeigerlaenge, int pFarbe){
        t.setzeFarbe(pFarbe);
        t.drehe(minute*360/60);
        t.vor(pZeigerlaenge);
        t.vor(-pZeigerlaenge);
        t.drehe(-minute*360/60);
        t.drehe(stunde*360/12);
        t.vor(pZeigerlaenge*0.8);
        t.vor(-pZeigerlaenge*0.8);
        t.drehe(-stunde*360/12);        
    }
    
    public int gibVergangeneMinutenSeitMitternacht() {
        int zwischenspeicher;
        zwischenspeicher = minute + stunde * 60;
        return zwischenspeicher;
    }
}


Übung

Analysieren Sie die Klasse Uhr.

  1. Klären Sie am Beispiel der Uhr folgende Begriffe:
    • Klasse, Methode, Datentyp, Parameter, Schleife (for), Bedingte Ausführung (if)
  2. Zeichnen Sie das Klassendiagramm zur Klasse Uhr.
  3. Implementieren Sie die Methode stelleUhr(int pStunde, int pMinute), die die Uhrzeit auf die angegebenen Parameter verstellt. Das soll aber nur dann geschehen, wenn eine gültige Uhrzeit übergeben wurde (Stunden bis max. 12 und Minuten bis 59). Falls als Stunde 0 angegeben wurde, soll der Wert auf 12 gestellt werden.
  4. Implementieren Sie die Methode stelleUmXMinutenVor(int x), die die Uhrzeit um x-Minuten verstellt. (Hinweis: es gibt zumindest 2 völlig verschiedene Lösungswege!)
  5. Ergänzen Sie die Uhr um eine Datumsangabe mit Tag und Monat. Implementieren Sie dazu auch stelleDatumWeiter(), die das Datum um einen Tag vorstellt. (Zur Vereinfachung vernachlässigen wir die Schaltjahre).
  6. Zusatzaufgabe: Ergänzen Sie eine Alarmfunktion.
  7. Zusatzaufgabe (Übungen zur Turtlegrafik):
    • Lassen Sie ein Ziffernblatt zeichnen.
    • Wahrscheinlich werden Sie die folgenden Befehle benötigen:
    • fuelleKreis(double radius)
    • schreibe(String text)


Weblinks

Andere Turtlelibraries


Siehe auch