ComeniusWiki - Benutzerbeiträge [de]

Kapitel 7: Objekte und Klassen

2014-03-31T08:29:17Z

PT59kripke:

[[Informatik_10._Klasse_13-14|Zur Startseite]] - [[Kapitel_1:_Vorbereitende_Aufgaben_und_Einstieg|Kapitel 1]] - [[Kapitel_2:_Variablen_und_Datentypen|Kapitel 2]] - [[Kapitel_3:_Kontrollstrukturen|Kapitel 3]] - [[Kapitel_4:_Methoden|Kapitel 4]] - [[Kapitel_5:_Arrays|Kapitel 5]] - [[Kapitel_6:_Objektorientierung|Kapitel 6]] - [[Kapitel_8:_Zustände|Kapitel 8]]

Bisher haben wir vornehmlich Datentypen verwendet, die in JAVA vordefiniert sind (z.B.''int'', ''double'', ''String''). Die große Stärke einer objektorientierten Programmiersprache besteht darin, dass wir als Programmierer eigene Datentypen in Form von Klassen nach unseren Vorstellungen und Bedürfnissen erstellen können. Eine '''Klasse''' beschreibt entsprechend den '''Aufbau eines komplexen Datentyps'''.

 

Beispiele für Objekte der Klasse ''Rechteck'':

[[Datei:Obj1.JPG]]

Wie wir bereits aus der 6.Klasse wissen, lassen sich diese Objekte der Klasse Rechteck auch in Form von '''Objektdiagrammen''' darstellen.

[[Datei:Klass1.JPG]]

Diese Darstellung von Objekten beinhaltet neben dem Objektnamen, der nach einer Konvention immer klein geschrieben wird, die '''Attribute''' des Objekts und die jeweiligen '''Attributwerte'''. Sie definieren den '''Zustand''' des Objekts. Objekte mit den denselben Attributen sind '''Instanzen''' einer Klasse. Eine Klasse stellt einen Konstruktionsplan für bestimmte Objekte dar, der mit all seinen Informationen auch ohne diese Objekte existiert. Eine Klasse ist also keine Menge von Objekten!

 

Die Definition einer Klasse beinhaltet drei Bestandteile:

 

*Die Datenfelder bzw. Instanzvariablen speichern die Daten, die das jeweilge Objekt benutzt.
*Die Konstruktoren erlauben es, neue Objekte zu erzeugen und diese in einen bestimmten Anfangszustand zu versetzen.
*Die Methoden implementieren das Verhalten der Objekte.

<big>[[Exkurs: UML]]</big>

 Beispiel: Die Klasse ''Rechteck''

[[Datei:Klass2.JPG]]

Instanzvariablen und Methoden haben wir bereits kennengelernt. Neu sind die sogenannten Konstruktoren.

 

=== Konstruktor ===

Eine Klasse kann keinen, einen oder mehrere unterschiedliche Konstruktoren besitzen. Sie dienen dazu, ein neu gebildetes Objekt einer Klasse in einen definierten Anfangszustand zu versetzen. Welcher dies ist hängt davon ab, welcher Konstruktor bei der Objektbildung aufgerufen wird. Ein leerer (Standard-) Konstruktor muss nicht angegeben werden, er wird bei Fehlen von der JVM (Java Virtual Machine) automatisch erzeugt. Aus diesem Grund hatten wir in unseren bisherigen Aufgaben keinen expliziten Konstruktor.

'''Syntax:'''
<pre> public nameDerKlasse(Parameter) {}
</pre>
 '''Beispiel''': Konstruktoren der obigen Klasse ''Rechteck'':

'''public Rechteck()''' weist dem Rechteck standardmäßig Werte zu.
<pre>public Rechteck(){
breite = 10;
hoehe = 7;
}
</pre>
Wir erhalten bei Aufruf des Konstruktors ein Rechteck der Größe 10x7. Die restlichen Werte werden von der JVM auf einen internen Standardwert gesetzt.

 

'''public Rechteck(breite, hoehe)''' gibt dem User die Möglichkeit, die Größe des Rechtecks selbst zu bestimmen.

 
<pre>public Rechteck(int breite, int hoehe){
this.breite = breite;
this.hoehe = hoehe;
}
</pre>
Hier werden nach Aufruf des Konstruktors den Instanzvariablen die entsprechenden Werte der Parameter zugewiesen. Das Schlüsselwort '''this''' liefert innerhalb eines Objekts immer eine Referenz auf das Objekt selbst, d.h. es steht in der bekannten Punktschreibweise an der Stelle des Objektnamens einfach das Wort '''this'''.

 

'''public Rechteck(breite, hoehe, fuellfarbe)''' gibt dem User die Möglichkeit, neben der Größe des Rechtecks auch noch dessen Füllfarbe festzulegen.

 
<pre>public Rechteck(int breite, int hoehe, String fuellfarbe){
this.breite = breite;
this.hoehe = hoehe;
this.fuellfarbe = fuellfarbe
}
</pre>
 

Konstruktoren können also mit unterschiedlichen Parameterlisten deklariert sein. Man spricht hier vom '''Überladen''' des Konstruktors.

==== Konstruktoraufruf ====

Neue Instanzen einer Klasse werden mit dem Operator '''''new''''' erzeugt.
<pre>Rechteck rechteck1 = new Rechteck();

Rechteck rechteck2 = new Rechteck(12,8);

Rechteck rechteck3 = new Rechteck(15,4,"rot");
</pre>
Die drei erzeugten Rechtecke sind vom Typ Rechteck; d.h. sie sind Instanzen der Klasse Rechteck. ''rechteck1'' wird mit dem Standardkonstruktor erzeugt und hat die Größe 10x7. ''rechteck2'' wird vom User auf die Größe 12x8 festgelegt ''rechteck3'' bekommt vom User die Größe 15x4 und die Füllfarbe ''rot'' zugewiesen.

Hier sollte nun deutlich werden, dass das erzeugte Objekt eine Variable ist, die nach dem Plan der Klasse ''Rechteck'' aufgebaut ist. Erst wenn das Objekt erzeugt wurde, kann mittels Punktschreibweise auch auf die Eigenschaften des Objekts zugegriffen werden. Beispiel: 

rechteck1.breite = 10;

rechteck3.fuellfarbe = "rot"

 

<big>[[Aufgaben 7.1.]]</big>

===Getter- und Setter-Methoden===

Will man von außen auf ''private'' gesetzte Attribute zugreifen, ist dies nur indirekt möglich. Wir nutzen dazu Methoden, die das betreffende Objekt veranlassen, Werte zurückzugeben bzw. zu verändern. Zur Rückgabe von Werten nutzt man sogenannte '''sondierende Methoden''' oder '''Getter-Methoden'''. Üblicherweise verwendet man als Namen für eine derartige Methode den Bezeichner ''getAttributname''.

Soll der Benutzer auch schreibenden Zugriff auf die Attribute haben, dann erstellt man sogenannte '''Setter-Methoden''', die von außen einen Wert übernehmen und dem auf ''private'' gesetzten Attribut zuweisen. Als Bezeichner verwendet man analog zu den Getter-Methoden ''setAttributname''. Beispiel:

<pre>
public class Rechteck {

private int laenge;
private int breite;

public Rechteck(int laenge, int breite){
this.laenge=laenge;
this.breite=breite;
}

public int getLaenge(){
return laenge;
}

public int getBreite(){
return breite;
}

public void setLaenge(int l){
laenge=l;
}

public void setBreite(int b){
breite=b;
}
}
</pre>

Setter- und Getter-Methoden müssen natürlich auf ''public'' gesetzt werden, um die ihnen zugedachte Aufgabe zu erfüllen.

Bis hierher ist eigentlich noch nicht klar, warum wir den direkten Lese- bzw. Schreibzugriff auf die Attribute kontrollieren sollten. Die Stärke dieses Verfahrens zeigt sich dann, wenn es für den Zugriff Beschränkungen gibt. So kann beispielsweise die Eingabe auf einen bestimmten Wertebereich beschränkt werden und im Fall einer unerlaubten Eingabe die Eingabe verweigert werden. Beispiel: Um zu vermeiden, dass ein Objekt der obigen Klasse '''Rechteck''' einen bestimmten Wert für die Länge bzw. Breite überschreitet, kann man die Methode mit einer bedingten Anweisung versehen:

<pre>
public void setLaenge(int l){
if(l>=100){System.out.println("Unzulaessiger Wert !");}else{
laenge=l;}
}

public void setBreite(int b){
if(b>=100){System.out.println("Unzulaessiger Wert !");}else{
breite=b;
}
}
</pre>

<big>[[Aufgaben 7.2.]]</big>

===Assoziationen===

Eine wichtige Eigenschaft objektorientierter Systeme ist der Austausch von Botschaften zwischen Objekten. Dazu muss ein Objekt andere Objekte "kennen" und kann Botschaften weitergeben. Diese Verbindung nennt sich '''Assoziation'''. Bei Assoziationen ist zu unterscheiden, ob nur eine Seite die andere kennt oder ob eine Navigation in beiden Richtungen möglich ist:

* Eine '''unidirektionale''' Beziehung geht nur in eine Richtung.
* Eine '''bidirektionale''' Beziehung geht in beide Richtungen.

Daneben ist bei Beziehungen die '''Multiplizität''' zu beachten (siehe [[Exkurs: UML]]). Sie sagt aus, mit wie vielen Objekten eine Seite eine Beziehung haben kann. Übliche Beziehungen sind 1:1 und 1:n. Wir beschränken uns hier auf unidirektionale Beziehungen.

'''Implementierung einer unidirektionalen 1:1-Beziehung'''

Bei bekannten Computerspielen kann ein Spieler seine Fahrkünste auf einem Formel 1-Kurs testen oder als Pilot einen Flughafen anfliegen. Dabei muss jeweils ein Spieler mit einem Kurs/Flughafen assoziiert werden. Damit ein Spieler sich auf einem Kurs befinden kann, lässt sich in ''Spieler'' eine Referenzvariable vom Typ ''Kurs'' anlegen. In Java sähe das in etwa so aus:

<pre>
public class Spieler {

public Kurs k;

}

public class Kurs {

}
</pre>

Während des Spiels müssen dann natürlich noch entsprechende Referenzen gesetzt werden:

<pre>
public class Spiel {

Spieler uschi = new Spieler();
Kurs hockenheim = new Kurs();
uschi.k = hockenheim;

}
</pre>

<big>[[Aufgaben 7.3.]]</big>

'''Implementierung einer unidirektionalen 1:n-Beziehung'''

Immer dann, wenn ein Objekt auf mehrere andere Objekte verweisen muss, reicht eine einfache Referenzvariable vom Typ der anderen Seite nicht mehr aus. Dann werden Datenstrukturen benötigt, die mehrere Referenzen aufnehmen können. In Computerspielen kann ein Spieler häufig Gegenstände, Waffen etc. sammeln. Um dies in der Programmierung umzusetzen, müssen auf der 1-Seite eine Datenstruktur verwenden, die eine Anzahl anderer Objekte aufnimmt. Handelt es sich um eine feste Anzahl von Gegenständen, ist als Datenstruktur das bereits bekannte '''Array''' gut geeignet. Bei Spielen, in denen sich die Anzahl der Gegenstände dynamisch ändert, ist ein Array wenig elegant, da die manuelle Vergrößerung oder Verkleinerung des Arrays aufwendig ist. Hier kann man beispielsweise die Klasse '''ArrayList''' aus dem Package '''java.util.ArrayList''' zum Einsatz bringen.

<big>[[Exkurs:Die Klasse ArrayList]]</big>

Wenn wir von einem Spiel ausgehen, in dem ein Spieler Waffen sammeln kann, könnte die Umsetzung folgendermaßen aussehen:

<pre>
public class Weapon
{
public String bezeichnung;

public Weapon( String bezeichnung )
{
this.bezeichnung = bezeichnung;
}
}
</pre>

Die Klasse '''Spieler''' erhält nun ein Attribut weapons von Typ ArrayList:

<pre>
private ArrayList<Weapon> weapons = new ArrayList<Weapon>();
</pre>

Damit sieht die Klasse wie folgt aus:

<pre>
public class Spieler
{
private ArrayList<Weapon> weapons = new ArrayList<Weapon>();

public void addWeapon( Weapon w )
{
weapons.add(w);
}

public void listWeapons()
{
for(int i=0;i<weapons.size();i++){
System.out.println( weapons.get(i).bezeichnung );}
}
}

</pre>

Zuletzt führen wir Spieler und Waffen in der Klasse '''Spiel''' zusammen:

<pre>
public class Spiel{

public Spiel(){

Spieler uschi = new Spieler();

uschi.addWeapon( new Weapon( "Keule" ) );
uschi.addWeapon( new Weapon( "Morgenstern" ) );
uschi.listWeapons(); // Ausgabe: Keule Morgenstern

}
}
</pre>

=== Klassenvariablen und Klassenmethoden ===

Bis jetzt kennen wir bei Variablen zwei Typen: '''Lokale Variablen''', wie wir sie beispielsweise in Schleifen als Zählvariablen verwenden, und '''Instanzvariablen'''. Innerhalb der Klasse ''Kreis'', die sozusagen den Datentyp ''Kreis'' definiert, haben wir beispielsweise ''Radius'', ''Fuellfarbe'' oder ''Linienstärke'' als Instanzvariablen. Jede Variable wird für sich separat für eine Instanz (also ein aus der Klasse erzeugtes Objekt) angelegt, d.h. jede Instanz hat eine eigene Kopie der Variablen. Die Methoden beziehen sich auf die jeweils angelegte Instanz.

Damit alle Objekte einer Klasse eine bestimmte Variable gemeinsam verwenden können, gibt es die sog. '''Klassenvariablen'''. Analog dazu benutzt man '''Klassenmethoden''' für Operationen, die sich nicht auf ein bestimmtes Objekt, sondern auf die Klasse an sich beziehen. Variablen und Methoden werden mit dem Schlüsselwort '''''static''''' an die jeweilige Klasse gebunden. Der Zugriff auf statische Variablen erfolgt über '''Klassenname.Variablenname''', der Zugriff auf statische Methoden über '''Klassenname.Methodennname'''

Folgendes Beispiel soll das Konzept verdeutlichen:

In einer Klasse '''Testobjekt''' wird eine statische Variable '''''zaehler''''' angelegt, in der die Anzahl der erzeugten Instanzen der Klasse abgespeichert wird. Über eine statische Getter-Methode kann der aktuelle Wert des Zählers abgefragt werden. In einer zweiten Klasse '''ZaehlerTest''' werden drei Instanzen der Klasse '''Testobjekt''' erzeugt und als Kontrolle ihre jeweilige Rangzahl ausgegeben. Am Ende wird über die Methode '''getZaehler()''' die Anzahl der erzeugten Instanzen abgefragt.

<pre>
public class Testobjekt {

// Klassenvariable
static int zaehler = 0;

// Instanzvariable
int nummer;

// Konstruktor
public Testobjekt() {
zaehler= zaehler+1;
nummer = zaehler;
}

// Klassenmethode
static int getZaehler() {
return zaehler;
}
}

public class Zaehlertest{

public void zaehlerTest(){
System.out.println("Klassenvariable zaehler:"+ Testobjekt.getZaehler());

Testobjekt obj_1 = new Testobjekt();
Testobjekt obj_2 = new Testobjekt();
Testobjekt obj_3 = new Testobjekt();

System.out.println("Instanzvariable nummer im 1. Objekt: "+ obj_1.nummer);
System.out.println("Instanzvariable nummer im 2. Objekt: "+ obj_2.nummer);
System.out.println("Instanzvariable nummer im 3. Objekt: "+ obj_3.nummer);
System.out.println("Klassenvariable zaehler: " + Testobjekt.getZaehler());

}
}

</pre>

<big>[[Aufgaben 7.4.]]</big>

Aufgaben 2.1.

2013-10-09T14:54:34Z

PT59kripke:

Zur Lösung der Aufgaben soll folgendes Grundgerüst verwendet werden:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

//Beispielaufgabe Addieren
public void addieren(){
Scanner eingabe = new Scanner (System.in);
System.out.print ("Geben Sie die erste Zahl ein: ");
int z1 = eingabe.nextInt();
System.out.print ("Geben Sie die zweite Zahl ein: ");
int z2 = eingabe.nextInt();
int add = z1 + z2;
System.out.println("Die Summe aus "+z1+" und "+z2+" lautet: "+add);
}

}
</pre>

Erläuterungen:
* Mit ''import java.util.Scanner'' wird ein sogenanntes Package importiert, das die Möglichkeit bietet, Zahlen oder Text auf der Konsole einzugeben. ([http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html Dokumentation der Klasse Scanner])
* Mit ''Scanner eingabe = new Scanner (System.in)'' wird ein Scanner-Objekt mit dem Namen ''eingabe'' erzeugt, das die Verwendung der benötigten Eingabemethoden ermöglicht.
* Die Eingabe erfolgt nach folgendem Schema:
<pre>
System.out.print ("Geben Sie die erste Zahl ein: "); // Der Text zwischen den Anführungszeichen kann beliebig sein
int zahl1 = eingabe.nextInt(); // für ganze Zahlen
double zahl2 = eingabe.nextDouble(); // für Fließkommazahlen
String ein = eingabe.next(); // für Zeichenketten
</pre>
* Der Wert wird nach der ausgegebenen Eingabeaufforderung eingegeben. Nach Betätigen der ENTER-Taste wird der jeweilige Wert der entsprechenden Variable zugewiesen.

'''Aufgabe 2.1.1.''' (Kreisberechnung)

Erstelle eine Methode '''''public void kreisberechnung()''''', die nach Eingabe des Radius den Umfang und den Inhalt des Kreises berechnet und auf der Konsole ausgibt. Pi kann mit dem gerundeten Wert ''3.1415926'' verwendet werden.

[[Lösungsvorschlag Aufgabe 2.1.1|Lösungsvorschlag ]]

'''Aufgabe 2.1.2''' ("Mondbremse")

Aufgrund der Gezeitenkräfte des Mondes wird die Rotation der Erde abgebremst. Als Folge daraus verlängern sich in den nächsten 1000 Jahren die Tage jedes Jahres um 0.0016 Sekunden. Erstelle eine Methode '''''public void mondbremse()''''', die nach Eingabe des Kalenderjahres angibt, um wieviel länger der Tag im Vergleich zu heute dauert. (Achtung: Typumwandlung nicht vergessen!)

[[Lösungsvorschlag Aufgabe 2.1.2|Lösungsvorschlag ]]

'''Aufgabe 2.1.3.''' ("Temperaturumrechnung")

Erstelle eine Methode '''''public void umrechnung_F_C ()''''', die die eingegebene Temperatur von Fahrenheit in Celsius umrechnet und ausgibt. Die Umrechnungsformel lautet: C=5/9(F-32). Vorsicht mit den verwendeten Datentypen, da sonst als Ergebnis immer 0.0 erscheinen wird! (Kontrolle: 212 Grad Fahrenheit entsprechen 100 Grad Celsius.)

[[Lösungsvorschlag Aufgabe 2.1.3|Lösungsvorschlag ]]

'''Aufgabe 2.1.4.''' ("Zinsrechnung")

Erstelle eine Methode '''''public void zinsrechnung()''''', die nach Eingabe von Kapital und Zinssatz (in Prozent) das Kapital nach einem Jahr berechnet. Erweitere anschließend das Programm um die Ausgabe des Kapitals nach zwei Jahren.

[[Lösungsvorschlag Aufgabe 2.1.4|Lösungsvorschlag ]]

'''Aufgabe 2.1.5.''' ("Bogenmaß") 
Erstelle eine Methode '''''public void Bogenmaß()''''', die einen Winkel von Grad nach Bogenmaß umrechnet. Tipp: Die Funktion '''''Math.round(x)''''' rundet auf die nächste ganze Zahl auf oder ab. 
(Kontrolle: 180° entsprechen 3,141) 
[[Lösungsvorschlag Aufgabe 2.1.5|Lösungsvorschlag ]]

'''Aufgabe 2.1.6.''' ("Inchumrechnung") 
Erstelle eine Methode '''''public void inchUmrechnung()''''', die von der Einheit Inch nach cm umrechnet.
(Kontrolle: 1cm entsprechen 2,54)

[[Lösungsvorschlag Aufgabe 2.1.6|Lösungsvorschlag ]]

Aufgaben 2.1.

2013-10-09T14:53:51Z

PT59kripke:

Zur Lösung der Aufgaben soll folgendes Grundgerüst verwendet werden:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

//Beispielaufgabe Addieren
public void addieren(){
Scanner eingabe = new Scanner (System.in);
System.out.print ("Geben Sie die erste Zahl ein: ");
int z1 = eingabe.nextInt();
System.out.print ("Geben Sie die zweite Zahl ein: ");
int z2 = eingabe.nextInt();
int add = z1 + z2;
System.out.println("Die Summe aus "+z1+" und "+z2+" lautet: "+add);
}

}
</pre>

Erläuterungen:
* Mit ''import java.util.Scanner'' wird ein sogenanntes Package importiert, das die Möglichkeit bietet, Zahlen oder Text auf der Konsole einzugeben. ([http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html Dokumentation der Klasse Scanner])
* Mit ''Scanner eingabe = new Scanner (System.in)'' wird ein Scanner-Objekt mit dem Namen ''eingabe'' erzeugt, das die Verwendung der benötigten Eingabemethoden ermöglicht.
* Die Eingabe erfolgt nach folgendem Schema:
<pre>
System.out.print ("Geben Sie die erste Zahl ein: "); // Der Text zwischen den Anführungszeichen kann beliebig sein
int zahl1 = eingabe.nextInt(); // für ganze Zahlen
double zahl2 = eingabe.nextDouble(); // für Fließkommazahlen
String ein = eingabe.next(); // für Zeichenketten
</pre>
* Der Wert wird nach der ausgegebenen Eingabeaufforderung eingegeben. Nach Betätigen der ENTER-Taste wird der jeweilige Wert der entsprechenden Variable zugewiesen.

'''Aufgabe 2.1.1.''' (Kreisberechnung)

Erstelle eine Methode '''''public void kreisberechnung()''''', die nach Eingabe des Radius den Umfang und den Inhalt des Kreises berechnet und auf der Konsole ausgibt. Pi kann mit dem gerundeten Wert ''3.1415926'' verwendet werden.

[[Lösungsvorschlag Aufgabe 2.1.1|Lösungsvorschlag ]]

'''Aufgabe 2.1.2''' ("Mondbremse")

Aufgrund der Gezeitenkräfte des Mondes wird die Rotation der Erde abgebremst. Als Folge daraus verlängern sich in den nächsten 1000 Jahren die Tage jedes Jahres um 0.0016 Sekunden. Erstelle eine Methode '''''public void mondbremse()''''', die nach Eingabe des Kalenderjahres angibt, um wieviel länger der Tag im Vergleich zu heute dauert. (Achtung: Typumwandlung nicht vergessen!)

[[Lösungsvorschlag Aufgabe 2.1.2|Lösungsvorschlag ]]

'''Aufgabe 2.1.3.''' ("Temperaturumrechnung")

Erstelle eine Methode '''''public void umrechnung_F_C ()''''', die die eingegebene Temperatur von Fahrenheit in Celsius umrechnet und ausgibt. Die Umrechnungsformel lautet: C=5/9(F-32). Vorsicht mit den verwendeten Datentypen, da sonst als Ergebnis immer 0.0 erscheinen wird! (Kontrolle: 212 Grad Fahrenheit entsprechen 100 Grad Celsius.)

[[Lösungsvorschlag Aufgabe 2.1.3|Lösungsvorschlag ]]

'''Aufgabe 2.1.4.''' ("Zinsrechnung")

Erstelle eine Methode '''''public void zinsrechnung()''''', die nach Eingabe von Kapital und Zinssatz (in Prozent) das Kapital nach einem Jahr berechnet. Erweitere anschließend das Programm um die Ausgabe des Kapitals nach zwei Jahren.

[[Lösungsvorschlag Aufgabe 2.1.4|Lösungsvorschlag ]]

'''Aufgabe 2.1.5.''' ("Bogenmaß") 
Erstelle eine Methode '''''public void Bogenmaß()''''', die einen Winkel von Grad nach Bogenmaß umrechnet. Tipp: Die Funktion '''''Math.round(x)''''' rundet auf die nächste ganze Zahl auf oder ab. 
(Kontrolle: 180° entsprechen 3,141) 
[[Lösungsvorschlag Aufgabe 2.1.5|Lösungsvorschlag ]]

'''Aufgabe 2.1.6.''' ("Inchumrechnung") 
Erstelle eine Methode '''''public void inchUmrechnung()''''', die von der Einheit Inch nach cm umrechnet.
(Kontrolle: 1cm entsprechen 2,54)

[[Lösungsvorschlag Aufgabe 2.1.6|Lösungsvorschlag ]]

Aufgaben 2.1.

2013-10-08T15:48:51Z

PT59kripke:

Zur Lösung der Aufgaben soll folgendes Grundgerüst verwendet werden:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

//Beispielaufgabe Addieren
public void addieren(){
Scanner eingabe = new Scanner (System.in);
System.out.print ("Geben Sie die erste Zahl ein: ");
int z1 = eingabe.nextInt();
System.out.print ("Geben Sie die zweite Zahl ein: ");
int z2 = eingabe.nextInt();
int add = z1 + z2;
System.out.println("Die Summe aus "+z1+" und "+z2+" lautet: "+add);
}

}
</pre>

Erläuterungen:
* Mit ''import java.util.Scanner'' wird ein sogenanntes Package importiert, das die Möglichkeit bietet, Zahlen oder Text auf der Konsole einzugeben. ([http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html Dokumentation der Klasse Scanner])
* Mit ''Scanner eingabe = new Scanner (System.in)'' wird ein Scanner-Objekt mit dem Namen ''eingabe'' erzeugt, das die Verwendung der benötigten Eingabemethoden ermöglicht.
* Die Eingabe erfolgt nach folgendem Schema:
<pre>
System.out.print ("Geben Sie die erste Zahl ein: "); // Der Text zwischen den Anführungszeichen kann beliebig sein
int zahl1 = eingabe.nextInt(); // für ganze Zahlen
double zahl2 = eingabe.nextDouble(); // für Fließkommazahlen
String ein = eingabe.next(); // für Zeichenketten
</pre>
* Der Wert wird nach der ausgegebenen Eingabeaufforderung eingegeben. Nach Betätigen der ENTER-Taste wird der jeweilige Wert der entsprechenden Variable zugewiesen.

'''Aufgabe 2.1.1.''' (Kreisberechnung)

Erstelle eine Methode '''''public void kreisberechnung()''''', die nach Eingabe des Radius den Umfang und den Inhalt des Kreises berechnet und auf der Konsole ausgibt. Pi kann mit dem gerundeten Wert ''3.1415926'' verwendet werden.

[[Lösungsvorschlag Aufgabe 2.1.1|Lösungsvorschlag ]]

'''Aufgabe 2.1.2''' ("Mondbremse")

Aufgrund der Gezeitenkräfte des Mondes wird die Rotation der Erde abgebremst. Als Folge daraus verlängern sich in den nächsten 1000 Jahren die Tage jedes Jahres um 0.0016 Sekunden. Erstelle eine Methode '''''public void mondbremse()''''', die nach Eingabe des Kalenderjahres angibt, um wieviel länger der Tag im Vergleich zu heute dauert. (Achtung: Typumwandlung nicht vergessen!)

[[Lösungsvorschlag Aufgabe 2.1.2|Lösungsvorschlag ]]

'''Aufgabe 2.1.3.''' ("Temperaturumrechnung")

Erstelle eine Methode '''''public void umrechnung_F_C ()''''', die die eingegebene Temperatur von Fahrenheit in Celsius umrechnet und ausgibt. Die Umrechnungsformel lautet: C=5/9(F-32). Vorsicht mit den verwendeten Datentypen, da sonst als Ergebnis immer 0.0 erscheinen wird! (Kontrolle: 212 Grad Fahrenheit entsprechen 100 Grad Celsius.)

[[Lösungsvorschlag Aufgabe 2.1.3|Lösungsvorschlag ]]

'''Aufgabe 2.1.4.''' ("Zinsrechnung")

Erstelle eine Methode '''''public void zinsrechnung()''''', die nach Eingabe von Kapital und Zinssatz (in Prozent) das Kapital nach einem Jahr berechnet. Erweitere anschließend das Programm um die Ausgabe des Kapitals nach zwei Jahren.

[[Lösungsvorschlag Aufgabe 2.1.4|Lösungsvorschlag ]]

'''Aufgabe 2.1.5.''' ("Bogenmaß") 
Erstelle eine Methode '''''public void Bogenmaß()''''', die einen Winkel von Grad nach Bogenmaß umrechnet. (Kontrolle: 180° entsprechen 3,141) 
[[Lösungsvorschlag Aufgabe 2.1.5|Lösungsvorschlag ]]

Lösungsvorschlag Aufgabe 2.1.5

2013-10-07T15:11:06Z

PT59kripke:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

public void Bogenmaß(){
Scanner eingabe = new Scanner (System.in);

System.out.print ("Geben Sie den Winkel in Grad ein: ");
int grad = eingabe.nextInt();

double rad = Math.round( grad * 0.0174);

System.out.println(+grad+" grad entsprechen im Bogenmaß"+rad+" rad");
}

}

</pre>

Lösungsvorschlag Aufgabe 2.1.5

2013-10-07T15:10:42Z

PT59kripke: Die Seite wurde neu angelegt: „<pre> public void Bogenmaß(){ Scanner eingabe = new Scanner (System.in); System.out.print ("Geben Sie den Winkel in Grad ein: "); int grad = ei…“

<pre>

public void Bogenmaß(){
Scanner eingabe = new Scanner (System.in);

System.out.print ("Geben Sie den Winkel in Grad ein: ");
int grad = eingabe.nextInt();

double rad = Math.round( grad * 0.0174);

System.out.println(+grad+" grad entsprechen im Bogenmaß"+rad+" rad");
}

</pre>

Aufgaben 2.1.

2013-10-07T14:57:56Z

PT59kripke:

Zur Lösung der Aufgaben soll folgendes Grundgerüst verwendet werden:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

//Beispielaufgabe Addieren
public void addieren(){
Scanner eingabe = new Scanner (System.in);
System.out.print ("Geben Sie die erste Zahl ein: ");
int z1 = eingabe.nextInt();
System.out.print ("Geben Sie die zweite Zahl ein: ");
int z2 = eingabe.nextInt();
int add = z1 + z2;
System.out.println("Die Summe aus "+z1+" und "+z2+" lautet: "+add);
}

}
</pre>

Erläuterungen:
* Mit ''import java.util.Scanner'' wird ein sogenanntes Package importiert, das die Möglichkeit bietet, Zahlen oder Text auf der Konsole einzugeben. ([http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html Dokumentation der Klasse Scanner])
* Mit ''Scanner eingabe = new Scanner (System.in)'' wird ein Scanner-Objekt mit dem Namen ''eingabe'' erzeugt, das die Verwendung der benötigten Eingabemethoden ermöglicht.
* Die Eingabe erfolgt nach folgendem Schema:
<pre>
System.out.print ("Geben Sie die erste Zahl ein: "); // Der Text zwischen den Anführungszeichen kann beliebig sein
int zahl1 = eingabe.nextInt(); // für ganze Zahlen
double zahl2 = eingabe.nextDouble(); // für Fließkommazahlen
String ein = eingabe.next(); // für Zeichenketten
</pre>
* Der Wert wird nach der ausgegebenen Eingabeaufforderung eingegeben. Nach Betätigen der ENTER-Taste wird der jeweilige Wert der entsprechenden Variable zugewiesen.

'''Aufgabe 2.1.1.''' (Kreisberechnung)

Erstelle eine Methode '''''public void kreisberechnung()''''', die nach Eingabe des Radius den Umfang und den Inhalt des Kreises berechnet und auf der Konsole ausgibt. Pi kann mit dem gerundeten Wert ''3.1415926'' verwendet werden.

[[Lösungsvorschlag Aufgabe 2.1.1|Lösungsvorschlag ]]

'''Aufgabe 2.1.2''' ("Mondbremse")

Aufgrund der Gezeitenkräfte des Mondes wird die Rotation der Erde abgebremst. Als Folge daraus verlängern sich in den nächsten 1000 Jahren die Tage jedes Jahres um 0.0016 Sekunden. Erstelle eine Methode '''''public void mondbremse()''''', die nach Eingabe des Kalenderjahres angibt, um wieviel länger der Tag im Vergleich zu heute dauert. (Achtung: Typumwandlung nicht vergessen!)

[[Lösungsvorschlag Aufgabe 2.1.2|Lösungsvorschlag ]]

'''Aufgabe 2.1.3.''' ("Temperaturumrechnung")

Erstelle eine Methode '''''public void umrechnung_F_C ()''''', die die eingegebene Temperatur von Fahrenheit in Celsius umrechnet und ausgibt. Die Umrechnungsformel lautet: C=5/9(F-32). Vorsicht mit den verwendeten Datentypen, da sonst als Ergebnis immer 0.0 erscheinen wird! (Kontrolle: 212 Grad Fahrenheit entsprechen 100 Grad Celsius.)

[[Lösungsvorschlag Aufgabe 2.1.3|Lösungsvorschlag ]]

'''Aufgabe 2.1.4.''' ("Zinsrechnung")

Erstelle eine Methode '''''public void zinsrechnung()''''', die nach Eingabe von Kapital und Zinssatz (in Prozent) das Kapital nach einem Jahr berechnet. Erweitere anschließend das Programm um die Ausgabe des Kapitals nach zwei Jahren.

[[Lösungsvorschlag Aufgabe 2.1.4|Lösungsvorschlag ]]

'''Aufgabe 2.1.5.''' ("Bogenmaß") 
Erstelle eine Methode '''''public void Bogenmaß()''''', die einen Winkel von Grad nach Bogenmaß umrechnet. (Kontrolle 180° entsprechen 3,141) 
[[Lösungsvorschlag Aufgabe 2.1.5|Lösungsvorschlag ]]

Aufgaben 2.1.

2013-10-07T14:55:45Z

PT59kripke:

Zur Lösung der Aufgaben soll folgendes Grundgerüst verwendet werden:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

//Beispielaufgabe Addieren
public void addieren(){
Scanner eingabe = new Scanner (System.in);
System.out.print ("Geben Sie die erste Zahl ein: ");
int z1 = eingabe.nextInt();
System.out.print ("Geben Sie die zweite Zahl ein: ");
int z2 = eingabe.nextInt();
int add = z1 + z2;
System.out.println("Die Summe aus "+z1+" und "+z2+" lautet: "+add);
}

}
</pre>

Erläuterungen:
* Mit ''import java.util.Scanner'' wird ein sogenanntes Package importiert, das die Möglichkeit bietet, Zahlen oder Text auf der Konsole einzugeben. ([http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html Dokumentation der Klasse Scanner])
* Mit ''Scanner eingabe = new Scanner (System.in)'' wird ein Scanner-Objekt mit dem Namen ''eingabe'' erzeugt, das die Verwendung der benötigten Eingabemethoden ermöglicht.
* Die Eingabe erfolgt nach folgendem Schema:
<pre>
System.out.print ("Geben Sie die erste Zahl ein: "); // Der Text zwischen den Anführungszeichen kann beliebig sein
int zahl1 = eingabe.nextInt(); // für ganze Zahlen
double zahl2 = eingabe.nextDouble(); // für Fließkommazahlen
String ein = eingabe.next(); // für Zeichenketten
</pre>
* Der Wert wird nach der ausgegebenen Eingabeaufforderung eingegeben. Nach Betätigen der ENTER-Taste wird der jeweilige Wert der entsprechenden Variable zugewiesen.

'''Aufgabe 2.1.1.''' (Kreisberechnung)

Erstelle eine Methode '''''public void kreisberechnung()''''', die nach Eingabe des Radius den Umfang und den Inhalt des Kreises berechnet und auf der Konsole ausgibt. Pi kann mit dem gerundeten Wert ''3.1415926'' verwendet werden.

[[Lösungsvorschlag Aufgabe 2.1.1|Lösungsvorschlag ]]

'''Aufgabe 2.1.2''' ("Mondbremse")

Aufgrund der Gezeitenkräfte des Mondes wird die Rotation der Erde abgebremst. Als Folge daraus verlängern sich in den nächsten 1000 Jahren die Tage jedes Jahres um 0.0016 Sekunden. Erstelle eine Methode '''''public void mondbremse()''''', die nach Eingabe des Kalenderjahres angibt, um wieviel länger der Tag im Vergleich zu heute dauert. (Achtung: Typumwandlung nicht vergessen!)

[[Lösungsvorschlag Aufgabe 2.1.2|Lösungsvorschlag ]]

'''Aufgabe 2.1.3.''' ("Temperaturumrechnung")

Erstelle eine Methode '''''public void umrechnung_F_C ()''''', die die eingegebene Temperatur von Fahrenheit in Celsius umrechnet und ausgibt. Die Umrechnungsformel lautet: C=5/9(F-32). Vorsicht mit den verwendeten Datentypen, da sonst als Ergebnis immer 0.0 erscheinen wird! (Kontrolle: 212 Grad Fahrenheit entsprechen 100 Grad Celsius.)

[[Lösungsvorschlag Aufgabe 2.1.3|Lösungsvorschlag ]]

'''Aufgabe 2.1.4.''' ("Zinsrechnung")

Erstelle eine Methode '''''public void zinsrechnung()''''', die nach Eingabe von Kapital und Zinssatz (in Prozent) das Kapital nach einem Jahr berechnet. Erweitere anschließend das Programm um die Ausgabe des Kapitals nach zwei Jahren.

[[Lösungsvorschlag Aufgabe 2.1.4|Lösungsvorschlag ]]

'''Aufgabe 2.1.5.''' ("Winkelmaßumrechnung")
Erstelle eine Methode '''''public void Bogenmaß()''''', die das einen Winkel in Bogenmaß angibt. (Kontrolle 180° entsprechen 3,141) 
[[Lösungsvorschlag Aufgabe 2.1.5|Lösungsvorschlag ]]

Aufgaben 2.1.

2013-10-07T14:55:12Z

PT59kripke:

Zur Lösung der Aufgaben soll folgendes Grundgerüst verwendet werden:

<pre>
import java.util.Scanner;

public class Aufgaben_2_1{

//Beispielaufgabe Addieren
public void addieren(){
Scanner eingabe = new Scanner (System.in);
System.out.print ("Geben Sie die erste Zahl ein: ");
int z1 = eingabe.nextInt();
System.out.print ("Geben Sie die zweite Zahl ein: ");
int z2 = eingabe.nextInt();
int add = z1 + z2;
System.out.println("Die Summe aus "+z1+" und "+z2+" lautet: "+add);
}

}
</pre>

Erläuterungen:
* Mit ''import java.util.Scanner'' wird ein sogenanntes Package importiert, das die Möglichkeit bietet, Zahlen oder Text auf der Konsole einzugeben. ([http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html Dokumentation der Klasse Scanner])
* Mit ''Scanner eingabe = new Scanner (System.in)'' wird ein Scanner-Objekt mit dem Namen ''eingabe'' erzeugt, das die Verwendung der benötigten Eingabemethoden ermöglicht.
* Die Eingabe erfolgt nach folgendem Schema:
<pre>
System.out.print ("Geben Sie die erste Zahl ein: "); // Der Text zwischen den Anführungszeichen kann beliebig sein
int zahl1 = eingabe.nextInt(); // für ganze Zahlen
double zahl2 = eingabe.nextDouble(); // für Fließkommazahlen
String ein = eingabe.next(); // für Zeichenketten
</pre>
* Der Wert wird nach der ausgegebenen Eingabeaufforderung eingegeben. Nach Betätigen der ENTER-Taste wird der jeweilige Wert der entsprechenden Variable zugewiesen.

'''Aufgabe 2.1.1.''' (Kreisberechnung)

Erstelle eine Methode '''''public void kreisberechnung()''''', die nach Eingabe des Radius den Umfang und den Inhalt des Kreises berechnet und auf der Konsole ausgibt. Pi kann mit dem gerundeten Wert ''3.1415926'' verwendet werden.

[[Lösungsvorschlag Aufgabe 2.1.1|Lösungsvorschlag ]]

'''Aufgabe 2.1.2''' ("Mondbremse")

Aufgrund der Gezeitenkräfte des Mondes wird die Rotation der Erde abgebremst. Als Folge daraus verlängern sich in den nächsten 1000 Jahren die Tage jedes Jahres um 0.0016 Sekunden. Erstelle eine Methode '''''public void mondbremse()''''', die nach Eingabe des Kalenderjahres angibt, um wieviel länger der Tag im Vergleich zu heute dauert. (Achtung: Typumwandlung nicht vergessen!)

[[Lösungsvorschlag Aufgabe 2.1.2|Lösungsvorschlag ]]

'''Aufgabe 2.1.3.''' ("Temperaturumrechnung")

Erstelle eine Methode '''''public void umrechnung_F_C ()''''', die die eingegebene Temperatur von Fahrenheit in Celsius umrechnet und ausgibt. Die Umrechnungsformel lautet: C=5/9(F-32). Vorsicht mit den verwendeten Datentypen, da sonst als Ergebnis immer 0.0 erscheinen wird! (Kontrolle: 212 Grad Fahrenheit entsprechen 100 Grad Celsius.)

[[Lösungsvorschlag Aufgabe 2.1.3|Lösungsvorschlag ]]

'''Aufgabe 2.1.4.''' ("Zinsrechnung")

Erstelle eine Methode '''''public void zinsrechnung()''''', die nach Eingabe von Kapital und Zinssatz (in Prozent) das Kapital nach einem Jahr berechnet. Erweitere anschließend das Programm um die Ausgabe des Kapitals nach zwei Jahren.

[[Lösungsvorschlag Aufgabe 2.1.4|Lösungsvorschlag ]]

'''Aufgabe 2.1.5.''' ("Winkelmaßumrechnung")
Erstelle eine Methode '''''public void Bogenmaß()''''', die das einen Winkel in Bogenmaß angibt. (Kontrolle 180° entsprechen 3,141)
[[Lösungsvorschlag Aufgabe 2.1.5|Lösungsvorschlag ]]

Lösungsvorschlag Zweiseitige bedingte Anweisung

2013-09-17T16:30:24Z

PT59kripke:

'''Aufgabe 1'''

<pre>
wiederhole solange nicht istziegel

wenn nicht istwand
dann
hinlegen
schritt
sonst
linksdrehen

*wenn

*wiederhole
</pre>

Lösungstrategie:

Hier wird Karol einfach solange abgefragt ob er schon an der Wand steht oder noch einen Zigel legen kann,
bis er wieder den ersten Ziegel erreicht hat.

Lösungsvorschlag Zweiseitige bedingte Anweisung

2013-09-17T16:26:51Z

PT59kripke: Die Seite wurde neu angelegt: „'''Aufgabe 1''' <pre> wiederhole solange nicht istziegel wenn nicht istwand dann hinlegen schritt sonst linksdrehen *wenn *wiederhole </pre>“

'''Aufgabe 1'''

<pre>
wiederhole solange nicht istziegel

wenn nicht istwand
dann
hinlegen
schritt
sonst
linksdrehen

*wenn

*wiederhole
</pre>

Lösungsvorschlag Wiederholung mit Anfangsbedingung

2013-09-17T16:19:59Z

PT59kripke: Erklärung hinzugefügt

'''Aufgabe 1'''

<pre>
wiederhole 4 mal

wiederhole solange nicht istwand
hinlegen
schritt
*wiederhole

linksdrehen

*wiederhole

</pre>

Lösungsstrageie: 

Da die Teilaufgabe, eine Seite des Quadrates abzuschreiten und Ziegel zu setzen, 4 mal (wegen der 4 Seiten eines Quadrats)
ausgeführt werden muss, 
empfiehlt es sich das Skript so zu gestalten, dass ein Teil wiederholt werden kann:

*Anfangs muss Karo solange einen Ziegel legen und einen Schritt machen, bis er die Wand berührt

*Dann dreht er sich einmal nach links, damit er wieder so da steht dass er die nächst Bahn abschreiten kann.

'''Aufgabe 2'''

<pre>
wiederhole solange nicht istziegel

wenn nicht istwand dann
hinlegen
schritt
sonst
linksdrehen

*wenn

*wiederhole
</pre>

Lösungsvorschlag Wiederholung mit Anfangsbedingung

2013-09-17T16:14:23Z

PT59kripke:

'''Aufgabe 1'''

<pre>
wiederhole 4 mal

wiederhole solange nicht istwand
hinlegen
schritt
*wiederhole

linksdrehen

*wiederhole

</pre>

Lösungsstrageie: 

*Da die Teilaufgabe, eine Seite des Quadrates abzuschreiten und Ziegel zu setzen, 4 mal (wegen der 4 Seiten eines Quadrats)
ausgeführt werden muss, empfiehlt es sich das Skript so zu gestalten, dass ein Teil werden kann.

'''Aufgabe 2'''

<pre>
wiederhole solange nicht istziegel

wenn nicht istwand dann
hinlegen
schritt
sonst
linksdrehen

*wenn

*wiederhole
</pre>

Lösungsvorschlag Wiederholung mit Anfangsbedingung

2013-09-17T16:04:03Z

PT59kripke: horiz. Linie entfernt

'''Aufgabe 1'''

<pre>
wiederhole 4 mal

wiederhole solange nicht istwand
hinlegen
schritt
*wiederhole

linksdrehen

*wiederhole

</pre>

'''Aufgabe 2'''

<pre>
wiederhole solange nicht istziegel

wenn nicht istwand dann
hinlegen
schritt
sonst
linksdrehen

*wenn

*wiederhole
</pre>

Lösungsvorschlag Wiederholung mit Anfangsbedingung

2013-09-17T16:03:20Z

PT59kripke:

'''Aufgabe 1'''

<pre>
wiederhole 4 mal

wiederhole solange nicht istwand
hinlegen
schritt
*wiederhole

linksdrehen

*wiederhole

</pre>

----

'''Aufgabe 2'''

<pre>
wiederhole solange nicht istziegel

wenn nicht istwand dann
hinlegen
schritt
sonst
linksdrehen

*wenn

*wiederhole
</pre>

Lösungsvorschlag Wiederholung mit Anfangsbedingung

2013-09-17T15:50:13Z

PT59kripke:

'''Aufgabe 1'''

<pre>
wiederhole 4 mal

wiederhole solange nicht istwand
hinlegen
schritt
*wiederhole

linksdrehen

*wiederhole

</pre>

Lösungsvorschlag Wiederholung mit Anfangsbedingung

2013-09-17T15:47:27Z

PT59kripke: Die Seite wurde neu angelegt: „'''Aufgabe 1'''“

'''Aufgabe 1'''

Datei:ObjekteKarol.png

2013-09-16T20:31:35Z

PT59kripke:

== Beschreibung ==
{{Information_ohne_UploadWizard
|Beschreibung = verschiedene Objekte aus Karos Welt
|Quelle = Screenshot
|Urheber = PT59Kripke
|Datum = 16.09.2013
|Genehmigung =
|Andere Versionen =
|Anmerkungen = Screenshot aus "Robot Karol 2.3"
}}
== Lizenz ==
{{Bild-CC-by-sa/3.0/de}}

Programmieren lernen mit Robot Karol

2013-09-16T20:29:34Z

PT59kripke: /* Objekte */

== Das Programm ==

{|
|width=800px|
Robot Karol ist eine Programmierumgebung mit einer Programmiersprache, die zum Erlernen des Programmierens und zur Einführung in die Algorithmik in der Schule gedacht ist. Das Programm ist Freeware und kann über den Link [http://www.schule.bayern.de/karol/download.htm Karol] heruntergeladen werden.
|width=20px|
|width=300px |
|}

===Die Oberfläche===

{|
|width=800px|
Die Programmoberfläche von Karol ist zweigeteilt: Auf der linken Seiten befindet sich der sogenannte Editor, in dem die Programme geschrieben werden. Auf der rechten Seite ist Karols Welt, in der das verfasste Programm ausgeführt werden kann.
|width=20px|
|width=300px |
|}

=== Objekte ===
{|
|width=800px|
In Karos Welt gibt es einige Objekte die von Karo verteilt und wieder eingesammelt werden können.

* Ziegel

:Karol kann Ziegel vor sich hinlegen. Sollte vor ihm bereits ein Ziegel liegen, wird der nächste Ziegel auf den anderen drauf gelegt. 
:Wenn Karol vor einem Ziegel steht und einen Schritt macht, steigt er auf den Ziegel. Allerdings kann er nicht über 2 Ziegel auf einmal steigen. 
:Das heißt um auf einen 2er Ziegelturm zu kommen, muss er über einen davorliegenden einzelnen Ziegelstein "klettern". 

* Marke

:Marken werden direkt auf das Feld unter Karol gelegt. Sie dienen zur Orientierung und haben keinen Einfluss auf Karols 
:Bewegungsmöglichkeiten; er kann einfach darüber laufen. Im Gegensatz zu Ziegeln können nicht mehrer Marken übereinander gestapelt werden. 

*Quader

:Quader versperren Karol den Weg. Er kann nicht über sie gehen. Außerdem lassen sie sich nicht stapeln.

[[Datei:ObjekteKarol.png]]
|width=20px|
|width=300px |
|}

=== Die Bewegungmöglichkeiten von Karol ===

{|
|width=800px|
Die Bewegungsmöglichkeiten von Karol sind recht übersichtlich. Mit den angegebenen Anweisungen kann das entsprechende Verhalten gesteuert werden.
|width=20px|
|width=300px |
|}

{| class="wikitable "
|- style="background: #DDFFDD;"
! Verhalten
! Anweisung
|-
| ein Schritt vorwärts
| '''Schritt'''
|-
| eine Vierteldrehung nach links
| '''LinksDrehen'''
|-
| eine Vierteldrehung nach rechts
| '''RechtsDrehen'''
|-
| einen Ziegel vor sich hinlegen
| '''Hinlegen'''
|-
| einen Ziegel vor sich entfernen
| '''Aufheben'''
|-
| eine gelbe Marke unter sich legen
| '''MarkeSetzen'''
|-
| eine gelbe Marke unter sich entfernen
| '''MarkeLöschen'''
|}

=== Karols Welt ===
{|
|width=800px|
Auf der rechten Seite der Karoloberfläche befindet sich Karols Welt. Durch Aufruf von ''Welt - Neue Welt'' kann die gewünschte Ausdehnung der neuen Welt festgelegt werden. Wenn die Ausgangsposition vom Standardstartpunkt (1,1) abweicht oder Hindernisse zur von Karol zu lösenden Welt gehören, dann empfiehlt es sich, die Welt über ''Welt - Welt speichern'' mit der Endung '''.kdw''' abzuspeichern.
[[Datei:KarolsWelt.JPG]]
|width=20px|
|width=300px |
|}

== Erste Programme ==

{|
|width=800px|
Das Programm "Robot Karol" ermöglicht es uns, dem Roboter, der sich in seiner Welt bewegen und Aufgaben erfüllen kann, Anweisungen zu geben.
{{Kasten_blass|Durch eine '''Anweisung''' (z.B. "Schritt") sendet man eine Botschaft an ein '''Objekt''' (z.B. Karol), das darauf mit der zugehörigen '''Methode''' reagiert (z.B. Schritt() ). }}

|width=20px|
|width=300px |
|}

'''Aufgabe''' 
Karol soll eine U-Form abschreiten 

'''Lösung'''

{|class="wikitable"
|-style="background:#DDFFDD;"
! umgangssprachlich formuliert
! Karolprogramm
|-
|
* 2 mal vorwärts
* Linksum
* 2 mal vorwärts
* Linksum
* 2 mal vorwärts
|
Schritt 
Schritt 
LinksDrehen 
Schritt 
Schritt 
LinksDrehen 
Schritt 
Schritt 
|}

{|
|width=800px|
Eine solche Folge von Anweisungen bezeichnet man als '''Algorithmus'''.
{{Kasten_blass|
Ein '''Algorithmus''' ist eine endliche Folge aus eindeutigen und ausführbaren Anweisungen zur Lösung eines allgemeinen Problems. 
Ein '''Programm''' ist ein Algorithmus, der in einer formalisierten Sprache abgefasst ist und maschinell ausgeführt werden kann.}}
|width=20px|
|width=300px |
|}
 
'''Aufgaben:'''
{|
|width=800px|
# Karol soll ein Rechteck ablaufen und am Ende wieder in der Ausgangsposition stehen.
# Damit man besser erkennt, ob Karol auch ein „U“ durchläuft, soll er dabei Marken setzen. Es soll also eine „U-Form mit Markierungen“ gebildet werden.
# Karol soll vier Ziegel in einer Reihe nebeneinander legen.
|width=20px|
|width=300px |
|}

[[Lösungen Abschnitt Erste Programme|Lösungsvorschlag]]

== Selbstdefinierte Methoden ==

{|
|width=800px|
Die Fähigkeiten von Karol können durch neue, zusätzliche Methoden erweitert werden. Diese selbstdefinierten Anweisungen müssen vorher vom Programmierer festgelegt werden.
Neue Methoden beginnen stets mit dem Wort '''Anweisung''' und dann mit dem '''Bezeichner''' der Methode. Es folgt eine Sequenz von Anweisungen, die beim Aufruf der Methode abgearbeitet werden. Die Festlegung der Methode endet mit dem Schlüsselwort '''*Anweisung'''.
 

'''Beispiel 1:''' Neue Methode '''Umdrehen'''
 
<pre>
Anweisung Umdrehen
LinksDrehen
LinksDrehen
*Anweisung
</pre>
 
'''Aufgabe:''' Karol soll einen Schritt rückwärts gehen.
''(Die Lösung greift nun auf die Anweisung '''Umdrehen''' zu.)''
 
<pre>
Anweisung Umdrehen
LinksDrehen
LinksDrehen
*Anweisung

Programm
Umdrehen
Schritt
Umdrehen
*Programm
</pre>
 
'''Aufgaben'''
# Bringe Karol mittels einer selbstdefinierten Anweisung bei, einen Riesenschritt auf einmal zu vollführen, der so groß wie drei normale Schritte ist.
# Bringe Karol den Rösslsprung bei, wie ihn die Springerfigur beim Schach ausführt. Erstelle ein Programm, so dass Karol mehrere Rösslsprünge ausführt und nach jedem Sprung eine Marke setzt. 
[[Bild:Screenshot_Roesselsprung.JPG]]
 
[[Lösungsvorschlag Selbstdefinierte Methoden|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Wiederholung mit fester Anzahl ==
{|
|width=800px|
'''Aufgabe:'''
Karol soll vier Ziegel in einer Reihe hintereinander legen. 
Erste Lösung durch sequentielles Anschreiben der Anweisungen:
<pre>
Hinlegen
Schritt
Hinlegen
Schritt
Hinlegen
Schritt
Hinlegen
Schritt
</pre>
Bei größerer Zahl von Wiederholungen erweist sich das Ganze als ungünstig.
'''Bessere Lösung:''' Wiederholung mit fester Anzahl

'''Wiederholung mit fester Anzahl''' 
Die Anweisungen im Wiederholungsteil werden nacheinander mehrfach ausgeführt (entsprechend der angegebenen Anzahl). 
Sprache Karol:
<pre>
wiederhole n mal
Anweisungen
*wiederhole
</pre>

Die günstigere Lösung für unsere Aufgabe sieht dann wie folgt aus:
<pre>
wiederhole 4 mal
hinlegen
schritt
*wiederhole
</pre>

'''Aufgabe 1:''' Karol soll mit Ziegeln ein Quadrat auslegen.

[[Bild:Screenshot_Quadrat.JPG]]

'''Geschachtelte Wiederholung''' 

'''Beispiel:''' Karol soll einen Quadratrand auslegen.

[[Bild:Screenshot_Quadratrand.JPG]]

'''Lösung'''

<pre>
wiederhole 4 mal
wiederhole 3 mal
Hinlegen
Schritt
*wiederhole
LinksDrehen
*wiederhole
</pre>
Der Quadratrand besteht aus vier Seiten (äußere Schleife). Jede Seite besteht wiederum aus drei Ziegeln (innere Schleife).

 
'''Aufgabe 2''' 
Karol soll eine Welt [8x8] vollständig mit Kacheln auslegen. Schreibe dazu ein
Programm, das Anweisungen für das Umdrehen und geschachtelte Wiederholungen
enthält. Überlege dir zuerst eine Strategie zur Lösung der Aufgabe, bei der du sie in Teilprobleme zerlegst.

[[Lösungsvorschlag Wiederholung mit fester Anzahl|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Wiederholung mit Anfangsbedingung ==

{|
|width=800px|
Bestimmte Problemstellungen lassen sich mit den bisherigen Methoden und Kontrollstrukturen
nicht zufrieden stellend bearbeiten. Die Lösung der Aufgabe „Gehe bis zur nächsten
Wand“ hängt von der Startposition Karols ab. Um unabhängig von der Ausgangsstellung zu
sein, muss Karol eine Methode kennen, die eine Anfrage, ob er noch weitergehen kann, mit
WAHR oder FALSCH beantwortet. Der Aufruf derartiger Methoden wird mit „Bedingung“
umschrieben. 

{{Kasten_blass|Karol hat auch Methoden, mit denen er auf eine Anfrage mit WAHR oder
FALSCH antwortet. Der Aufruf einer Methode dieser Art heißt '''Bedingung'''.}}

Von Karol vorgegebene Bedingungen sind: '''IstWand(), NichtIstWand(), IstZiegel(), NichtIstZiegel(),'''
'''IstMarke(), NichtIstMarke(), IstSüden(), IstNorden(), IstOsten(), IstWesten().'''

'''Aufgabe:''' Karol soll, solange er nicht an eine Wand anstößt, vorwärts gehen.

Er muss den Vorgang „Schritt“ solange wiederholen, bis er auf die Frage '''NichtIstWand''' mit
WAHR antwortet, da man die Anzahl der möglichen Schritte nicht im Voraus kennt. Sie ist
von der Ausgangsposition Karols abhängig.

'''Lösung:''' Wiederholung mit Anfangsbedingung

Die Anweisungen im Wiederholungsteil werden so oft wiederholt, solange
die Bedingung WAHR ergibt. Die Überprüfung der Bedingung erfolgt am
Anfang jeder Wiederholung.

Sprache Karol:
<pre>
wiederhole solange Bedingung
Anweisungen
*wiederhole
</pre>

'''Aufgabe 1:''' 
Karol soll in einer rechteckigen Welt von einer Ecke aus genau einmal um die Welt
herumlaufen und seine Strecke dabei mit Ziegeln belegen.

'''Aufgabe 2:''' 
Wie Aufgabe 1. Aber nun soll Karol an einem beliebigen Ort an der Wand starten.

[[Lösungsvorschlag Wiederholung mit Anfangsbedingung|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Zweiseitige bedingte Anweisung ==

{|
|width=800px|
Das Programm für die Lösung der Aufgabe ''"Karol soll von einem beliebigen Punkt an der Wand
aus einmal an der Wand entlang genau eine Runde laufen und dabei seine Ziegel hinlegen"'', lässt
sich dadurch vereinfachen, dass wir ihn bei jedem Schritt entscheiden lassen, was er als nächstes
tut: 
Solange er nicht an der Wand anstößt macht er jeweils einen Schritt. Stößt er an der Wand an
dreht er sich nach links. Der Vorteil ist, dass wir nicht mehr anzugeben brauchen, wie oft Karol
sich drehen muss, bis er seine Runde absolviert hat.

'''Bedingte Anweisung (zweiseitig):''' 
In Abhängigkeit davon, ob die Bedingung erfüllt wird oder nicht, werden die
Anweisungen1 bzw. die Anweisungen2 ausgeführt.

Sprache Karol:
<pre>
wenn Bedingung dann
Anweisungen1
sonst
Anweisungen2
*wenn
</pre>

'''Aufgabe 1:''' 
Das Beispielprogramm "Karol soll von einem beliebigen Punkt an der Wand aus einmal an der
Wand entlang genau eine Runde laufen und dabei seine Ziegel hinlegen" soll in ein Programm
mit einer bedingten Anweisung umgewandelt und dadurch vereinfacht werden.

'''Aufgabe 2:''' 
Wie Aufgabe 1, nur dass Karol von einem beliebigen Feld in der Welt startet und auch wieder an
seinen Ausgangspunkt zurückkehrt. 
a) Lösung ohne Verwendung der bedingten Anweisung. 
b) Lösung unter Verwendung der bedingten Anweisung.

'''Aufgabe 3:''' 
a) Karol hat eine Reihe von Ziegelsteinen vor sich. Dort wo ein Stein liegt, soll er ihn wegnehmen, dort wo keiner liegt, soll er einen Stein hinlegen. 
b) Nun soll Karol das Ganze 4 mal wiederholen, wobei er jeweils an der Wand entlang zurückgehen und zu seinem Ausgangspunkt zurückkehren soll.

|width=20px|
|width=300px |
|}

[[Lösungsvorschlag Zweiseitige bedingte Anweisung|Lösungsvorschlag]]

== Einseitige bedingte Anweisung ==

{|
|width=800px|
'''Aufgabe:''' 
Karol soll eine lückenhafte Ziegelreihe auffüllen, bis er an der Wand
ankommt. Vor jedem Schritt muss er nur dann einen Ziegel legen, wenn
vor ihm keiner liegt. Falls bereits ein Ziegel vor ihm liegt, geschieht nichts.

'''Bedingte Anweisung (einseitig):'''
Wenn die Bedingung WAHR ergibt, werden die Anweisungen ausgeführt.

Sprache Karol:
<pre>
wenn Bedingung dann
Anweisungen
*wenn
</pre>

Lösung der obigen Aufgabe: 

<pre>
wiederhole solange NichtIstWand
wenn NichtIstZiegel dann
Hinlegen
*wenn
Schritt
*wiederhole
</pre>

'''Aufgabe:''' 
In einer Welt (9x8) sind 15 Marken beliebig verteilt. Karol soll von einem beliebigen
Startpunkt ausgehend, alle Marken mit Ziegelsteinen belegen und dabei keine Marke
vergessen. Teste das Programm mit verschiedenen Startpunkten von Karol.

[[Lösungsvorschlag Einseitige bedingte Anweisung|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

Programmieren lernen mit Robot Karol

2013-09-16T20:27:38Z

PT59kripke: /* Objekte */

Programmieren lernen mit Robot Karol

2013-09-16T20:26:56Z

PT59kripke: /* Objekte */

== Das Programm ==

{|
|width=800px|
Robot Karol ist eine Programmierumgebung mit einer Programmiersprache, die zum Erlernen des Programmierens und zur Einführung in die Algorithmik in der Schule gedacht ist. Das Programm ist Freeware und kann über den Link [http://www.schule.bayern.de/karol/download.htm Karol] heruntergeladen werden.
|width=20px|
|width=300px |
|}

===Die Oberfläche===

{|
|width=800px|
Die Programmoberfläche von Karol ist zweigeteilt: Auf der linken Seiten befindet sich der sogenannte Editor, in dem die Programme geschrieben werden. Auf der rechten Seite ist Karols Welt, in der das verfasste Programm ausgeführt werden kann.
|width=20px|
|width=300px |
|}

=== Objekte ===
{|
|width=800px|
In Karos Welt gibt es einige Objekte die von Karo verteilt und wieder eingesammelt werden können.

* Ziegel

:Karol kann Ziegel vor sich hinlegen. Sollte vor ihm bereits ein Ziegel liegen, wird der nächste Ziegel auf den anderen drauf gelegt. 
:Wenn Karol vor einem Ziegel steht und einen Schritt macht, steigt er auf den Ziegel.Allerdings kann er nicht über 2 Ziegel auf einmal steigen. 
:Das heißt um auf einen 2er Ziegelturm zu kommen, muss er über einen davorliegenden einzelnen Ziegelstein "klettern". 

* Marke

:Marken werden direkt auf das Feld unter Karol gelegt. Sie dienen zur Orientierung und haben keinen Einfluss auf Karols 
:Bewegungsmöglichkeiten; er kann einfach darüber laufen. Im Gegensatz zu Ziegeln können nicht mehrer Marken übereinander gestapelt werden. 

*Quader

:Quader versperren Karol den Weg. Er kann nicht über sie gehen. Außerdem lassen sie sich nicht stapeln.

[[Datei:ObjekteKarol.png]]
|width=20px|
|width=300px |
|}

=== Die Bewegungmöglichkeiten von Karol ===

{|
|width=800px|
Die Bewegungsmöglichkeiten von Karol sind recht übersichtlich. Mit den angegebenen Anweisungen kann das entsprechende Verhalten gesteuert werden.
|width=20px|
|width=300px |
|}

{| class="wikitable "
|- style="background: #DDFFDD;"
! Verhalten
! Anweisung
|-
| ein Schritt vorwärts
| '''Schritt'''
|-
| eine Vierteldrehung nach links
| '''LinksDrehen'''
|-
| eine Vierteldrehung nach rechts
| '''RechtsDrehen'''
|-
| einen Ziegel vor sich hinlegen
| '''Hinlegen'''
|-
| einen Ziegel vor sich entfernen
| '''Aufheben'''
|-
| eine gelbe Marke unter sich legen
| '''MarkeSetzen'''
|-
| eine gelbe Marke unter sich entfernen
| '''MarkeLöschen'''
|}

=== Karols Welt ===
{|
|width=800px|
Auf der rechten Seite der Karoloberfläche befindet sich Karols Welt. Durch Aufruf von ''Welt - Neue Welt'' kann die gewünschte Ausdehnung der neuen Welt festgelegt werden. Wenn die Ausgangsposition vom Standardstartpunkt (1,1) abweicht oder Hindernisse zur von Karol zu lösenden Welt gehören, dann empfiehlt es sich, die Welt über ''Welt - Welt speichern'' mit der Endung '''.kdw''' abzuspeichern.
[[Datei:KarolsWelt.JPG]]
|width=20px|
|width=300px |
|}

== Erste Programme ==

{|
|width=800px|
Das Programm "Robot Karol" ermöglicht es uns, dem Roboter, der sich in seiner Welt bewegen und Aufgaben erfüllen kann, Anweisungen zu geben.
{{Kasten_blass|Durch eine '''Anweisung''' (z.B. "Schritt") sendet man eine Botschaft an ein '''Objekt''' (z.B. Karol), das darauf mit der zugehörigen '''Methode''' reagiert (z.B. Schritt() ). }}

|width=20px|
|width=300px |
|}

'''Aufgabe''' 
Karol soll eine U-Form abschreiten 

'''Lösung'''

{|class="wikitable"
|-style="background:#DDFFDD;"
! umgangssprachlich formuliert
! Karolprogramm
|-
|
* 2 mal vorwärts
* Linksum
* 2 mal vorwärts
* Linksum
* 2 mal vorwärts
|
Schritt 
Schritt 
LinksDrehen 
Schritt 
Schritt 
LinksDrehen 
Schritt 
Schritt 
|}

{|
|width=800px|
Eine solche Folge von Anweisungen bezeichnet man als '''Algorithmus'''.
{{Kasten_blass|
Ein '''Algorithmus''' ist eine endliche Folge aus eindeutigen und ausführbaren Anweisungen zur Lösung eines allgemeinen Problems. 
Ein '''Programm''' ist ein Algorithmus, der in einer formalisierten Sprache abgefasst ist und maschinell ausgeführt werden kann.}}
|width=20px|
|width=300px |
|}
 
'''Aufgaben:'''
{|
|width=800px|
# Karol soll ein Rechteck ablaufen und am Ende wieder in der Ausgangsposition stehen.
# Damit man besser erkennt, ob Karol auch ein „U“ durchläuft, soll er dabei Marken setzen. Es soll also eine „U-Form mit Markierungen“ gebildet werden.
# Karol soll vier Ziegel in einer Reihe nebeneinander legen.
|width=20px|
|width=300px |
|}

[[Lösungen Abschnitt Erste Programme|Lösungsvorschlag]]

== Selbstdefinierte Methoden ==

{|
|width=800px|
Die Fähigkeiten von Karol können durch neue, zusätzliche Methoden erweitert werden. Diese selbstdefinierten Anweisungen müssen vorher vom Programmierer festgelegt werden.
Neue Methoden beginnen stets mit dem Wort '''Anweisung''' und dann mit dem '''Bezeichner''' der Methode. Es folgt eine Sequenz von Anweisungen, die beim Aufruf der Methode abgearbeitet werden. Die Festlegung der Methode endet mit dem Schlüsselwort '''*Anweisung'''.
 

'''Beispiel 1:''' Neue Methode '''Umdrehen'''
 
<pre>
Anweisung Umdrehen
LinksDrehen
LinksDrehen
*Anweisung
</pre>
 
'''Aufgabe:''' Karol soll einen Schritt rückwärts gehen.
''(Die Lösung greift nun auf die Anweisung '''Umdrehen''' zu.)''
 
<pre>
Anweisung Umdrehen
LinksDrehen
LinksDrehen
*Anweisung

Programm
Umdrehen
Schritt
Umdrehen
*Programm
</pre>
 
'''Aufgaben'''
# Bringe Karol mittels einer selbstdefinierten Anweisung bei, einen Riesenschritt auf einmal zu vollführen, der so groß wie drei normale Schritte ist.
# Bringe Karol den Rösslsprung bei, wie ihn die Springerfigur beim Schach ausführt. Erstelle ein Programm, so dass Karol mehrere Rösslsprünge ausführt und nach jedem Sprung eine Marke setzt. 
[[Bild:Screenshot_Roesselsprung.JPG]]
 
[[Lösungsvorschlag Selbstdefinierte Methoden|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Wiederholung mit fester Anzahl ==
{|
|width=800px|
'''Aufgabe:'''
Karol soll vier Ziegel in einer Reihe hintereinander legen. 
Erste Lösung durch sequentielles Anschreiben der Anweisungen:
<pre>
Hinlegen
Schritt
Hinlegen
Schritt
Hinlegen
Schritt
Hinlegen
Schritt
</pre>
Bei größerer Zahl von Wiederholungen erweist sich das Ganze als ungünstig.
'''Bessere Lösung:''' Wiederholung mit fester Anzahl

'''Wiederholung mit fester Anzahl''' 
Die Anweisungen im Wiederholungsteil werden nacheinander mehrfach ausgeführt (entsprechend der angegebenen Anzahl). 
Sprache Karol:
<pre>
wiederhole n mal
Anweisungen
*wiederhole
</pre>

Die günstigere Lösung für unsere Aufgabe sieht dann wie folgt aus:
<pre>
wiederhole 4 mal
hinlegen
schritt
*wiederhole
</pre>

'''Aufgabe 1:''' Karol soll mit Ziegeln ein Quadrat auslegen.

[[Bild:Screenshot_Quadrat.JPG]]

'''Geschachtelte Wiederholung''' 

'''Beispiel:''' Karol soll einen Quadratrand auslegen.

[[Bild:Screenshot_Quadratrand.JPG]]

'''Lösung'''

<pre>
wiederhole 4 mal
wiederhole 3 mal
Hinlegen
Schritt
*wiederhole
LinksDrehen
*wiederhole
</pre>
Der Quadratrand besteht aus vier Seiten (äußere Schleife). Jede Seite besteht wiederum aus drei Ziegeln (innere Schleife).

 
'''Aufgabe 2''' 
Karol soll eine Welt [8x8] vollständig mit Kacheln auslegen. Schreibe dazu ein
Programm, das Anweisungen für das Umdrehen und geschachtelte Wiederholungen
enthält. Überlege dir zuerst eine Strategie zur Lösung der Aufgabe, bei der du sie in Teilprobleme zerlegst.

[[Lösungsvorschlag Wiederholung mit fester Anzahl|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Wiederholung mit Anfangsbedingung ==

{|
|width=800px|
Bestimmte Problemstellungen lassen sich mit den bisherigen Methoden und Kontrollstrukturen
nicht zufrieden stellend bearbeiten. Die Lösung der Aufgabe „Gehe bis zur nächsten
Wand“ hängt von der Startposition Karols ab. Um unabhängig von der Ausgangsstellung zu
sein, muss Karol eine Methode kennen, die eine Anfrage, ob er noch weitergehen kann, mit
WAHR oder FALSCH beantwortet. Der Aufruf derartiger Methoden wird mit „Bedingung“
umschrieben. 

{{Kasten_blass|Karol hat auch Methoden, mit denen er auf eine Anfrage mit WAHR oder
FALSCH antwortet. Der Aufruf einer Methode dieser Art heißt '''Bedingung'''.}}

Von Karol vorgegebene Bedingungen sind: '''IstWand(), NichtIstWand(), IstZiegel(), NichtIstZiegel(),'''
'''IstMarke(), NichtIstMarke(), IstSüden(), IstNorden(), IstOsten(), IstWesten().'''

'''Aufgabe:''' Karol soll, solange er nicht an eine Wand anstößt, vorwärts gehen.

Er muss den Vorgang „Schritt“ solange wiederholen, bis er auf die Frage '''NichtIstWand''' mit
WAHR antwortet, da man die Anzahl der möglichen Schritte nicht im Voraus kennt. Sie ist
von der Ausgangsposition Karols abhängig.

'''Lösung:''' Wiederholung mit Anfangsbedingung

Die Anweisungen im Wiederholungsteil werden so oft wiederholt, solange
die Bedingung WAHR ergibt. Die Überprüfung der Bedingung erfolgt am
Anfang jeder Wiederholung.

Sprache Karol:
<pre>
wiederhole solange Bedingung
Anweisungen
*wiederhole
</pre>

'''Aufgabe 1:''' 
Karol soll in einer rechteckigen Welt von einer Ecke aus genau einmal um die Welt
herumlaufen und seine Strecke dabei mit Ziegeln belegen.

'''Aufgabe 2:''' 
Wie Aufgabe 1. Aber nun soll Karol an einem beliebigen Ort an der Wand starten.

[[Lösungsvorschlag Wiederholung mit Anfangsbedingung|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Zweiseitige bedingte Anweisung ==

{|
|width=800px|
Das Programm für die Lösung der Aufgabe ''"Karol soll von einem beliebigen Punkt an der Wand
aus einmal an der Wand entlang genau eine Runde laufen und dabei seine Ziegel hinlegen"'', lässt
sich dadurch vereinfachen, dass wir ihn bei jedem Schritt entscheiden lassen, was er als nächstes
tut: 
Solange er nicht an der Wand anstößt macht er jeweils einen Schritt. Stößt er an der Wand an
dreht er sich nach links. Der Vorteil ist, dass wir nicht mehr anzugeben brauchen, wie oft Karol
sich drehen muss, bis er seine Runde absolviert hat.

'''Bedingte Anweisung (zweiseitig):''' 
In Abhängigkeit davon, ob die Bedingung erfüllt wird oder nicht, werden die
Anweisungen1 bzw. die Anweisungen2 ausgeführt.

Sprache Karol:
<pre>
wenn Bedingung dann
Anweisungen1
sonst
Anweisungen2
*wenn
</pre>

'''Aufgabe 1:''' 
Das Beispielprogramm "Karol soll von einem beliebigen Punkt an der Wand aus einmal an der
Wand entlang genau eine Runde laufen und dabei seine Ziegel hinlegen" soll in ein Programm
mit einer bedingten Anweisung umgewandelt und dadurch vereinfacht werden.

'''Aufgabe 2:''' 
Wie Aufgabe 1, nur dass Karol von einem beliebigen Feld in der Welt startet und auch wieder an
seinen Ausgangspunkt zurückkehrt. 
a) Lösung ohne Verwendung der bedingten Anweisung. 
b) Lösung unter Verwendung der bedingten Anweisung.

'''Aufgabe 3:''' 
a) Karol hat eine Reihe von Ziegelsteinen vor sich. Dort wo ein Stein liegt, soll er ihn wegnehmen, dort wo keiner liegt, soll er einen Stein hinlegen. 
b) Nun soll Karol das Ganze 4 mal wiederholen, wobei er jeweils an der Wand entlang zurückgehen und zu seinem Ausgangspunkt zurückkehren soll.

|width=20px|
|width=300px |
|}

[[Lösungsvorschlag Zweiseitige bedingte Anweisung|Lösungsvorschlag]]

== Einseitige bedingte Anweisung ==

{|
|width=800px|
'''Aufgabe:''' 
Karol soll eine lückenhafte Ziegelreihe auffüllen, bis er an der Wand
ankommt. Vor jedem Schritt muss er nur dann einen Ziegel legen, wenn
vor ihm keiner liegt. Falls bereits ein Ziegel vor ihm liegt, geschieht nichts.

'''Bedingte Anweisung (einseitig):'''
Wenn die Bedingung WAHR ergibt, werden die Anweisungen ausgeführt.

Sprache Karol:
<pre>
wenn Bedingung dann
Anweisungen
*wenn
</pre>

Lösung der obigen Aufgabe: 

<pre>
wiederhole solange NichtIstWand
wenn NichtIstZiegel dann
Hinlegen
*wenn
Schritt
*wiederhole
</pre>

'''Aufgabe:''' 
In einer Welt (9x8) sind 15 Marken beliebig verteilt. Karol soll von einem beliebigen
Startpunkt ausgehend, alle Marken mit Ziegelsteinen belegen und dabei keine Marke
vergessen. Teste das Programm mit verschiedenen Startpunkten von Karol.

[[Lösungsvorschlag Einseitige bedingte Anweisung|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

Programmieren lernen mit Robot Karol

2013-09-16T20:26:36Z

PT59kripke: "Objekte" angelegt

== Das Programm ==

{|
|width=800px|
Robot Karol ist eine Programmierumgebung mit einer Programmiersprache, die zum Erlernen des Programmierens und zur Einführung in die Algorithmik in der Schule gedacht ist. Das Programm ist Freeware und kann über den Link [http://www.schule.bayern.de/karol/download.htm Karol] heruntergeladen werden.
|width=20px|
|width=300px |
|}

===Die Oberfläche===

{|
|width=800px|
Die Programmoberfläche von Karol ist zweigeteilt: Auf der linken Seiten befindet sich der sogenannte Editor, in dem die Programme geschrieben werden. Auf der rechten Seite ist Karols Welt, in der das verfasste Programm ausgeführt werden kann.
|width=20px|
|width=300px |
|}

=== Objekte ===
{|
|width=800px|
In Karos Welt gibt es einige Objekte die von Karo verteilt und wieder eingesammelt werden können.

* Ziegel

:Karol kann Ziegel vor sich hinlegen. Sollte vor ihm bereits ein Ziegel liegen, wird der nächste Ziegel auf den anderen drauf gelegt. 
:Wenn Karol vor einem Ziegel steht und einen Schritt macht, steigt er auf den Ziegel.Allerdings kann er nicht über 2 Ziegel auf einmal steigen. 
:Das heißt um auf einen 2er Ziegelturm zu kommen, muss er über einen davorliegenden einzelnen Ziegelstein "klettern". 

* Marke

:Marken werden direkt auf das Feld unter Karol gelegt. Sie dienen zur Orientierung und haben keinen Einfluss auf Karols 
:Bewegungsmöglichkeiten; er kann einfach darüber laufen. Im Gegensatz zu Ziegeln können nicht mehrer Marken übereinander gestapelt werden. 

*Quader

:Quader versperren Karol den Weg. Er kann nicht über sie gehen. Außerdem lassen sie sich nicht stapeln

[[Datei:ObjekteKarol.png]]
|width=20px|
|width=300px |
|}

=== Die Bewegungmöglichkeiten von Karol ===

{|
|width=800px|
Die Bewegungsmöglichkeiten von Karol sind recht übersichtlich. Mit den angegebenen Anweisungen kann das entsprechende Verhalten gesteuert werden.
|width=20px|
|width=300px |
|}

{| class="wikitable "
|- style="background: #DDFFDD;"
! Verhalten
! Anweisung
|-
| ein Schritt vorwärts
| '''Schritt'''
|-
| eine Vierteldrehung nach links
| '''LinksDrehen'''
|-
| eine Vierteldrehung nach rechts
| '''RechtsDrehen'''
|-
| einen Ziegel vor sich hinlegen
| '''Hinlegen'''
|-
| einen Ziegel vor sich entfernen
| '''Aufheben'''
|-
| eine gelbe Marke unter sich legen
| '''MarkeSetzen'''
|-
| eine gelbe Marke unter sich entfernen
| '''MarkeLöschen'''
|}

=== Karols Welt ===
{|
|width=800px|
Auf der rechten Seite der Karoloberfläche befindet sich Karols Welt. Durch Aufruf von ''Welt - Neue Welt'' kann die gewünschte Ausdehnung der neuen Welt festgelegt werden. Wenn die Ausgangsposition vom Standardstartpunkt (1,1) abweicht oder Hindernisse zur von Karol zu lösenden Welt gehören, dann empfiehlt es sich, die Welt über ''Welt - Welt speichern'' mit der Endung '''.kdw''' abzuspeichern.
[[Datei:KarolsWelt.JPG]]
|width=20px|
|width=300px |
|}

== Erste Programme ==

{|
|width=800px|
Das Programm "Robot Karol" ermöglicht es uns, dem Roboter, der sich in seiner Welt bewegen und Aufgaben erfüllen kann, Anweisungen zu geben.
{{Kasten_blass|Durch eine '''Anweisung''' (z.B. "Schritt") sendet man eine Botschaft an ein '''Objekt''' (z.B. Karol), das darauf mit der zugehörigen '''Methode''' reagiert (z.B. Schritt() ). }}

|width=20px|
|width=300px |
|}

'''Aufgabe''' 
Karol soll eine U-Form abschreiten 

'''Lösung'''

{|class="wikitable"
|-style="background:#DDFFDD;"
! umgangssprachlich formuliert
! Karolprogramm
|-
|
* 2 mal vorwärts
* Linksum
* 2 mal vorwärts
* Linksum
* 2 mal vorwärts
|
Schritt 
Schritt 
LinksDrehen 
Schritt 
Schritt 
LinksDrehen 
Schritt 
Schritt 
|}

{|
|width=800px|
Eine solche Folge von Anweisungen bezeichnet man als '''Algorithmus'''.
{{Kasten_blass|
Ein '''Algorithmus''' ist eine endliche Folge aus eindeutigen und ausführbaren Anweisungen zur Lösung eines allgemeinen Problems. 
Ein '''Programm''' ist ein Algorithmus, der in einer formalisierten Sprache abgefasst ist und maschinell ausgeführt werden kann.}}
|width=20px|
|width=300px |
|}
 
'''Aufgaben:'''
{|
|width=800px|
# Karol soll ein Rechteck ablaufen und am Ende wieder in der Ausgangsposition stehen.
# Damit man besser erkennt, ob Karol auch ein „U“ durchläuft, soll er dabei Marken setzen. Es soll also eine „U-Form mit Markierungen“ gebildet werden.
# Karol soll vier Ziegel in einer Reihe nebeneinander legen.
|width=20px|
|width=300px |
|}

[[Lösungen Abschnitt Erste Programme|Lösungsvorschlag]]

== Selbstdefinierte Methoden ==

{|
|width=800px|
Die Fähigkeiten von Karol können durch neue, zusätzliche Methoden erweitert werden. Diese selbstdefinierten Anweisungen müssen vorher vom Programmierer festgelegt werden.
Neue Methoden beginnen stets mit dem Wort '''Anweisung''' und dann mit dem '''Bezeichner''' der Methode. Es folgt eine Sequenz von Anweisungen, die beim Aufruf der Methode abgearbeitet werden. Die Festlegung der Methode endet mit dem Schlüsselwort '''*Anweisung'''.
 

'''Beispiel 1:''' Neue Methode '''Umdrehen'''
 
<pre>
Anweisung Umdrehen
LinksDrehen
LinksDrehen
*Anweisung
</pre>
 
'''Aufgabe:''' Karol soll einen Schritt rückwärts gehen.
''(Die Lösung greift nun auf die Anweisung '''Umdrehen''' zu.)''
 
<pre>
Anweisung Umdrehen
LinksDrehen
LinksDrehen
*Anweisung

Programm
Umdrehen
Schritt
Umdrehen
*Programm
</pre>
 
'''Aufgaben'''
# Bringe Karol mittels einer selbstdefinierten Anweisung bei, einen Riesenschritt auf einmal zu vollführen, der so groß wie drei normale Schritte ist.
# Bringe Karol den Rösslsprung bei, wie ihn die Springerfigur beim Schach ausführt. Erstelle ein Programm, so dass Karol mehrere Rösslsprünge ausführt und nach jedem Sprung eine Marke setzt. 
[[Bild:Screenshot_Roesselsprung.JPG]]
 
[[Lösungsvorschlag Selbstdefinierte Methoden|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Wiederholung mit fester Anzahl ==
{|
|width=800px|
'''Aufgabe:'''
Karol soll vier Ziegel in einer Reihe hintereinander legen. 
Erste Lösung durch sequentielles Anschreiben der Anweisungen:
<pre>
Hinlegen
Schritt
Hinlegen
Schritt
Hinlegen
Schritt
Hinlegen
Schritt
</pre>
Bei größerer Zahl von Wiederholungen erweist sich das Ganze als ungünstig.
'''Bessere Lösung:''' Wiederholung mit fester Anzahl

'''Wiederholung mit fester Anzahl''' 
Die Anweisungen im Wiederholungsteil werden nacheinander mehrfach ausgeführt (entsprechend der angegebenen Anzahl). 
Sprache Karol:
<pre>
wiederhole n mal
Anweisungen
*wiederhole
</pre>

Die günstigere Lösung für unsere Aufgabe sieht dann wie folgt aus:
<pre>
wiederhole 4 mal
hinlegen
schritt
*wiederhole
</pre>

'''Aufgabe 1:''' Karol soll mit Ziegeln ein Quadrat auslegen.

[[Bild:Screenshot_Quadrat.JPG]]

'''Geschachtelte Wiederholung''' 

'''Beispiel:''' Karol soll einen Quadratrand auslegen.

[[Bild:Screenshot_Quadratrand.JPG]]

'''Lösung'''

<pre>
wiederhole 4 mal
wiederhole 3 mal
Hinlegen
Schritt
*wiederhole
LinksDrehen
*wiederhole
</pre>
Der Quadratrand besteht aus vier Seiten (äußere Schleife). Jede Seite besteht wiederum aus drei Ziegeln (innere Schleife).

 
'''Aufgabe 2''' 
Karol soll eine Welt [8x8] vollständig mit Kacheln auslegen. Schreibe dazu ein
Programm, das Anweisungen für das Umdrehen und geschachtelte Wiederholungen
enthält. Überlege dir zuerst eine Strategie zur Lösung der Aufgabe, bei der du sie in Teilprobleme zerlegst.

[[Lösungsvorschlag Wiederholung mit fester Anzahl|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Wiederholung mit Anfangsbedingung ==

{|
|width=800px|
Bestimmte Problemstellungen lassen sich mit den bisherigen Methoden und Kontrollstrukturen
nicht zufrieden stellend bearbeiten. Die Lösung der Aufgabe „Gehe bis zur nächsten
Wand“ hängt von der Startposition Karols ab. Um unabhängig von der Ausgangsstellung zu
sein, muss Karol eine Methode kennen, die eine Anfrage, ob er noch weitergehen kann, mit
WAHR oder FALSCH beantwortet. Der Aufruf derartiger Methoden wird mit „Bedingung“
umschrieben. 

{{Kasten_blass|Karol hat auch Methoden, mit denen er auf eine Anfrage mit WAHR oder
FALSCH antwortet. Der Aufruf einer Methode dieser Art heißt '''Bedingung'''.}}

Von Karol vorgegebene Bedingungen sind: '''IstWand(), NichtIstWand(), IstZiegel(), NichtIstZiegel(),'''
'''IstMarke(), NichtIstMarke(), IstSüden(), IstNorden(), IstOsten(), IstWesten().'''

'''Aufgabe:''' Karol soll, solange er nicht an eine Wand anstößt, vorwärts gehen.

Er muss den Vorgang „Schritt“ solange wiederholen, bis er auf die Frage '''NichtIstWand''' mit
WAHR antwortet, da man die Anzahl der möglichen Schritte nicht im Voraus kennt. Sie ist
von der Ausgangsposition Karols abhängig.

'''Lösung:''' Wiederholung mit Anfangsbedingung

Die Anweisungen im Wiederholungsteil werden so oft wiederholt, solange
die Bedingung WAHR ergibt. Die Überprüfung der Bedingung erfolgt am
Anfang jeder Wiederholung.

Sprache Karol:
<pre>
wiederhole solange Bedingung
Anweisungen
*wiederhole
</pre>

'''Aufgabe 1:''' 
Karol soll in einer rechteckigen Welt von einer Ecke aus genau einmal um die Welt
herumlaufen und seine Strecke dabei mit Ziegeln belegen.

'''Aufgabe 2:''' 
Wie Aufgabe 1. Aber nun soll Karol an einem beliebigen Ort an der Wand starten.

[[Lösungsvorschlag Wiederholung mit Anfangsbedingung|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

== Zweiseitige bedingte Anweisung ==

{|
|width=800px|
Das Programm für die Lösung der Aufgabe ''"Karol soll von einem beliebigen Punkt an der Wand
aus einmal an der Wand entlang genau eine Runde laufen und dabei seine Ziegel hinlegen"'', lässt
sich dadurch vereinfachen, dass wir ihn bei jedem Schritt entscheiden lassen, was er als nächstes
tut: 
Solange er nicht an der Wand anstößt macht er jeweils einen Schritt. Stößt er an der Wand an
dreht er sich nach links. Der Vorteil ist, dass wir nicht mehr anzugeben brauchen, wie oft Karol
sich drehen muss, bis er seine Runde absolviert hat.

'''Bedingte Anweisung (zweiseitig):''' 
In Abhängigkeit davon, ob die Bedingung erfüllt wird oder nicht, werden die
Anweisungen1 bzw. die Anweisungen2 ausgeführt.

Sprache Karol:
<pre>
wenn Bedingung dann
Anweisungen1
sonst
Anweisungen2
*wenn
</pre>

'''Aufgabe 1:''' 
Das Beispielprogramm "Karol soll von einem beliebigen Punkt an der Wand aus einmal an der
Wand entlang genau eine Runde laufen und dabei seine Ziegel hinlegen" soll in ein Programm
mit einer bedingten Anweisung umgewandelt und dadurch vereinfacht werden.

'''Aufgabe 2:''' 
Wie Aufgabe 1, nur dass Karol von einem beliebigen Feld in der Welt startet und auch wieder an
seinen Ausgangspunkt zurückkehrt. 
a) Lösung ohne Verwendung der bedingten Anweisung. 
b) Lösung unter Verwendung der bedingten Anweisung.

'''Aufgabe 3:''' 
a) Karol hat eine Reihe von Ziegelsteinen vor sich. Dort wo ein Stein liegt, soll er ihn wegnehmen, dort wo keiner liegt, soll er einen Stein hinlegen. 
b) Nun soll Karol das Ganze 4 mal wiederholen, wobei er jeweils an der Wand entlang zurückgehen und zu seinem Ausgangspunkt zurückkehren soll.

|width=20px|
|width=300px |
|}

[[Lösungsvorschlag Zweiseitige bedingte Anweisung|Lösungsvorschlag]]

== Einseitige bedingte Anweisung ==

{|
|width=800px|
'''Aufgabe:''' 
Karol soll eine lückenhafte Ziegelreihe auffüllen, bis er an der Wand
ankommt. Vor jedem Schritt muss er nur dann einen Ziegel legen, wenn
vor ihm keiner liegt. Falls bereits ein Ziegel vor ihm liegt, geschieht nichts.

'''Bedingte Anweisung (einseitig):'''
Wenn die Bedingung WAHR ergibt, werden die Anweisungen ausgeführt.

Sprache Karol:
<pre>
wenn Bedingung dann
Anweisungen
*wenn
</pre>

Lösung der obigen Aufgabe: 

<pre>
wiederhole solange NichtIstWand
wenn NichtIstZiegel dann
Hinlegen
*wenn
Schritt
*wiederhole
</pre>

'''Aufgabe:''' 
In einer Welt (9x8) sind 15 Marken beliebig verteilt. Karol soll von einem beliebigen
Startpunkt ausgehend, alle Marken mit Ziegelsteinen belegen und dabei keine Marke
vergessen. Teste das Programm mit verschiedenen Startpunkten von Karol.

[[Lösungsvorschlag Einseitige bedingte Anweisung|Lösungsvorschlag]]
|width=20px|
|width=300px |
|}

Datei:ObjekteKarol.png

2013-09-16T20:16:49Z

PT59kripke: hat eine neue Version von „Datei:ObjekteKarol.png“ hochgeladen: {{Information |Beschreibung = |Quelle = |Urheber = |Datum = |Genehmigung = |Andere Versionen = |Anmerkungen = }}

== Beschreibung ==
{{Information_ohne_UploadWizard
|Beschreibung = verschiedene Objekte aus Karos Welt
|Quelle = Screenshot
|Urheber =
|Datum = 16.09.2013
|Genehmigung =
|Andere Versionen =
|Anmerkungen =
}}
== Lizenz ==
{{Bild-CC-by-sa/3.0/de}}

Datei:ObjekteKarol.png

2013-09-16T20:01:17Z

PT59kripke:

Datei:ObjekteKarol.png

2013-09-16T20:00:48Z

PT59kripke: {{Information |Beschreibung = |Quelle = Screenshot |Urheber = |Datum = 16.09.2013 |Genehmigung = |Andere Versionen = |Anmerkungen = }}

== Beschreibung ==
{{Information_ohne_UploadWizard
|Beschreibung =
|Quelle = Screenshot
|Urheber =
|Datum = 16.09.2013
|Genehmigung =
|Andere Versionen =
|Anmerkungen =
}}
== Lizenz ==
{{Bild-CC-by-sa/3.0/de}}

Lösungsvorschlag Selbstdefinierte Methoden

2013-09-16T19:36:26Z

PT59kripke:

'''Aufgabe 1'''

<pre>
Anweisung Riesenschritt
Schritt
Schritt
Schritt
*Anweisung

Programm
Riesenschritt
*Programm
</pre>

'''Aufgabe 2'''

<pre>
Anweisung linksFlach
LinksDrehen
Schritt
Schritt
RechtsDrehen
Schritt
MarkeSetzen
*Anweisung

Anweisung linksSteil
LinksDrehen
Schritt
RechtsDrehen
Schritt
Schritt
MarkeSetzen
*Anweisung

Anweisung rechtsFlach
RechtsDrehen
Schritt
Schritt
LinksDrehen
Schritt
MarkeSetzen
*Anweisung

Anweisung rechtsSteil
RechtsDrehen
Schritt
LinksDrehen
Schritt
Schritt
MarkeSetzen
*Anweisung

Programm
MarkeSetzen
LinksFlach
RechtsSteil
LinksSteil
*Programm
</pre>

[[Programmieren lernen mit Robot Karol| zurück]]