Programmiertechnik: Unterschied zwischen den Versionen
(16 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
Zeile 2: | Zeile 2: | ||
[[Kategorie:Informatik-EF]] | [[Kategorie:Informatik-EF]] | ||
Auf dieser Seite werden anhand von Kara grundlegende Programmiertechniken vorgestellt. | Auf dieser Seite werden anhand von Kara '''grundlegende Programmiertechniken''' vorgestellt. | ||
Die Grundlagen der '''Java-Syntax''' werden auf folgender Seite vorgestellt: '''[[Java_Basis-Sprachelemente]]''' | |||
=Methoden, die n-mal etwas tun= | =Methoden, die n-mal etwas tun= | ||
Zeile 16: | Zeile 18: | ||
|- | |- | ||
| | | | ||
{|style="border-style: solid; border-width: 0px;" | |||
| Methode zwanzigerLinieLegen() | |||
{|style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| Wiederhole 20-mal | |||
{|style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| lege ein Blatt<br/>gehe einen Schritt | |||
|} | |||
|} | |||
|} | |||
|| | || | ||
public void zwanzigerLinieLegen() | public void zwanzigerLinieLegen() | ||
Zeile 40: | Zeile 43: | ||
In der Regel haben diese Methoden folgenden Aufbau: | In der Regel haben diese Methoden folgenden Aufbau: | ||
* Eine Schleife, die so lange läuft, bis das "Ziel" erreicht ist<br>In der Schleife passiert folgendes: | * Eine Schleife, die so lange läuft, bis das "Ziel" erreicht ist<br>In der Schleife passiert folgendes: | ||
** Es wird "nachgedacht" | ** Es wird "nachgedacht". (Das kann kompliziert sein...) | ||
** '''Nach''' dem Nachdenken: | ** '''Nach''' dem Nachdenken: Ein Schritt in Richtung Ziel wird ausgeführt | ||
'''Wichtig''' ist dabei, dass '''in jedem Schleifendurchlauf genau ein Schritt''' ausgeführt wird, und das erst nach dem "Nachdenken"! | '''Wichtig''' ist dabei, dass '''in jedem Schleifendurchlauf genau ein Schritt''' ausgeführt wird, und das erst '''nach''' dem "Nachdenken"! | ||
Dadurch wird die Programmierung viel einfacher! | Dadurch wird die Programmierung viel einfacher! | ||
Zeile 59: | Zeile 62: | ||
|- | |- | ||
| | | | ||
'''Methode rundUmDenWald()''' | {| style="border-style: solid; border-width: 0px;" | ||
| '''Methode rundUmDenWald()''' | |||
{| style="border-style: solid; border-width: 3px 0px 3px 3px; margin: 5px" | |||
| Solange Kara nicht auf einem Blatt steht | |||
{| style="border-style: solid; border-width: 2px 0px 2px 2px; margin: 5px" | |||
| '''''(Nachdenken!)'''''<br>wenn kein Baum rechts ist | |||
{| style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| drehe dich nach rechts | |||
|} sonst | |||
{| style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| solange ein Baum vorne ist | |||
{| style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| drehe dich nach links | |||
|} | |||
|} <br/>'''''(Schritt ausführen!)'''''<br/>gehe einen Schritt | |||
|} | |||
|} | |||
|} | |||
|| | |||
|| | |||
public void rundUmDenWald() | public void rundUmDenWald() | ||
{ | { | ||
Zeile 96: | Zeile 92: | ||
else | else | ||
{ | { | ||
while(kara.treeFront()) | |||
{ | { | ||
kara.turnLeft(); | kara.turnLeft(); | ||
} | } | ||
} | } | ||
// '''''(Schritt ausführen!)''''' | // '''''(Schritt ausführen!)''''' | ||
kara.move(); | kara.move(); | ||
Zeile 118: | Zeile 110: | ||
** Die Berechnung wird aktualisiert | ** Die Berechnung wird aktualisiert | ||
** Es wird zum nächsten Schritt weitergegangen. | ** Es wird zum nächsten Schritt weitergegangen. | ||
* Wenn die Schleife fertig ist, dann wird <code>ergebnis</code> zurückgegeben. | * Wenn die Schleife fertig ist, dann wird mit dem Schlüsselwort <code>return</code> das <code>ergebnis</code> zurückgegeben. | ||
==Beispiel== | ==Beispiel== | ||
Zeile 131: | Zeile 123: | ||
|- | |- | ||
| | | | ||
'''Methode zaehleBlaetter()''': ''gibt eine Zahl zurück'' | {|style="border-style: solid; border-width: 0px;" | ||
| '''Methode zaehleBlaetter()''': ''gibt eine Zahl zurück'' | |||
{|style="border-style: solid; border-width: 2px 0px 2px 2px; margin: 5px" | |||
| Setze ergebnis auf 0<br/>Solange Kara auf einem Blatt steht | |||
{|style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| erhöhe ergebnis um 1<br/>gehe einen Schritt | |||
|} gib ergebnis zurück; | |||
|} | |||
|} | |||
|| | || | ||
public int zaehleBlaetter() | public int zaehleBlaetter() | ||
Zeile 153: | Zeile 144: | ||
} | } | ||
|} | |} | ||
==Aufruf der Methode== | |||
Die Methode <code>zaehleBlaetter()</code> kann z.B. so verwendet werden: | |||
<code> | |||
'''int anzahl = zaehleBlaetter();''' | |||
kara.turnLeft(); | |||
kara.move(); | |||
kara.turnLeft(); | |||
kara.move(); | |||
linieLegen(anzahl); | |||
</code> | |||
'''Erklärung:''' | |||
Die Methode <code>zaehleBlaetter()</code> gibt eine Zahl zurück. <br/> | |||
Diese Zahl wird in der lokalen Variable <code>anzahl</code> gespeichert.<br/> | |||
Dann kann <code>anzahl</code> verwendet werden. | |||
Im Beispiel zählt Kara die Blätter. <br/>Dann wendet sie und legt eine Zeile darunter genau so viele Blätter ab, wie sie gezählt hat. | |||
=Zerlegung in mehrere Methoden= | =Zerlegung in mehrere Methoden= | ||
Zeile 175: | Zeile 185: | ||
Man sieht, dass Kara immer abwechselnd bergauf und bergab gehen muss! | Man sieht, dass Kara immer abwechselnd bergauf und bergab gehen muss! | ||
Daher bietet es sich an, das Gesamtproblem mithilfe der folgenden zwei Methoden zu programmieren: | Daher bietet es sich an, das Gesamtproblem mithilfe der folgenden zwei Methoden zu programmieren: | ||
* <code> | * <code>zumGipfel()</code> | ||
* <code>insTal()</code> | * <code>insTal()</code> | ||
Zeile 185: | Zeile 195: | ||
|- | |- | ||
| | | | ||
{|style="border-style: solid; border-width: 0px;" | |||
| '''Methode sucheKleeblatt()''' | |||
{|style="border-style: solid; border-width: 2px 0px 2px 2px; margin: 5px" | |||
| Solange Kara '''nicht''' auf einem Blatt steht | |||
{|style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| zumGipfel()<br/>insTal() | |||
|} | |||
|} | |||
|} | |||
|} | |} | ||
Zeile 199: | Zeile 209: | ||
''Für die Teilprobleme wird hier nur die Programmierung angegeben.'' | ''Für die Teilprobleme wird hier nur die Programmierung angegeben.'' | ||
<code> | <code> | ||
'''public void zumGipfel()''' | '''public void zumGipfel()''' | ||
{ | { | ||
Zeile 211: | Zeile 221: | ||
} | } | ||
} | } | ||
'''public void insTal()''' | '''public void insTal()''' | ||
{ | { | ||
Zeile 226: | Zeile 233: | ||
} | } | ||
} | } | ||
</code> | </code> | ||
===Programmierung der Hauptmethode=== | ===Programmierung der Hauptmethode=== | ||
Zeile 239: | Zeile 245: | ||
|- | |- | ||
| | | | ||
{|style="border-style: solid; border-width: 0px;" | |||
| '''Methode sucheKleeblatt()''' | |||
{|style="border-style: solid; border-width: 2px 0px 2px 2px; margin: 5px" | |||
| Solange Kara '''nicht''' auf einem Blatt steht | |||
{|style="border-style: solid; border-width: 1px 0px 1px 1px; margin: 5px" | |||
| zumGipfel()<br/>insTal() | |||
|} | |||
|} | |||
|} | |||
| | | | ||
'''public void sucheKleeblatt()''' | '''public void sucheKleeblatt()''' | ||
Zeile 258: | Zeile 264: | ||
} | } | ||
|} | |} | ||
==Beispiel 2: Wintervorrat== | ==Beispiel 2: Wintervorrat== | ||
Zeile 283: | Zeile 288: | ||
|- | |- | ||
| | | | ||
{|style="border-style: solid; border-width: 0px;" | |||
| '''Methode wintervorratAnlegen()''' | |||
{|style="border-style: solid; border-width: 2px 0px 2px 2px; margin: 5px" | |||
| ''Es wird die Variable blaetterZahl gebraucht!''<br/>blaetterZahl = blaetterSammeln()<br/>nach rechts drehen<br/>bisZumBaumGehen()<br/>zweimal nach rechts drehen<br/>blaetterLegen(blaetterZahl) | |||
|} | |||
|} | |||
|} | |} | ||
Zeile 298: | Zeile 299: | ||
''Für die Teilprobleme wird hier nur die Programmierung angegeben.'' | ''Für die Teilprobleme wird hier nur die Programmierung angegeben.'' | ||
<code> | <code> | ||
'''public int blaetterSammeln()''' | '''public int blaetterSammeln()''' | ||
{ | { | ||
Zeile 316: | Zeile 317: | ||
return ergebnis; | return ergebnis; | ||
} | } | ||
</code> | </code> | ||
<code> | <code> | ||
'''public void bisZumBaumGehen()''' | '''public void bisZumBaumGehen()''' | ||
{ | { | ||
Zeile 326: | Zeile 327: | ||
} | } | ||
} | } | ||
</code> | </code> | ||
<code> | <code> | ||
'''public void blaetterLegen(int anzahl)''' | '''public void blaetterLegen(int anzahl)''' | ||
{ | { | ||
Zeile 337: | Zeile 338: | ||
} | } | ||
} | } | ||
</code> | </code> | ||
===Programmierung der Hauptmethode=== | ===Programmierung der Hauptmethode=== | ||
Zeile 349: | Zeile 350: | ||
|- | |- | ||
| | | | ||
{|style="border-style: solid; border-width: 0px;" | |||
| '''Methode wintervorratAnlegen()''' | |||
{|style="border-style: solid; border-width: 2px 0px 2px 2px; margin: 5px" | |||
| ''Es wird die Variable blaetterZahl gebraucht!''<br/>blaetterZahl = blaetterSammeln()<br/>nach rechts drehen<br/>bisZumBaumGehen()<br/>zweimal nach rechts drehen<br/>blaetterLegen(blaetterZahl) | |||
|} | |||
|} | |||
| | | | ||
'''public void wintervorratAnlegen()''' | '''public void wintervorratAnlegen()''' |
Aktuelle Version vom 27. Oktober 2024, 14:00 Uhr
Auf dieser Seite werden anhand von Kara grundlegende Programmiertechniken vorgestellt.
Die Grundlagen der Java-Syntax werden auf folgender Seite vorgestellt: Java_Basis-Sprachelemente
Methoden, die n-mal etwas tun
Mit n-mal ist gemeint, dass bekannt ist, wie oft die Wiederholung ausgeführt werden soll.
Dafür braucht man eine Wiederhole n-mal-Schleife. In Java kann man das mit for
realisieren.
Beispiel
Kara soll eine Linie von 20 Kleeblättern legen.
Programmbeschreibung | Java Quelltext | |||
---|---|---|---|---|
|
public void zwanzigerLinieLegen() { for(int i=0; i<20; i++) { kara.putLeaf(); kara.move(); } } |
Methoden, die etwas tun, bis ein Ziel erreicht wird
Solche Methoden brauchen eine Solange-Schleife. In Java kann man das mit while
realisieren.
In der Regel haben diese Methoden folgenden Aufbau:
- Eine Schleife, die so lange läuft, bis das "Ziel" erreicht ist
In der Schleife passiert folgendes:- Es wird "nachgedacht". (Das kann kompliziert sein...)
- Nach dem Nachdenken: Ein Schritt in Richtung Ziel wird ausgeführt
Wichtig ist dabei, dass in jedem Schleifendurchlauf genau ein Schritt ausgeführt wird, und das erst nach dem "Nachdenken"!
Dadurch wird die Programmierung viel einfacher!
Beispiel
Die folgende Methode lässt Kara rund um einen Wald gehen, bis sie auf einem Blatt steht.
Das "Nachdenken" ist hier relativ kompliziert:
Die größte Schwierigkeit ist für Kara, wenn sie in die "Sackgasse" auf der rechten Seite geht.
Dort muss sie 2x prüfen, ob sie vor einem Baum steht!
Programmbeschreibung | Java Quelltext | ||||||
---|---|---|---|---|---|---|---|
|
public void rundUmDenWald() { while(!kara.onLeaf()) { // (Nachdenken!) if(!kara.treeRight()) { kara.turnRight(); } else { while(kara.treeFront()) { kara.turnLeft(); } } // (Schritt ausführen!) kara.move(); } } |
Methoden, die etwas berechnen
Methoden, die etwas berechnen, haben in der Regel folgenden Aufbau:
- Zuerst wird eine Variable
ergebnis
deklariert. - Dann wird mit einer Schleife das zu berechnende Feld (oder Blätterspur o.ä.) durchlaufen.
In der Schleife passiert folgendes:- Die Berechnung wird aktualisiert
- Es wird zum nächsten Schritt weitergegangen.
- Wenn die Schleife fertig ist, dann wird mit dem Schlüsselwort
return
dasergebnis
zurückgegeben.
Beispiel
Die folgende Methode lässt Kara so lange geradeaus laufen, wie Kara auf einem Blatt steht.
Dabei werden die Blätter gezählt und am Ende der Methode zurückgegeben.
Programmbeschreibung | Java Quelltext | |||
---|---|---|---|---|
|
public int zaehleBlaetter() { int ergebnis = 0; while(kara.onLeaf()) { ergebnis = ergebnis + 1; kara.move(); } return ergebnis; } |
Aufruf der Methode
Die Methode zaehleBlaetter()
kann z.B. so verwendet werden:
int anzahl = zaehleBlaetter();
kara.turnLeft();
kara.move();
kara.turnLeft();
kara.move();
linieLegen(anzahl);
Erklärung:
Die Methode zaehleBlaetter()
gibt eine Zahl zurück.
Diese Zahl wird in der lokalen Variable anzahl
gespeichert.
Dann kann anzahl
verwendet werden.
Im Beispiel zählt Kara die Blätter.
Dann wendet sie und legt eine Zeile darunter genau so viele Blätter ab, wie sie gezählt hat.
Zerlegung in mehrere Methoden
Programmieren wird viel einfacher - und vor allem übersichtlicher! - wenn man ein großes Problem in beherrschbare Teilprobleme zerlegt.
Im Idealfall genügt jedes Teilproblem folgenden Anforderungen:
- Es lässt sich ganz einfach programmieren
- Es lässt sich einzeln testen
Vorgehensweise
- Man überlegt sich, in welche Teilprobleme man das Gesamtproblem zerlegen kann.
- Für jedes Teilproblem:
- Programmieren
- Testen
- Jetzt das Gesamtproblem programmieren!
Beispiel 1: Gebirge
Kara soll über das Gebirge klettern, bis sie in einem Tal ein Kleeblatt findet.
Zerlegung
Man sieht, dass Kara immer abwechselnd bergauf und bergab gehen muss! Daher bietet es sich an, das Gesamtproblem mithilfe der folgenden zwei Methoden zu programmieren:
zumGipfel()
insTal()
Programmbeschreibung der Hauptmethode
Programmbeschreibung | |||
---|---|---|---|
|
Programmierung der Teilprobleme
Für die Teilprobleme wird hier nur die Programmierung angegeben.
public void zumGipfel()
{
while(kara.treeFront())
{
// eine Stufe hochsteigen!
kara.turnRight();
kara.move();
kara.turnLeft();
kara.move();
}
}
public void insTal()
{
while(!kara.treeFront())
{
// eine Stufe runtersteigen!
kara.move();
kara.turnRight();
kara.move();
kara.turnLeft();
}
}
Programmierung der Hauptmethode
Jetzt kann man die Hauptmethode programmieren, indem man die Methoden zumGipfel()
und insTal()
verwendet!
Dafür wird die Programmbeschreibung in ein Java-Programm übersetzt.
Programmbeschreibung | Java-Quelltext | |||
---|---|---|---|---|
|
public void sucheKleeblatt() { while(!kara.onLeaf()) { zumGipfel(); insTal(); } } |
Beispiel 2: Wintervorrat
Kara soll bis zur Höhle gehen und alle Kleeblätter aufsammeln.
Dann soll Kara die gesammelten Kleeblätter in der Höhle ablegen und sich darüber setzen.
Zerlegung
Das Problem besteht aus mehreren Teilproblemen die nacheinander abgearbeitet werden:
blaetterSammeln()
:
Diese Methode gibt die Zahl der gesammelten Blätter zurück!
Danach dreht sich Kara nach rechts.bisZumBaumGehen()
Danach dreht sich Kara zweimal nach rechts.blaetterLegen(int anzahl)
Dieser Methode wird die Anzahl der gesammelten Blätter übergeben.
Programmbeschreibung der Hauptmethode
Programmbeschreibung | ||
---|---|---|
|
Programmierung der Teilprobleme
Für die Teilprobleme wird hier nur die Programmierung angegeben.
public int blaetterSammeln()
{
int ergebnis = 0;
while(kara.treeRight())
{
// "Nachdenken"
if(kara.onLeaf())
{
kara.removeLeaf();
ergebnis = ergebnis + 1;
}
// "Einen Schritt weiter gehen"
kara.move();
}
return ergebnis;
}
public void bisZumBaumGehen()
{
while(!kara.treeFront())
{
kara.move();
}
}
public void blaetterLegen(int anzahl)
{
for(int i=0; i<anzahl; i++)
{
kara.putLeaf();
kara.move();
}
}
Programmierung der Hauptmethode
Jetzt kann man die Hauptmethode programmieren:
Dafür wird die Programmbeschreibung in ein Java-Programm übersetzt.
Programmbeschreibung | Java-Quelltext | ||
---|---|---|---|
|
public void wintervorratAnlegen() { int blaetterZahl = blaetterSammeln(); kara.turnRight(); bisZumBaumGehen(); kara.turnRight(); kara.turnRight(); blaetterLegen(blaetterZahl); } |