FreitagsrundenWiki - Benutzerbeiträge [de]

Diskussion:Abschlussarbeit

2010-10-03T21:14:31Z

Andre: Die Seite wurde neu angelegt: „warum gehen die links nicht? --~~~~“

warum gehen die links nicht? --[[Benutzer:Andre|Andre]] 23:14, 3. Okt. 2010 (CEST)

Javakurs/Übungsaufgaben

2010-03-25T16:35:20Z

Andre: /* Die Aufgaben */

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. Einen kleinen Überblick zu den Schwierigkeitsgraden findet ihr ganz unten auf dieser Seite.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Überprüfer(Status)
!Musterlösung

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]]
| align="center" |2
| align="center" |1. VL
| Einfaches Arbeiten mit der Kommandozeile Kompilieren und Ausführen von Javacode
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Variablen_und_Zuweisungen | Variablen und Zuweisungen]]
| align="center" |1
| align="center" |1. VL
| Deklarieren und definieren von Variablen grundlegende Regeln der Codeformatierung
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Cowsay | Cowsay oder "Wie macht die Kuh?"]]
| align="center" |3
| align="center" |1. VL
| etwas mehr Bildschirmausgabe schöne Graphiken
| tkroenert (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Kassenbon | Erstellen eines Kassenbons]]
| align="center" |2
| align="center" |1. VL
| Arbeiten mit Variablen Fallunterscheidungen
| AndyF (ok), Katrin (Alignment-Vorgabe hinzugefügt, siehe Kommentar)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Javamenue | Ein eigenes Menü]]
| align="center" |3
| align="center" |1. VL
| Lesen von Benutzereingaben über die Konsole Fallunterscheidungen
| sdyroff (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Glücksspiel | Glücksspiel]]
| align="center" |3
| align="center" |1. VL
| Anwenden von Fallunterscheidungen
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Arrays | Quickies Arrays]]
| align="center" |2
| align="center" |2. VL
| Verwenden von Arrays
| andy (okay)
| [[Javakurs2007/Arrays/Musterloesung | Musterlösung Quickies Arrays]]

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Verschachtelte_Schleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Primzahlenaufgabe | Primzahlen]]
| align="center" |2-5
| align="center" |2. VL
| Geschicktes Einsetzen von Schleifen und Arrays
| andy (okay) 
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Wetterstation | Wetterstation]]
| align="center" |4
| align="center" |2. VL
| Schleifen und Arrays
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Geometrie | Geometrie]]
| align="center" |4
| align="center" |2. VL
| Methoden schreiben schreiben mathematischer Funktionen
| AndyF (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Zweierpotenzen | Zweierpotenzen]]
| align="center" |5
| align="center" |2. VL
| Schleifen und Arrays
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Schleifen_und_Modulo | Schleifen und Modulo]]
| align="center" |5
| align="center" |2. VL
| Verwendung von Schleifen Benutzung des Modulo-Operators
| andy(okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Methoden | Quickies zu Methoden]]
| align="center" |2
| align="center" |3. VL
| Verwenden von Methoden
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/MathematischeMethoden | Mathematische Methoden]]
| align="center" |3
| align="center" |3. VL
| Schreiben eigener Methoden
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Schaltjahr | Schaltjahr]]
| align="center" |3
| align="center" |3. VL
| Schreiben von Methoden Fallunterscheidungen Benutzerinteraktion
| andy (okay) 
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Crack_the_Password | Crack the Password]]
| align="center" |3
| align="center" |2/3. VL
| Passwörter knacken ;-)
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Rekursion_vs._Iteration | Rekursion vs. Iteration]]
| align="center" |5
| align="center" |3. VL
| Fehler finden
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Lineare_Funktionen | Lineare Funktionen]]
| align="center" |5
| align="center" |3. VL
| Verwendung von Methoden Schleifen und Arrays
| mars [ok]
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Fibonacci | Fibonaccizahlen]]
| align="center" |5
| align="center" |3. VL
| Schleifen und Arrays
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Brainfuck | Brainfuck vs Turingmaschine]]
| align="center" |5
| align="center" |3. VL
| Arbeiten mit Arrays Allgemeinwissen :-)
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]]
| align="center" |6
| align="center" |3. VL
| Arrays und Matrizen
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Zahlenumrechner | Zahlenumrechner]]
| align="center" |6
| align="center" |3. VL
| Arbeiten mit Methoden mathematisches Denken
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs 2007/Democracy | Der Fehler im System]]
| align="center" |3
| align="center" |3. VL
| Fehler finden
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Quersumme | Spaß mit Quersummen]]
| align="center" |5 - 7
| align="center" |3. VL
| Benutzung des Modulo-Operators Auslagern von Funktionalität in Methoden
| AndyF (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Appleman | Appleman und Fraktale]]
| align="center" |7
| align="center" |3. VL
| Schleifen, Umgang mit Fließkommazahlen
| AndyF (ok), ÜBB-Link fixed(Jörg)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/DiffusionLimitedAggregation | Diffusion Limited Aggregation]]
| align="center" |5
| align="center" |3. VL
| 2-dimensionale Arrays, Methoden, Schleifen
| Dirk (dabei)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Palindrome | Palindrome]]
| align="center" |3
| align="center" |4. VL
| Entwurf von Programmen Parameterübergabe beim Programmaufruf
| Jörg (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Hangman | Hangman]]
| align="center" |5
| align="center" |4. VL
| Entwurf von Programmen Arbeiten mit Methoden
| Jörg (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/SelectionSort | Selection Sort]]
| align="center" |5
| align="center" |4. VL
| Verstehen von komplexeren Algorithmen Schleifen und Arrays (Hilfs-)Methoden
| Jörg (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]]
| align="center" |9
| align="center" |4. VL
| eigenständiges Problemlösen. Alle Konzepte des Kurses
| mars [ok]
| [[Javakurs2007/Cäsar-Chiffre/Musterloesung | Musterlösung Cäsar-Chiffre]]

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Abzaehlspiel | Abzählspiel]]
| align="center" |7
| align="center" |4. VL
| Analyse von Aufgabenstellungen Entwurf eines komplexen Programms von Grund auf
| alexK (ok)
| [[Javakurs2007/Abzaehlspiel/Musterloesung | Musterlösung Abzählspiel]]

|- bgcolor="#F5F5F5"
| [[Javakurs2006/Rennschnecke | Schneckenrennen]]
| align="center" |5
| align="center" |5. VL
| Objektorientierte Programmierung
| seba (okay)
| [[Javakurs2006/Rennschnecke/Musterloesung | Musterlösung Rennschnecke]]

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Studentendatenbank_LE5 | Studentendatenbank]]
| align="center" |4
| align="center" |5. VL
| Vertiefung in objektorientiertes Programmieren
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Multiarray| Mehrdimensionale Arrays]]
| align="center" |10
| align="center" |5. VL
| Methoden, Schleifen, Arrays Objektorientierung
| Katrin (dabei)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Canvas | Virtuelles Canvas mit 3D-Objekten]]
| align="center" |5
| align="center" |6. VL
| Arbeiten mit Methoden mathematisches Denken
| alexK (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Doom | ASCII DOOM ]]
| align="center" |8
| align="center" |6. VL
| Vertiefung in objektorientierte Programmierung Benutzung der Java-API
| Mario (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Textwordcount | Texte lesen und analysieren]]
| align="center" |7
| align="center" |6. VL
| eigenständiges Problemlösen
| Dirk (dabei)
|

|}

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer weden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Kleine und große Probleme ==

- Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.

== Links ==

* [[Javakurs_2010/Feedback|Feedback zum Kurs 2010]]

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Javakurs/Übungsaufgaben/ArrayList

2010-03-25T13:18:54Z

Andre: /* Ein kleines Beispielprogramm für ArrayList */

Eine ArrayList ist ein Hilfsmittel, um Listen mit sich ändernder Größe
zu verwalten. Sie sind im 'Lieferumfang' von Java enthalten.

Javadoc zu [http://java.sun.com/j2se/1.4.2/docs/api/java/util/ArrayList.html ArrayList]

== Arrays - Wozu benötigen wir eine ArrayList? ==
Wenn man ein Array benutzt, so muss man schon beim Anlegen wissen,
wieviele Elemente man darin speichern will.

Im Code sieht das so aus:
<nowiki>
int[] foo = new int[4];
</nowiki>

Will man nun aber 5 Elemente in dem schon angelegten Array speichern, so müsste man erst ein
größeres Array anlegen und dann alle Elemente kopieren:

<nowiki>

//wir wollen ein 5. Element - was nun?!
int[] bar = new int[5]; // neues Array erzeugen
for (int i=0;i<foo.length;i++){ // array durchlaufen
bar[i]=foo[i]; // Werte kopieren
}
foo=bar; //alte Referenz überschreiben

foo[5] = 5; // Wert hinzufügen
</nowiki>

Auf Dauer ist das keine Lösung, zumal dies bei jedem weiteren Vergrößern
notwendig wird - je länger das Array ist, desto länger dauert die Aktion.

Die Rettung heißt: ArrayList

== Ein kleines Beispielprogramm für ArrayList ==

Im Folgenden seht Ihr ein vollständiges und lauffähiges Programm, dass mehr
oder minder sinnvolle Operationen mit einer Array-List vollführt.

<nowiki>

// WICHTIG: Einbinden der ArrayList aus der java-api:
import java.util.ArrayList;

public class ArrayListExample {

public static void main(String[] args) {

//anlegen einer ArrayListe
ArrayList<String> liste = new ArrayList<String>();

//fuellen der Liste mit Daten
liste.add("Apfel");
liste.add("Birne");
liste.add("Stuhl");
liste.add("Orange");
liste.add("Zitrone");

//Ausgeben der Liste
System.out.println(liste);

//Hmm - der gehoert hier nicht rein!
liste.remove("Stuhl");

// nochmal ausgeben
System.out.println(liste);

//testen ob Stuhl enthalten:
if (liste.contains ("Stuhl")){
System.out.println("Der Stuhl ist noch drin.");
}else{
System.out.println("Der Stuhl ist draußen.");
}

// testen ob Birne enthalten:
if (liste.contains ("Birne")){
System.out.println("Die Birne ist noch drin.");
}else{
System.out.println("Die Birne ist draußen.");
}

}

}

</nowiki>

Die ArrayList bietet noch einige weitere Methoden:
<nowiki>
int liste.size(); // liefert die Anzahl der Elemente in der Liste
Object liste.get(int i); // liefert den Eintrag an Stelle i
liste.remove(int i); // entfernt den Eintrag an Stelle i

</nowiki>

Die Art und Weise, wie in diesem Beispiel die ArrayList benutzt wird hat nur einen kleinen Haken: Sie ist nicht typsicher. Das bedeutet, dass in der Liste alle Elemente
als Typ '''Object''' gespeichert werden. Daher muss man sie explizit umwandeln:

Die Zeile:
<nowiki>
String obst = liste.get(2);
</nowiki>
ergibt beim compilieren einen Fehler, da in der Liste "Objects" gespeichert sind und keine Strings.

Das bedeutet zwar, dass man in diese ArrayList nicht nur Strings hinein geben kann, sondern beliebige Typen. Das klingt erst einmal gut, weil man sich ja nicht nur auf Strings beschränken will - aber wie bekommen wir nun Strings heraus?

=== Generics ===

Eine Möglichkeit besteht darin, die sogenannten "Generics" zu benutzen.
Keine Angst, auch wenn viele was anderes behaupten ist es eigentlich ganz einfach.

Wir müssen dazu in unserem Beispiel nur eine Zeile ändern:
<nowiki>
//anlegen einer ArrayListe
ArrayList <String> liste = new ArrayList<String>();
</nowiki>

Ab sofort erlaubt der Java Compiler uns nur noch Objekte vom Typ String in
der ArrayList zu speichern. Alles andere wird schon beim compilieren
verhindert, so dass wir gar keine falschen Typen mehr einfügen können.

Versucht es ruhig einmal selber: 
Kopiert das ArrayList-Programm von oben zunächst ohne die Änderung. Dann erweitert es mit dem folgenden Kommando, um einen String für die Variable "obst" zu erhalten:

<nowiki>
String obst = liste.get(2);
</nowiki>

=== Casten ===

Eine andere Möglichkeit besteht darin, dem Java-Compiler zu sagen,
dass Ihr euch sicher seid, keinen Typfehler zu machen und dass er den Typ
einfach umwandeln soll. Das nennt man casten und es funktioniert so:
<nowiki>
String obst = (String) liste.get(2);
</nowiki>

Damit sagt ihr dem compiler: "Hey, ich weiß dass da etwas anderes als ein String
rauskommt. Ich bin mir aber sicher, dass man das Element wie einen String behandeln kann!"

Das Problem an der Lösung ist, dass man unheimlich aufpassen muss, nicht versehentlich doch z.B. eine Rennschnecke im Array gespeichert zu haben, weil es dann einen Fehler zur Laufzeit des Programms gibt.

== Ein Beispiel für komplexe Datentypen ==

Im Folgenden seht ihr drei Klassen, bei der in der ersten
eine ArrayList zum Einsatz kommt, um die Teilnehmer an einem
Praktikum zu verwalten.

<nowiki>

/*
* DATEI: Praktikum.java
*/
import java.util.ArrayList;

class Praktikum {

String name;

ArrayList<Student> studenten; // ArrayList nur fuer Studenten

Praktikum(String aName) {
this.name = aName;
this.studenten = new ArrayList<Student>();
}

void addStudent(Student aStudent) {
studenten.add(aStudent);
}

//TODO: removeStudent -
// durch die studenten gehen und nach z.B. dem Namen suchen,
// etc.... ;)

double getAverageGrade() {
double average = 0; // initialisieren des Durchschnitts
int numberOfStudents = studenten.size();

if (numberOfStudents > 0) { // vermeiden der Division duch 0
for (int position = 0; position < numberOfStudents; position++) {
Student current = studenten.get(position);
average += current.grade;
}
average = average / numberOfStudents;
}
return average;
}

public String toString(){
int numberOfStudents = this.studenten.size();
String result= this.name+": \n";
result += "Teilnehmer : "+numberOfStudents +"\n";
result += "Durchschnittsnote: "+this.getAverageGrade()+"\n";

for (int position = 0; position < numberOfStudents; position++) {
Student current = studenten.get(position);
result += " "+position+".: "+current.name+" ("+current.grade+") \n";
}

return result;
}

}

/*
* DATEI: Student.java
*/

public class Student {

double grade;
String name;

Student(String aName,double aGrade){
this.grade=aGrade;
this.name=aName;
}

}

/*
* DATEI: TestPraktikum.java
*/
public class TestPraktikum {

public static void main(String[] args) {

Praktikum unixPraktikum = new Praktikum("UNIX-Praktikum");

Student florian = new Student("Florian",1.0);
Student maximilian = new Student("Maximilian",2.8);

unixPraktikum.addStudent(florian);
unixPraktikum.addStudent(maximilian);

System.out.println(unixPraktikum);

}

}

</nowiki>

[[Kategorie:Java]]

Javakurs/Übungsaufgaben/Rennschnecke

2010-03-25T11:25:42Z

Andre: /* Rennen */

== Rennschnecke ==
#Erstelle eine Klasse "Rennschnecke"
#:
#Rennschnecken sollen folgende Eigenschaften(Objektvariablen) besitzen:
#* einen Namen
#* eine Rasse
#* eine Maximalgeschwindigkeit (Veränderung der Strecke pro Schritt)
#* die Schnecke soll wissen welchen Weg sie bereits zurück gelegt hat
#:
# Erstelle für die Klasse Rennschnecke einen [[Javakurs2006/Java_Kurzreferenz#Konstruktor|Konstruktor]], der den Instanzvariablen beim Erstellen einer neuen Instanz (Objekt zu dieser Klasse) Werte zuweist.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "krieche()" an, welche die Schnecke abhängig von ihrer Maximalgeschwindigkeit eine zufällige Strecke weiter bewegt. Soll heißen: Sie kriecht eine zufällige Strecke größer null und kleiner ihrer Maximalgeschwindigkeit. Nimm als Zeiteinheit 1 an.
#* Tipp: Schaut euch die Methode Math.random() aus der Java API an.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "public String toString()" an, welche die Daten der Schnecke mit return als String zurückgibt.
#:
# Teste deine Klasse, indem du probehalber ein Rennschneckenobjekt erzeugst und seine Daten auf der Konsole ausgibst.
#*Tipp:Verwende zum Ausgeben der Daten die toString() Methode der Rennschnecke.
#:
#:

== Rennen ==

#Erstelle eine Klasse "Rennen"
#:
#Ein Rennen hat folgende Eigenschaften:
#*einen Namen
#*die Anzahl der teilnehmenden Schnecken
#*die teilnemenden Schnecken selbst, als:
#** Array: einfachere Umsetzung mit konstanter Teilnehmerzahl
#** [[Javakurs2007/ArrayList|ArrayList]]: schönere Umsetzung mit variabler Teilnehmerzahl
#*** Tipps:
#**** Verwende als Datentyp ArrayList<Rennschnecke>
#**** Verwende beim Erstellen new ArrayList<Rennschnecke>()
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir, welche dieser Werte bereits im Konstruktor gesetzt werden sollten.
#:
#Lege in der Klasse "Rennen" eine Methode "void addRennschnecke(Rennschnecke neueSchnecke)" an, welche dem Rennen eine Schnecke hinzufügt.
#:
#Lege in der Klasse "Rennen" eine Methode "void removeRennschnecke(String name)" an, welche eine Schnecke aus dem Rennen entfernt. (nicht so einfach und kann erstmal übersprungen werden)
#:
#Lege in der Klasse "Rennen" eine Methode "public String toString()" an, welche die Daten des Rennens mit return als String zurückgibt.
#*Tipp: Um die Daten der beteiligten Schnecken zurückzugeben, könnt ihr deren toString() Funktion benutzen.
#:
#Teste deine Klasse vom Hauptprogramm aus!
#:
#Lege in der Klasse "Rennen" eine Methode "Rennschnecke ermittleGewinner()" an, welche '''null''' zurückliefert, wenn noch keine der teilnemenden Schnecken das Ziel erreicht hat und anderenfalls die Gewinnerschnecke zurückgibt.
#:
#Lege in der Klasse "Rennen" eine Methode "void lasseSchneckenKriechen()" an, welche alle teilnemenden Schnecken einmal kriechen lässt.
#:
#Lege in der Klasse "Rennen" eine Methode "void durchfuehren()" an, welche so lange lasseSchneckenKriechen() aufruft, bis eine der Schnecken das Ziel erreicht hat.
#* Tipp: Ob eine Schnecke im Ziel angekommen ist, kannst du mit deiner Methode ermittleGewinner() herrausfinden.

== Wettbüro ==

#Erstelle eine Klasse Wettbuero.
#:
#:Ein Wettbuero hat die folgenden Eigenschaften:
#* Es weiß, für welches Rennen es seine Wetten entgegennimmt.
#* Es verfügt über eine Liste (z.B. eine ArrayList) von angenommenen Wetten.
#* Es hat einen festen Faktor, mit welchem Wetteinsätze bei einem Gewinn multipliziert werden.
#:
#Lege in der Klasse "Wettbuero" eine Methode "wetteAnnehmen(String schneckenName, int wettEinsatz, String spieler)" an, welche eine Wette entgegennimmt. Die Wette ist bezogen auf eine Schnecke für das Rennen, das von dem Büro bearbeitet wird.
#* Um die einzelnen Wetten speichern zu können, sollten ihre Daten in eigenen Objekten der Klasse "Wette" gespeichert werden. Erstellt euch diese Klasse selbst.
#* Tipp: Denkt an toString().
#:
#Lege in der Klasse "Wettbuero" eine Methode "rennenDurchfuehren()" an, welche das betreute Rennen durchfuert.
#:
#Lege in der Klasse "Wettbuero" eine Methode "toString()" an, welche die Daten des Wettbueros, die Daten des Rennens sowie sämtliche abgeschlossende Wetten als String zurückgibt.
#:
# Teste dein Programm!
#:
# Tausche die Klasse Rennen mit einem Kommilitonen, der ebenfalls bereits fertig ist.
#* Sollten eure Programme immer noch laufen?
#* Treten Fehler auf? Wenn ja: ändert eure Programme so ab, dass ihr problemlos Klassen austauschen könnt.

== Zusatz ==

Es gibt noch ein paar Dinge, die in unserem Wettbüro nicht so laufen wie sie sollten.
Macht sie besser.

* Dieselbe Schnecke kann in ein Rennen zweimal eingetragen werden.
* Es können negative Wetten abgeschlossen werden.
* Gehen zwei Schnecken gleichzeitig durchs Ziel, wird die Schnecke ausgegeben, auf die die Suche nach dem Gewinner zuerst stößt. Das ist ganz schön ungerecht.



== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)



==== Felix S. ====
"abhängig von ihrer Maximalgeschwindigkeit" verwirrte mehrmals Teilnehmer. Mathematischen Bezug/Verfahren hinschreiben bzw. erst mal auf das Kriechen konzentrieren.

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Javakurs/Übungsaufgaben/Rennschnecke/Musterloesung

2010-03-25T10:31:45Z

Andre: /* Rennen.java */

= Rennschnecke - Musterlösung =

Dies ist eine ausführliche Musterlösung der Aufgabenstellung.
Vom Wettbüso gibt es zwei unterschiedliche Versionen, von denen die zweite die Zusatzaufgaben berücksichtigt.

== Rennschnecke.java ==

<nowiki>
package Schneckenrennen;

import java.util.Random;

/**
* Eine Schnecke, welche an Rennen teilnehmen kann.
* @author André Schulz
* @version 1.0
*/
public class Rennschnecke
{
private String name;
private String rasse;
private double vMax;
private double strecke;// zurückgelegte Strcke am Startpunkt

/**
* Konstruktor für Schnecken.
* @param name Name der Schnecke
* @param rasse Rasse der Schnecke
* @param vMax Maximalgeschwindigkeit der Schnecke
*/
public Rennschnecke(String name, String rasse, double vMax)
{
this.name = name;
this.rasse = rasse;
this.vMax = vMax;
this.strecke = 0;
}

/**
* Bewegt die Schnecke mit einer zufälligen Geschwindigkeit (im Abhängigkeit von der Maximalgeschwindigkeit).
*/
public void krieche()
{
Random random = new Random();
// Mximalgeschwindigkeit wird mit 0,01..1 multipliziert
this.strecke += vMax * (random.nextInt(100) + 1) / 100;
}

/**
* Gibt den Namen der Schnecke zurück.
* @return Name
*/
public String getName()
{
return name;
}

/**
* Gibt die Rasse der Schnecke zurück.
* @return Rasse
*/
public String getRasse()
{
return rasse;
}

/**
* Gibt die Maximalgeschwindigkeit zurück.
* @return Maximalgeschwindigkeit
*/
public double getVMax()
{
return vMax;
}

/**
* Gibt die bereits zurückgelegte Strecke zurück.
* @return zurückgelegt Strecke
*/
public double getStrecke()
{
return strecke;
}

public String toString()
{
return "(" + name + "." + rasse + ":" + vMax + "@" + strecke + ")";
}

/**
* Main-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennschnecke snail = new Rennschnecke("andre", "human", 100);
System.out.println(snail);
}
}// class Rennschnecke
</nowiki>

== Rennen.java ==

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;
import java.util.Iterator;

/**
* Ein Rennen, an dem Schnecken teilnehmen.
* @author André Schulz
* @version 1.0
*/
public class Rennen
{
private String name;
private ArrayList<Rennschnecke> schnecken;
private double renndistanz;

/**
* Konstruktor für Schneckenrennen 
* (Punkt 3)
* @param name Name des Schneckenrennens
* @param renndistanz distance off the race
*/
public Rennen(String name, double renndistanz)
{
this.name = name;
//leere ArrayList von Schnecken
this.schnecken = new ArrayList<Rennschnecke>();
this.renndistanz = renndistanz;
}

/**
* Fügt eine Schnecke dem Rennen hinzu. 
*(Punkt 4)
* @param schnecke eine zum Rennen hinzuzufügende Schnecke
* @throws IllegalArgumentException wenn versucht wird eine Schnecke mehrmals hinzuzufügen
*/
public void addRennschnecke(Rennschnecke schnecke)
{
//überprüfen, ob die Schnecke schon am Rennen teilnimmt (Doppelteilnahme verhindern)
//(Zustazpunkt 1)
if (this.schnecken.contains(schnecke))
{
//Exception werfen, wenn die Schnecke schon am Rennen teilnimmt
throw new IllegalArgumentException("This snail is alredy at this race!");
}

this.schnecken.add(schnecke);
}

/**
* Entfernt eine Schnecke aus dem Rennen. 
* (entfernt alle Schnecken, die den jeweiligen Namen haben) 
* (Punkt 5)
* @param name Name der zu entfernende(n) Schnecke(n)
*/
public void removeRennschnecke(String name)
{
Rennschnecke schnecke;
//Iterator um die ArrayList zu durchlaufen
Iterator<Rennschnecke> iter = this.schnecken.iterator();

//solange es noch Elemente in der ArrayList gibt...
while (iter.hasNext())
{
//...sich den nächsten Eintrag nehmen...
schnecke = iter.next();

//...und überprüfen ob der Name mit dem zu entfernenden Namen übereinstimmt...
if (schnecke.getName().equals(name))
{
//...wenn, dann diesen Eintrag aus der ArrayList entfernen
iter.remove();
}// if
}// while
}// removeSnail

public String toString()
{
//(Punkt 6)

//StringBuilder ist Classe um Strings zu "bauen"
StringBuilder sb = new StringBuilder();

//Metadaten des Rennens (Name, Teilnehmeranzahl, Distanz)
sb.append(this.name + "(" + this.schnecken.size() + ") :" + this.renndistanz + "\n");

//die gesamte ArrayList durchlaufen und alle Schnecke hinzufügen
for (Rennschnecke snail : this.schnecken)
{
sb.append(snail);
sb.append("\n");
}// for

//wenn es einen Gewinner gibt
if (this.getGewinner() != null)
{
//...dann wird er hinzugefügt
sb.append("Gewinner:");
sb.append(this.getGewinner());
}
else
{
//..ansonsten nicht
sb.append("Rennen noch nicht gestartet!");
}

sb.append("\n");

//den gebauten String in eine echte Zeichenkette konvertieren
return sb.toString();
}// toString

/**
* Methode liefert auch einen String, welcher das Rennen repräsentiert,
* doch ist der Aufbau etwas übersichtlicher. (tabellarisch)
* @return String-Repräsentation des Schneckenrennens
*/
public String getPrintString()
{
StringBuilder sb = new StringBuilder();

sb.append("Rennen: '");
sb.append(this.name);
sb.append("' Teilnehmer: ");
sb.append(this.schnecken.size());
sb.append(" Distanz: ");
sb.append(this.renndistanz);
sb.append("\nSchnecken:\n");
sb.append("+Name\t+Rasse\t+vMax\t+Strecke\n");

for (Rennschnecke snail : this.schnecken)
{
sb.append(snail.getName());
sb.append("\t");//zwischen den einzelnen Atributen der Schnecken wird ein TabStop eingefügt
sb.append(snail.getRasse());
sb.append("\t");
sb.append(snail.getVMax());
sb.append("\t");
sb.append(snail.getStrecke());
sb.append("\t\n");
}// for

if (this.getGewinner() != null)
{
sb.append("Gewinner:");
sb.append(this.getGewinner());
}
else
{
sb.append("Rennen noch nicht gestartet!");
}

sb.append("\n");

return sb.toString();
}//getPrintString

/**
* Gibt das Rennen tabellarisch auf der Konsole aus.
*/
public void print()
{
System.out.println(getPrintString());
}// print

/**
* Gibt den Gewinner des Rennens zurück. 
* (Gibt <code>null</code> zurück, wenn das Rennen noch nciht beendet wurde.) 
* (Punkt 8)
* @return Gewinner des Rennens
*/
public Rennschnecke getGewinner()
{
Rennschnecke gewinner = null;//bis jetzt ist noch keiner bekannt...

//durchlaufe alle Schnecken...
for (Rennschnecke schnecke : this.schnecken)
{
//...überprüfe ob eine die Renndistanz zurückgelegt hat
if (schnecke.getStrecke() > this.renndistanz)
{
//wenn bisher noch kein gewinner ermittelt wurde...
if (gewinner == null)
{
//...dann ist die Schnecke der gewinner
gewinner = schnecke;
}
else
{
//...andernfalls ist die Schnecke welche weiter ist der Gewinner
//(Zusatzpunkt 3)
if (schnecke.getStrecke() > gewinner.getStrecke())
{
gewinner = schnecke;
}
}
}// if
}// for

return gewinner;
}//getWinner

/**
* Gibt alle Schnecken zurück.
* @return alle Schnecken
*/
public ArrayList<Rennschnecke> getSchnecken()
{
return this.schnecken;
}

/**
* Gibt den Namen des Rennens zurück
* @return Rennname
*/
public String getName()
{
return this.name;
}

/**
* Lässt alle Schnecken ein mal kriechen. 
* (Punkt 9)
*/
public void lasseSchneckenKriechen()
{
for (Rennschnecke snail : this.schnecken)
{
snail.krieche();
}
}

/**
* Führt das Rennen durch 
* Bewegt alle Schnecken so lange, bis eine im Zeil ist. 
* (Punkt 10)
*/
public void durchfuehren()
{
System.out.println("Rennen '" + this.name + "' wird durchgeführt...");

//so lange es keinen Gewinner gibt...
while (this.getGewinner() == null)
{
//...alle Schnecken ein mal kriechen lassen.
this.lasseSchneckenKriechen();
}// while
}

/**
* Maim-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennen testRennen = new Rennen("Test", 100000);

testRennen.addRennschnecke(new Rennschnecke("andre", "human", 100));
testRennen.addRennschnecke(new Rennschnecke("klaus", "human", 90));
testRennen.addRennschnecke(new Rennschnecke("hans", "human", 75));

System.out.println(testRennen);

testRennen.durchfuehren();
System.out.println(testRennen);
}
}// class Rennen
</nowiki>

== Wettbuero.java ==

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;

/**
* Wettbüro (einfache Version)
* @author André Schulz
* @version 1.0
*/
public class Wettbuero
{
private Rennen rennen;
private ArrayList<Wette> wetten;
private double faktor;

/**
* Konstruktor für ein Wettbüro.
* @param rennen das Rennen, welches dieses Wettbüro betreuen soll
* @param faktor der Faktor, welcher bei gewinnen ausgezahlt wird
* @throws IllegalArgumentException wenn versucht wird einen negativen Wetteinsatz zu verwenden
*/
public Wettbuero(Rennen rennen, double faktor)
{
// wenn der Wetteinsatz negativ sein soll => Fehler
// (Zusatzpunkt 2)
if (faktor < 0)
{
throw new IllegalArgumentException("Es dürfen keine Negativen Wetten abgeschlossen werden!");
}

this.rennen = rennen;
this.faktor = faktor;
this.wetten = new ArrayList<Wette>();
}

/**
* Fügt eine Wette hinzu. 
* (Punkt 2)
* @param schneckenname Name der Schnecke auf die gesetzt wird
* @param wetteinsatz der Wetteinsatz
* @param spielername Name des Spielers, welche doe Wette tätigt
*/
public void wetteAnnehmen(String schneckenname, double wetteinsatz, String spielername)
{
wetten.add(new Wette(schneckenname, wetteinsatz, spielername));
}

/**
* Führt das Rennen durch. 
* (Punkt 3)
*/
public void rennenDurchfuehren()
{
this.rennen.durchfuehren();
}

public String toString()
{
// (Punkt 4)

StringBuilder sb = new StringBuilder();

// zu erst das Rennen ausgeben
sb.append("Renen:\n");
sb.append(this.rennen);
sb.append("Wetten:\n");

// dann Wetten ausgeben, wenn vorhanden
if (wetten.size() > 0)
{
for (Wette wette : this.wetten)
{
sb.append(wette);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

return sb.toString();
}// toString

/**
* Gibt das Wettbüro, mit dem dazugehörigen Rennen aus.
*/
public void print()
{
StringBuilder sb = new StringBuilder();

sb.append("Wettbüro für:\n");
sb.append(this.rennen.getPrintString());
sb.append("Wetten:\n");

if (wetten.size() > 0)
{
for (Wette bet : this.wetten)
{
sb.append(bet);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

System.out.println(sb.toString());
}// print

/**
* Main-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennen rennen = new Rennen("testRace", 100000);

rennen.addRennschnecke(new Rennschnecke("andre", "human", 100));
rennen.addRennschnecke(new Rennschnecke("klaus", "human", 90));
rennen.addRennschnecke(new Rennschnecke("hans", "human", 75));

Wettbuero wettbuero = new Wettbuero(rennen, 1.5);

// TODO Wetten hinzufügen

wettbuero.print();

wettbuero.rennenDurchfuehren();

wettbuero.print();

}// main

/**
* Wette.
* @author André Schulz
* @version 1.0
*/
private class Wette
{
private String spielerName;
private String schneckenName;
private double wetteinsatz;

/**
* Konstruktor erstellt eine neue Wette.
* @param schneckenName Name der Schnecke auf die gesetzt werden soll.
* @param wetteinsatz der Wetteinsatz für die Wette
* @param spielerName der Name des Spielers
*/
public Wette(String schneckenName, double wetteinsatz, String spielerName)
{
if (wetteinsatz < 0)
{
throw new IllegalArgumentException("betAmount must be >=0!");
}

this.spielerName = spielerName;
this.schneckenName = schneckenName;
this.wetteinsatz = wetteinsatz;
}// Wette

public String toString()
{
return this.spielerName + ":" + this.wetteinsatz + "@" + this.schneckenName;
}

/**
* Gibt den Namen des Spielers dieser Wette zurück.
* @return Name des Spielers
*/
public String getSpielername()
{
return spielerName;
}

/**
* Gibt den Namen der Schnecke zurück, auf die gesetzt wurde.
* @return Name der Schnecke
*/
public String getSchneckenname()
{
return schneckenName;
}

/**
* Gibt den Wetteinsatz zurück.
* @return Wetteinsatz
*/
public double getWetteinsatz()
{
return wetteinsatz;
}
}// class Wette
}// class Wettbuero</nowiki>

=== Wettbuero_2.java (verbesserte Version) ===

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;
import java.util.Collections;

/**
* Wettbüro (verbesserte Version)
* @author André Schulz
* @version 2.0
*/
public class Wettbuero_2
{
private Rennen rennen;
private ArrayList<Spieler> spieler;
private ArrayList<Wette> wetten;
private double faktor;
private Rennschnecke gewinner;

/**
* Konstruktor für ein Wettbüro.
* @param rennen das Rennen, welches dieses Wettbüro betreuen soll
* @param faktor der Faktor, welcher bei gewinnen ausgezahlt wird
* @throws IllegalArgumentException wenn versucht wird einen negativen Wetteinsatz zu verwenden
*/
public Wettbuero_2(Rennen rennen, double faktor)
{
// wenn der Wetteinsatz negativ sein sollte => Fehler
// (Zusatzpunkt 2)
if (faktor < 0)
{
throw new IllegalArgumentException("Es dürfen keine Negativen Wetten abgeschlossen werden!");
}

this.rennen = rennen;
this.faktor = faktor;
this.spieler = new ArrayList<Spieler>();
this.wetten = new ArrayList<Wette>();
}// Wettbuero_2

/**
* Fügt dem Wettbüro einen neuen Spieler hinzu.
* @param spielerName der Name des Spielers
*/
public Spieler addSpieler(String spielerName)
{
// neunen Spieler erstellen
Spieler spieler = new Spieler(spielerName);

// wenn der Spieler noch nicht vorhanden ist => hinzufügen
if (!this.spieler.contains(spieler))
{
this.spieler.add(spieler);
}

return spieler;
}// addSpieler

/**
* Fügt eine Wette hinzu.
* @param schneckenName der Name der Schnecke, auf die gesetzt werden soll
* @param wetteinsatz der Wetteinsatz aud die Schnecke
* @param spielerName der Name des Spielers
*/
public void addWette(String schneckenName, double wetteinsatz, Spieler spieler)
{
for (Rennschnecke snail : this.rennen.getSchnecken())
{
if (snail.getName().equals(schneckenName))
{
wetten.add(new Wette(snail, wetteinsatz, spieler));
return;
}// if
}// for

throw new IllegalArgumentException("Eine Schnecke mit dem Namen '" + schneckenName + "' gibts in dem Rennen '" + this.rennen.getName() + " nicht!");
}// addWette

/**
* Führt das Rennen durch.
*/
public void rennenDurchfuehren()
{
this.rennen.durchfuehren();
this.gewinner = this.rennen.getGewinner();
}

public String toString()
{
StringBuilder sb = new StringBuilder();

sb.append("Rennen:\n");
sb.append(this.rennen);
sb.append("Wetten:\n");

if (wetten.size() > 0)
{
for (Wette bet : this.wetten)
{
sb.append(bet);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

return sb.toString();
}// toString

/**
* Methode wertet alle Wetten aus.
*/
public void wettenAuswerten()
{
for (Wette wette : this.wetten)
{
wette.setzeGewinn(this.gewinner, this.faktor);
}
}// wettenAuswerten

/**
* Main-Mthode zum Testen.
* @param args (none)
*/
public static void main(String[] args)
{
// rennen erstellen
Rennen race = new Rennen("Testrennen", 100000);

// Schnecken hinzufügen
race.addRennschnecke(new Rennschnecke("andre", "Mensch", 100));
race.addRennschnecke(new Rennschnecke("klaus", "Mensch", 90));
race.addRennschnecke(new Rennschnecke("hans", "Mensch", 75));

// Wettbüro erstellen
Wettbuero_2 wettbuero = new Wettbuero_2(race, 1.5);

// Spieler erstellen
Spieler spielerAndre = wettbuero.addSpieler("andre");
Spieler spielerHans = wettbuero.addSpieler("hans");

// wetten setzen
wettbuero.addWette("andre", 100, spielerAndre);
wettbuero.addWette("hans", 100, spielerHans);
wettbuero.addWette("andre", 10, spielerHans);

// Wettbüro ausgeben (vor dem Lauf)
System.out.println(wettbuero);

// Rennen durchführen udn auswerten
wettbuero.rennenDurchfuehren();
wettbuero.wettenAuswerten();

// Wettbüro ausgeben (nach dem Lauf)
System.out.println(wettbuero);

// zeigt die einzelnen Spieler
System.out.println("Spielerübersicht:");
wettbuero.zeigeSpieler();
}// main

/**
* Methode gibt alle Spieler mit ihren jeweiligen Wetten übersichtlich aus.
*/
public void zeigeSpieler()
{
// sortieren aller Wetten (nach Spielername)
Collections.sort(this.wetten);

String oldSpielerName = "";
double wetteinsatz = 0;// Gesamtwetteinsatz eines Spielers
double wettgewinn = 0;// Gesamtwettgewinn eines Spielers

System.out.println("Spieler\tSchnecke\tEinsatz\tGewinn\tSaldo");
System.out.println("================================================");

for (Wette wette : this.wetten)
{
if (wette.spieler.name == oldSpielerName)
{
System.out.println("\t" + wette.schnecke.getRasse() + "." + wette.schnecke.getName() + "\t" + wette.wetteinsatz + "\t" + wette.wettgewinn + "\t" + (wette.wettgewinn - wette.wetteinsatz));

wetteinsatz += wette.wetteinsatz;
wettgewinn += wette.wettgewinn;
}
else
{
if (oldSpielerName != "")
{
System.out.println("\t\t\t------------------------");
System.out.println("\t\t\t" + wetteinsatz + "\t" + wettgewinn + "\t" + (wettgewinn - wetteinsatz));
}// if

System.out.println(wette.spieler.name);
System.out.println("\t" + wette.schnecke.getRasse() + "." + wette.schnecke.getName() + "\t" + wette.wetteinsatz + "\t" + wette.wettgewinn + "\t" + (wette.wettgewinn - wette.wetteinsatz));

oldSpielerName = wette.spieler.name;
wetteinsatz = wette.wetteinsatz;
wettgewinn = wette.wettgewinn;
}// else
}// for

if (oldSpielerName != "")
{
System.out.println("\t\t\t------------------------");
System.out.println("\t\t\t" + wetteinsatz + "\t" + wettgewinn + "\t" + (wettgewinn - wetteinsatz));
}// if
}// zeigeSpieler

/**
* Eine Wette.
*/
private class Wette implements Comparable<Wette>
{
private Spieler spieler;
private Rennschnecke schnecke;
private double wetteinsatz;
private double wettgewinn;

/**
* Konstruktor für wetten.
* @param schnecke die Schnecke
* @param wetteinsatz der Wetteinsatz
* @param spieler der Spieler der wettet
*/
public Wette(Rennschnecke schnecke, double wetteinsatz, Spieler spieler)
{
if (wetteinsatz < 0)
{
throw new IllegalArgumentException("Wetteinsatz muss >=0 sein!");
}

this.spieler = spieler;
this.schnecke = schnecke;
this.wetteinsatz = wetteinsatz;
this.wettgewinn = -1;
}// Wette

/**
* Methode setzt in Abhängigkeit vom Gewinner den Wettgewinn.
* @param gewinner die Schnecke, welce das Rennen gewonnen hat
* @param faktor der Gewinnfaktor
*/
public void setzeGewinn(Rennschnecke gewinner, double faktor)
{
if (this.schnecke.equals(gewinner))
{
// auf Gewinner gesetzt => Wettgewinn setzen
this.wettgewinn = this.wetteinsatz * faktor;
}
else
{
// auf andere Schnecke gesetzt => kein Gewinn
this.wettgewinn = 0;
}
}// setzeGewinn

public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append(this.spieler);
sb.append(":");
sb.append(this.wetteinsatz);
sb.append("@");
sb.append(this.schnecke);

if (this.wettgewinn != -1)
{
sb.append("->");
sb.append(this.wettgewinn);
}

return sb.toString();
}// toString

@Override
public int compareTo(Wette other)
{
return this.spieler.name.compareTo(other.spieler.name);
}
}// class Bet

/**
* Ein Spieler welcher Wetten tätigt.
* @author André Schulz
* @version 1.0
*/
public class Spieler
{
private String name;

public Spieler(String name)
{
this.name = name;
}

public String getName()
{
return this.name;
}

public String toString()
{
return name;
}
}// calss Spieler
}// class Wettbuero_2
</nowiki>

Javakurs/Übungsaufgaben/Rennschnecke

2010-03-25T10:28:33Z

Andre: /* Rennen */

== Rennschnecke ==
#Erstelle eine Klasse "Rennschnecke"
#:
#Rennschnecken sollen folgende Eigenschaften(Objektvariablen) besitzen:
#* einen Namen
#* eine Rasse
#* eine Maximalgeschwindigkeit (Veränderung der Strecke pro Schritt)
#* die Schnecke soll wissen welchen Weg sie bereits zurück gelegt hat
#:
# Erstelle für die Klasse Rennschnecke einen [[Javakurs2006/Java_Kurzreferenz#Konstruktor|Konstruktor]], der den Instanzvariablen beim Erstellen einer neuen Instanz (Objekt zu dieser Klasse) Werte zuweist.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "krieche()" an, welche die Schnecke abhängig von ihrer Maximalgeschwindigkeit eine zufällige Strecke weiter bewegt. Soll heißen: Sie kriecht eine zufällige Strecke größer null und kleiner ihrer Maximalgeschwindigkeit. Nimm als Zeiteinheit 1 an.
#* Tipp: Schaut euch die Methode Math.random() aus der Java API an.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "public String toString()" an, welche die Daten der Schnecke mit return als String zurückgibt.
#:
# Teste deine Klasse, indem du probehalber ein Rennschneckenobjekt erzeugst und seine Daten auf der Konsole ausgibst.
#*Tipp:Verwende zum Ausgeben der Daten die toString() Methode der Rennschnecke.
#:
#:

== Rennen ==

#Erstelle eine Klasse "Rennen"
#:
#Ein Rennen hat folgende Eigenschaften:
#*einen Namen
#*die Anzahl der teilnehmenden Schnecken
#*die teilnemenden Schnecken selbst, als:
#** Array: einfachere Umsetzung mit konstanter Teilnehmerzahl
#** [[Javakurs2007/ArrayList|ArrayList]]: schönere Umsetzung mit variabler Teilnehmerzahl
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir, welche dieser Werte bereits im Konstruktor gesetzt werden sollten.
#:
#Lege in der Klasse "Rennen" eine Methode "void addRennschnecke(Rennschnecke neueSchnecke)" an, welche dem Rennen eine Schnecke hinzufügt.
#:
#Lege in der Klasse "Rennen" eine Methode "void removeRennschnecke(String name)" an, welche eine Schnecke aus dem Rennen entfernt. (nicht so einfach und kann erstmal übersprungen werden)
#:
#Lege in der Klasse "Rennen" eine Methode "public String toString()" an, welche die Daten des Rennens mit return als String zurückgibt.
#*Tipp: Um die Daten der beteiligten Schnecken zurückzugeben, könnt ihr deren toString() Funktion benutzen.
#:
#Teste deine Klasse vom Hauptprogramm aus!
#:
#Lege in der Klasse "Rennen" eine Methode "Rennschnecke ermittleGewinner()" an, welche '''null''' zurückliefert, wenn noch keine der teilnemenden Schnecken das Ziel erreicht hat und anderenfalls die Gewinnerschnecke zurückgibt.
#:
#Lege in der Klasse "Rennen" eine Methode "void lasseSchneckenKriechen()" an, welche alle teilnemenden Schnecken einmal kriechen lässt.
#:
#Lege in der Klasse "Rennen" eine Methode "void durchfuehren()" an, welche so lange lasseSchneckenKriechen() aufruft, bis eine der Schnecken das Ziel erreicht hat.
#* Tipp: Ob eine Schnecke im Ziel angekommen ist, kannst du mit deiner Methode ermittleGewinner() herrausfinden.

== Wettbüro ==

#Erstelle eine Klasse Wettbuero.
#:
#:Ein Wettbuero hat die folgenden Eigenschaften:
#* Es weiß, für welches Rennen es seine Wetten entgegennimmt.
#* Es verfügt über eine Liste (z.B. eine ArrayList) von angenommenen Wetten.
#* Es hat einen festen Faktor, mit welchem Wetteinsätze bei einem Gewinn multipliziert werden.
#:
#Lege in der Klasse "Wettbuero" eine Methode "wetteAnnehmen(String schneckenName, int wettEinsatz, String spieler)" an, welche eine Wette entgegennimmt. Die Wette ist bezogen auf eine Schnecke für das Rennen, das von dem Büro bearbeitet wird.
#* Um die einzelnen Wetten speichern zu können, sollten ihre Daten in eigenen Objekten der Klasse "Wette" gespeichert werden. Erstellt euch diese Klasse selbst.
#* Tipp: Denkt an toString().
#:
#Lege in der Klasse "Wettbuero" eine Methode "rennenDurchfuehren()" an, welche das betreute Rennen durchfuert.
#:
#Lege in der Klasse "Wettbuero" eine Methode "toString()" an, welche die Daten des Wettbueros, die Daten des Rennens sowie sämtliche abgeschlossende Wetten als String zurückgibt.
#:
# Teste dein Programm!
#:
# Tausche die Klasse Rennen mit einem Kommilitonen, der ebenfalls bereits fertig ist.
#* Sollten eure Programme immer noch laufen?
#* Treten Fehler auf? Wenn ja: ändert eure Programme so ab, dass ihr problemlos Klassen austauschen könnt.

== Zusatz ==

Es gibt noch ein paar Dinge, die in unserem Wettbüro nicht so laufen wie sie sollten.
Macht sie besser.

* Dieselbe Schnecke kann in ein Rennen zweimal eingetragen werden.
* Es können negative Wetten abgeschlossen werden.
* Gehen zwei Schnecken gleichzeitig durchs Ziel, wird die Schnecke ausgegeben, auf die die Suche nach dem Gewinner zuerst stößt. Das ist ganz schön ungerecht.



== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)



==== Felix S. ====
"abhängig von ihrer Maximalgeschwindigkeit" verwirrte mehrmals Teilnehmer. Mathematischen Bezug/Verfahren hinschreiben bzw. erst mal auf das Kriechen konzentrieren.

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Javakurs/Übungsaufgaben/Rennschnecke

2010-03-25T10:26:18Z

Andre: /* Rennschnecke */

== Rennschnecke ==
#Erstelle eine Klasse "Rennschnecke"
#:
#Rennschnecken sollen folgende Eigenschaften(Objektvariablen) besitzen:
#* einen Namen
#* eine Rasse
#* eine Maximalgeschwindigkeit (Veränderung der Strecke pro Schritt)
#* die Schnecke soll wissen welchen Weg sie bereits zurück gelegt hat
#:
# Erstelle für die Klasse Rennschnecke einen [[Javakurs2006/Java_Kurzreferenz#Konstruktor|Konstruktor]], der den Instanzvariablen beim Erstellen einer neuen Instanz (Objekt zu dieser Klasse) Werte zuweist.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "krieche()" an, welche die Schnecke abhängig von ihrer Maximalgeschwindigkeit eine zufällige Strecke weiter bewegt. Soll heißen: Sie kriecht eine zufällige Strecke größer null und kleiner ihrer Maximalgeschwindigkeit. Nimm als Zeiteinheit 1 an.
#* Tipp: Schaut euch die Methode Math.random() aus der Java API an.
#:
#Lege in der Klasse "Rennschnecke" eine Methode "public String toString()" an, welche die Daten der Schnecke mit return als String zurückgibt.
#:
# Teste deine Klasse, indem du probehalber ein Rennschneckenobjekt erzeugst und seine Daten auf der Konsole ausgibst.
#*Tipp:Verwende zum Ausgeben der Daten die toString() Methode der Rennschnecke.
#:
#:

== Rennen ==

#Erstelle eine Klasse "Rennen"
#:
#Ein Rennen hat folgende Eigenschaften:
#*einen Namen
#*die Anzahl der teilnehmenden Schnecken
#*die teilnemenden Schnecken selbst (z.B. in einer [[Javakurs2007/ArrayList|ArrayList]])
#*die Länge der zu kriechenden Strecke
#:
#Überlege dir, welche dieser Werte bereits im Konstruktor gesetzt werden sollten.
#:
#Lege in der Klasse "Rennen" eine Methode "void addRennschnecke(Rennschnecke neueSchnecke)" an, welche dem Rennen eine Schnecke hinzufügt.
#:
#Lege in der Klasse "Rennen" eine Methode "void removeRennschnecke(String name)" an, welche eine Schnecke aus dem Rennen entfernt.
#:
#Lege in der Klasse "Rennen" eine Methode "public String toString()" an, welche die Daten des Rennens mit return als String zurückgibt.
#*Tipp: Um die Daten der beteiligten Schnecken zurückzugeben, könnt ihr deren toString() Funktion benutzen.
#:
#Teste deine Klasse vom Hauptprogramm aus!
#:
#Lege in der Klasse "Rennen" eine Methode "Rennschnecke ermittleGewinner()" an, welche '''null''' zurückliefert, wenn noch keine der teilnemenden Schnecken das Ziel erreicht hat und anderenfalls die Gewinnerschnecke zurückgibt.
#:
#Lege in der Klasse "Rennen" eine Methode "void lasseSchneckenKriechen()" an, welche alle teilnemenden Schnecken einmal kriechen lässt.
#:
#Lege in der Klasse "Rennen" eine Methode "void durchfuehren()" an, welche so lange lasseSchneckenKriechen() aufruft, bis eine der Schnecken das Ziel erreicht hat.
#* Tipp: Ob eine Schnecke im Ziel angekommen ist, kannst du mit deiner Methode ermittleGewinner() herrausfinden.

== Wettbüro ==

#Erstelle eine Klasse Wettbuero.
#:
#:Ein Wettbuero hat die folgenden Eigenschaften:
#* Es weiß, für welches Rennen es seine Wetten entgegennimmt.
#* Es verfügt über eine Liste (z.B. eine ArrayList) von angenommenen Wetten.
#* Es hat einen festen Faktor, mit welchem Wetteinsätze bei einem Gewinn multipliziert werden.
#:
#Lege in der Klasse "Wettbuero" eine Methode "wetteAnnehmen(String schneckenName, int wettEinsatz, String spieler)" an, welche eine Wette entgegennimmt. Die Wette ist bezogen auf eine Schnecke für das Rennen, das von dem Büro bearbeitet wird.
#* Um die einzelnen Wetten speichern zu können, sollten ihre Daten in eigenen Objekten der Klasse "Wette" gespeichert werden. Erstellt euch diese Klasse selbst.
#* Tipp: Denkt an toString().
#:
#Lege in der Klasse "Wettbuero" eine Methode "rennenDurchfuehren()" an, welche das betreute Rennen durchfuert.
#:
#Lege in der Klasse "Wettbuero" eine Methode "toString()" an, welche die Daten des Wettbueros, die Daten des Rennens sowie sämtliche abgeschlossende Wetten als String zurückgibt.
#:
# Teste dein Programm!
#:
# Tausche die Klasse Rennen mit einem Kommilitonen, der ebenfalls bereits fertig ist.
#* Sollten eure Programme immer noch laufen?
#* Treten Fehler auf? Wenn ja: ändert eure Programme so ab, dass ihr problemlos Klassen austauschen könnt.

== Zusatz ==

Es gibt noch ein paar Dinge, die in unserem Wettbüro nicht so laufen wie sie sollten.
Macht sie besser.

* Dieselbe Schnecke kann in ein Rennen zweimal eingetragen werden.
* Es können negative Wetten abgeschlossen werden.
* Gehen zwei Schnecken gleichzeitig durchs Ziel, wird die Schnecke ausgegeben, auf die die Suche nach dem Gewinner zuerst stößt. Das ist ganz schön ungerecht.



== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)



==== Felix S. ====
"abhängig von ihrer Maximalgeschwindigkeit" verwirrte mehrmals Teilnehmer. Mathematischen Bezug/Verfahren hinschreiben bzw. erst mal auf das Kriechen konzentrieren.

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Javakurs/Übungsaufgaben

2010-03-25T10:24:46Z

Andre: /* Die Aufgaben */

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. Einen kleinen Überblick zu den Schwierigkeitsgraden findet ihr ganz unten auf dieser Seite.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Überprüfer(Status)
!Musterlösung

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]]
| align="center" |2
| align="center" |1. VL
| Einfaches Arbeiten mit der Kommandozeile Kompilieren und Ausführen von Javacode
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Variablen_und_Zuweisungen | Variablen und Zuweisungen]]
| align="center" |1
| align="center" |1. VL
| Deklarieren und definieren von Variablen grundlegende Regeln der Codeformatierung
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Cowsay | Cowsay oder "Wie macht die Kuh?"]]
| align="center" |3
| align="center" |1. VL
| etwas mehr Bildschirmausgabe schöne Graphiken
| tkroenert (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Kassenbon | Erstellen eines Kassenbons]]
| align="center" |2
| align="center" |1. VL
| Arbeiten mit Variablen Fallunterscheidungen
| AndyF (ok), Katrin (Alignment-Vorgabe hinzugefügt, siehe Kommentar)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Javamenue | Ein eigenes Menü]]
| align="center" |3
| align="center" |1. VL
| Lesen von Benutzereingaben über die Konsole Fallunterscheidungen
| sdyroff (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Glücksspiel | Glücksspiel]]
| align="center" |3
| align="center" |1. VL
| Anwenden von Fallunterscheidungen
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Arrays | Quickies Arrays]]
| align="center" |2
| align="center" |2. VL
| Verwenden von Arrays
| andy (okay)
| [[Javakurs2007/Arrays/Musterloesung | Musterlösung Quickies Arrays]]

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Verschachtelte_Schleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Primzahlenaufgabe | Primzahlen]]
| align="center" |2-5
| align="center" |2. VL
| Geschicktes Einsetzen von Schleifen und Arrays
| andy (okay) 
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Wetterstation | Wetterstation]]
| align="center" |4
| align="center" |2. VL
| Schleifen und Arrays
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Geometrie | Geometrie]]
| align="center" |4
| align="center" |2. VL
| Methoden schreiben schreiben mathematischer Funktionen
| AndyF (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Zweierpotenzen | Zweierpotenzen]]
| align="center" |5
| align="center" |2. VL
| Schleifen und Arrays
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Schleifen_und_Modulo | Schleifen und Modulo]]
| align="center" |5
| align="center" |2. VL
| Verwendung von Schleifen Benutzung des Modulo-Operators
| andy(okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Methoden | Quickies zu Methoden]]
| align="center" |2
| align="center" |3. VL
| Verwenden von Methoden
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/MathematischeMethoden | Mathematische Methoden]]
| align="center" |3
| align="center" |3. VL
| Schreiben eigener Methoden
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Schaltjahr | Schaltjahr]]
| align="center" |3
| align="center" |3. VL
| Schreiben von Methoden Fallunterscheidungen Benutzerinteraktion
| andy (okay) 
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Crack_the_Password | Crack the Password]]
| align="center" |3
| align="center" |2/3. VL
| Passwörter knacken ;-)
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Rekursion_vs._Iteration | Rekursion vs. Iteration]]
| align="center" |5
| align="center" |3. VL
| Fehler finden
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Lineare_Funktionen | Lineare Funktionen]]
| align="center" |5
| align="center" |3. VL
| Verwendung von Methoden Schleifen und Arrays
| mars [ok]
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Fibonacci | Fibonaccizahlen]]
| align="center" |5
| align="center" |3. VL
| Schleifen und Arrays
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Brainfuck | Brainfuck vs Turingmaschine]]
| align="center" |5
| align="center" |3. VL
| Arbeiten mit Arrays Allgemeinwissen :-)
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]]
| align="center" |6
| align="center" |3. VL
| Arrays und Matrizen
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Zahlenumrechner | Zahlenumrechner]]
| align="center" |6
| align="center" |3. VL
| Arbeiten mit Methoden mathematisches Denken
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs 2007/Democracy | Der Fehler im System]]
| align="center" |3
| align="center" |3. VL
| Fehler finden
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Quersumme | Spaß mit Quersummen]]
| align="center" |5 - 7
| align="center" |3. VL
| Benutzung des Modulo-Operators Auslagern von Funktionalität in Methoden
| AndyF (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Appleman | Appleman und Fraktale]]
| align="center" |7
| align="center" |3. VL
| Schleifen, Umgang mit Fließkommazahlen
| AndyF (ok), ÜBB-Link fixed(Jörg)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/DiffusionLimitedAggregation | Diffusion Limited Aggregation]]
| align="center" |5
| align="center" |3. VL
| 2-dimensionale Arrays, Methoden, Schleifen
| Dirk (dabei)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Palindrome | Palindrome]]
| align="center" |3
| align="center" |4. VL
| Entwurf von Programmen Parameterübergabe beim Programmaufruf
| Jörg (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Hangman | Hangman]]
| align="center" |5
| align="center" |4. VL
| Entwurf von Programmen Arbeiten mit Methoden
| Jörg (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/SelectionSort | Selection Sort]]
| align="center" |5
| align="center" |4. VL
| Verstehen von komplexeren Algorithmen Schleifen und Arrays (Hilfs-)Methoden
| Jörg (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]]
| align="center" |9
| align="center" |4. VL
| eigenständiges Problemlösen. Alle Konzepte des Kurses
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Abzaehlspiel | Abzählspiel]]
| align="center" |7
| align="center" |4. VL
| Analyse von Aufgabenstellungen Entwurf eines komplexen Programms von Grund auf
| alexK (ok)
| [[Javakurs2007/Abzaehlspiel/Musterloesung | Musterlösung Abzählspiel]]

|- bgcolor="#F5F5F5"
| [[Javakurs2006/Rennschnecke | Schneckenrennen]]
| align="center" |5
| align="center" |5. VL
| Objektorientierte Programmierung
| seba (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Studentendatenbank_LE5 | Studentendatenbank]]
| align="center" |4
| align="center" |5. VL
| Vertiefung in objektorientiertes Programmieren
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Multiarray| Mehrdimensionale Arrays]]
| align="center" |10
| align="center" |5. VL
| Methoden, Schleifen, Arrays Objektorientierung
| Katrin (dabei)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Canvas | Virtuelles Canvas mit 3D-Objekten]]
| align="center" |5
| align="center" |6. VL
| Arbeiten mit Methoden mathematisches Denken
| alexK (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Doom | ASCII DOOM ]]
| align="center" |8
| align="center" |6. VL
| Vertiefung in objektorientierte Programmierung Benutzung der Java-API
| Mario (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Textwordcount | Texte lesen und analysieren]]
| align="center" |7
| align="center" |6. VL
| eigenständiges Problemlösen
| Dirk (dabei)
|

|}

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer weden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Kleine und große Probleme ==

- Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.

== Links ==

* [[Javakurs_2010/Feedback|Feedback zum Kurs 2010]]

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Datei Diskussion:LAN10.1.png

2010-03-24T20:04:01Z

Andre: Die Seite wurde neu angelegt: „fehlt da nich n FI am ende? ~~~“

fehlt da nich n FI am ende? [[Benutzer:Andre|Andre]]

Javakurs/Übungsaufgaben

2010-03-24T19:58:16Z

Andre: Musterlösung verlinkt

Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert.
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. Einen kleinen Überblick zu den Schwierigkeitsgraden findet ihr ganz unten auf dieser Seite.

Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.

== Die Aufgaben ==

{| class="wikitable sortable" border="0" cellpadding="4" cellspacing="2"
|- bgcolor="#D8D8D8"
!Aufgabe
!Schwierigkeit
!Vorwissen
!Lerneffekte
!Überprüfer(Status)
!Musterlösung

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Von der Console zum HelloWorld | Vom Arbeiten mit der Konsole bis "Hallo Welt"]]
| align="center" |2
| align="center" |1. VL
| Einfaches Arbeiten mit der Kommandozeile Kompilieren und Ausführen von Javacode
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Variablen_und_Zuweisungen | Variablen und Zuweisungen]]
| align="center" |1
| align="center" |1. VL
| Deklarieren und definieren von Variablen grundlegende Regeln der Codeformatierung
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Cowsay | Cowsay oder "Wie macht die Kuh?"]]
| align="center" |3
| align="center" |1. VL
| etwas mehr Bildschirmausgabe schöne Graphiken
| tkroenert (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Kassenbon | Erstellen eines Kassenbons]]
| align="center" |2
| align="center" |1. VL
| Arbeiten mit Variablen Fallunterscheidungen
| AndyF (ok), Katrin (Alignment-Vorgabe hinzugefügt, siehe Kommentar)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Javamenue | Ein eigenes Menü]]
| align="center" |3
| align="center" |1. VL
| Lesen von Benutzereingaben über die Konsole Fallunterscheidungen
| sdyroff (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Glücksspiel | Glücksspiel]]
| align="center" |3
| align="center" |1. VL
| Anwenden von Fallunterscheidungen
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Arrays | Quickies Arrays]]
| align="center" |2
| align="center" |2. VL
| Verwenden von Arrays
| andy (okay)
| [[Javakurs2007/Arrays/Musterloesung | Musterlösung Quickies Arrays]]

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Verschachtelte_Schleifen | Verschachtelte Schleifen]]
| align="center" |3
| align="center" |2. VL
| Umgang mit mehreren verschachtelten Schleifen
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Primzahlenaufgabe | Primzahlen]]
| align="center" |2-5
| align="center" |2. VL
| Geschicktes Einsetzen von Schleifen und Arrays
| andy (okay) 
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Wetterstation | Wetterstation]]
| align="center" |4
| align="center" |2. VL
| Schleifen und Arrays
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Geometrie | Geometrie]]
| align="center" |4
| align="center" |2. VL
| Methoden schreiben schreiben mathematischer Funktionen
| AndyF (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Zweierpotenzen | Zweierpotenzen]]
| align="center" |5
| align="center" |2. VL
| Schleifen und Arrays
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Schleifen_und_Modulo | Schleifen und Modulo]]
| align="center" |5
| align="center" |2. VL
| Verwendung von Schleifen Benutzung des Modulo-Operators
| andy(okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Methoden | Quickies zu Methoden]]
| align="center" |2
| align="center" |3. VL
| Verwenden von Methoden
| andy (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/MathematischeMethoden | Mathematische Methoden]]
| align="center" |3
| align="center" |3. VL
| Schreiben eigener Methoden
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Schaltjahr | Schaltjahr]]
| align="center" |3
| align="center" |3. VL
| Schreiben von Methoden Fallunterscheidungen Benutzerinteraktion
| andy (okay) 
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Crack_the_Password | Crack the Password]]
| align="center" |3
| align="center" |2/3. VL
| Passwörter knacken ;-)
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Rekursion_vs._Iteration | Rekursion vs. Iteration]]
| align="center" |5
| align="center" |3. VL
| Fehler finden
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Lineare_Funktionen | Lineare Funktionen]]
| align="center" |5
| align="center" |3. VL
| Verwendung von Methoden Schleifen und Arrays
| mars [ok]
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Fibonacci | Fibonaccizahlen]]
| align="center" |5
| align="center" |3. VL
| Schleifen und Arrays
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Brainfuck | Brainfuck vs Turingmaschine]]
| align="center" |5
| align="center" |3. VL
| Arbeiten mit Arrays Allgemeinwissen :-)
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Gau%C3%9F-Algorithmus | Gauß-Algorithmus]]
| align="center" |6
| align="center" |3. VL
| Arrays und Matrizen
| sdyroff (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Zahlenumrechner | Zahlenumrechner]]
| align="center" |6
| align="center" |3. VL
| Arbeiten mit Methoden mathematisches Denken
| andy (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs 2007/Democracy | Der Fehler im System]]
| align="center" |3
| align="center" |3. VL
| Fehler finden
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Quersumme | Spaß mit Quersummen]]
| align="center" |5 - 7
| align="center" |3. VL
| Benutzung des Modulo-Operators Auslagern von Funktionalität in Methoden
| AndyF (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Appleman | Appleman und Fraktale]]
| align="center" |7
| align="center" |3. VL
| Schleifen, Umgang mit Fließkommazahlen
| AndyF (ok), ÜBB-Link fixed(Jörg)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/DiffusionLimitedAggregation | Diffusion Limited Aggregation]]
| align="center" |5
| align="center" |3. VL
| 2-dimensionale Arrays, Methoden, Schleifen
| Dirk (dabei)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Palindrome | Palindrome]]
| align="center" |3
| align="center" |4. VL
| Entwurf von Programmen Parameterübergabe beim Programmaufruf
| Jörg (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Hangman | Hangman]]
| align="center" |5
| align="center" |4. VL
| Entwurf von Programmen Arbeiten mit Methoden
| Jörg (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/SelectionSort | Selection Sort]]
| align="center" |5
| align="center" |4. VL
| Verstehen von komplexeren Algorithmen Schleifen und Arrays (Hilfs-)Methoden
| Jörg (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Cäsar-Chiffre | Chiffrierung/Dechiffrierung (Cäsar)]]
| align="center" |9
| align="center" |4. VL
| eigenständiges Problemlösen. Alle Konzepte des Kurses
| mars [ok]
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Abzaehlspiel | Abzählspiel]]
| align="center" |7
| align="center" |4. VL
| Analyse von Aufgabenstellungen Entwurf eines komplexen Programms von Grund auf
| alexK (ok)
| [[Javakurs2007/Abzaehlspiel/Musterloesung | Musterlösung Abzählspiel]]

|- bgcolor="#F5F5F5"
| [[Javakurs2006/Rennschnecke | Schneckenrennen]]
| align="center" |4
| align="center" |5. VL
| Objektorientierte Programmierung
| seba (okay)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Studentendatenbank_LE5 | Studentendatenbank]]
| align="center" |4
| align="center" |5. VL
| Vertiefung in objektorientiertes Programmieren
| seba (okay)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Multiarray| Mehrdimensionale Arrays]]
| align="center" |10
| align="center" |5. VL
| Methoden, Schleifen, Arrays Objektorientierung
| Katrin (dabei)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Canvas | Virtuelles Canvas mit 3D-Objekten]]
| align="center" |5
| align="center" |6. VL
| Arbeiten mit Methoden mathematisches Denken
| alexK (ok)
|

|- bgcolor="#F5F5F5"
| [[Javakurs2007/Doom | ASCII DOOM ]]
| align="center" |8
| align="center" |6. VL
| Vertiefung in objektorientierte Programmierung Benutzung der Java-API
| Mario (ok)
|

|- bgcolor="#E8E8E8"
| [[Javakurs2007/Textwordcount | Texte lesen und analysieren]]
| align="center" |7
| align="center" |6. VL
| eigenständiges Problemlösen
| Dirk (dabei)
|

|}

== Schwierigkeitsgrade ==

# Reines Tutorial. Man muss nicht viel selbst denken
# ...
# Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.
# ...
# Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.
# ...
# Herausfordernd, eher etwas für Studies die etwas fitter sind.
# ...
# Auch erfahrene Programmierer weden hier ein bis zwei Übungen beschäftigt sein 
# Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.

== Kleine und große Probleme ==

- Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die Cursortasten nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.

== Links ==

* [[Javakurs_2010/Feedback|Feedback zum Kurs 2010]]

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Javakurs/Übungsaufgaben/Abzaehlspiel/Musterloesung

2010-03-24T19:53:04Z

Andre: Die Seite wurde neu angelegt: „= Abzählspiel - Musterlösung = <nowiki> package abzaehlspiel; public class Abzaehlspiel { public static void main(String[] args) { int[] personen = new i...“

= Abzählspiel - Musterlösung =

<nowiki>
package abzaehlspiel;

public class Abzaehlspiel
{
public static void main(String[] args)
{
int[] personen = new int[10000];// Array fuer die Personen
int i;// Zaehlvariable

// allen Personen eine Nummer zuweisen
for (i = 0; i < 10000; i++)
{
// den Personen eine Nummer geben
personen[i] = i + 1;
}

int stelle = 0;// Stelle der Person, welche man gerade betrachtet
int zaehler = 0;// Variable, mit der man bis zum 3. zaehlt
int letzter = -1;// Stelle, an der der Letzte ertfernt wurde

// die eigentliche Abzaehlung
do
{
// ueberpruefen ob die person noch da ist...
if (personen[stelle] != 0)
{
// ... wenn ja, dann weiterzaehlen
zaehler++;

// ueberpruefen ob man beim 3. angekommen ist...
if (zaehler == 3)
{
// ... diese Person etfernen (seine Numer auf Null setzen)
personen[stelle] = 0;
zaehler = 0;// wieder von vorne anfangen zu zaehlen
letzter = stelle;// merken, wo als letztes entfernt wurde
}// if
}// if

// zum naechsten gehen
stelle++;

// ueberpruefen ob man am Ende ist...
if (stelle == personen.length)
{
// ... dann am Anfang fortsetzen
stelle = 0;
}

// die Schleife so lange wiederholen, bis man an der Stelle
// angekommen ist, an der man als Letztes jemanden entfernt hat,
// dann ist man einmal duch alle Personen durchgelaufen
// und hat dabei keinen entfernt => Ende
} while (stelle != letzter);

System.out.println("Uebrig bleiben:");

// Alle Personen durchgehen...
for (i = 0; i < 10000; i++)
{
// ... und wenn eine Person noch da ist...
if (personen[i] != 0)
{
// ...ausgeben
System.out.println(personen[i]);
}
}// for

}// main
}// class
</nowiki>

Javakurs/Übungsaufgaben/Abzaehlspiel

2010-03-24T14:33:04Z

Andre: /* Kommentare */

=== Problembeschreibung ===
10000 Leute stehen durchnummeriert im Kreis. Nacheinander muss jeder Dritte gehen. Welche 2 Personen bleiben übrig?

=== Arbeitsschritte ===

# Analysiert das Problem, gibt es noch Fragen oder Ungenauigkeiten in der Aufgabenstellung, die zuvor geklärt werden müssen?
# Entwerft den späteren Programmablauf auf Papier. Notiert euch dabei, welche Teilprobleme zu lösen sind.
# Verfeinert euren Entwurf, wie im [[Javakurs2007/Vortrag04|Vortrag 4]] gezeigt wurde.
# Schreibt nun das Programm. Und denkt dran: Immer wieder mal testen!

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

wer hat noch 1 und 10000 raus?

oder wer hat noch 2691 und 8922 raus xD

Kann mal bitte irgendwer von den Tutoren, die richtige Lösung hier rein schreiben???

-> Die 2692. und 8923. Person bleiben übrig. (welche die Indizes 2691 und 8922 haben)

Javakurs/Übungsaufgaben/Rennschnecke/Musterloesung

2010-03-24T13:56:53Z

Andre: /* Rennschnecke - Musterlösung */

= Rennschnecke - Musterlösung =

Dies ist eine ausführliche Musterlösung der Aufgabenstellung.
Vom Wettbüso gibt es zwei unterschiedliche Versionen, von denen die zweite die Zusatzaufgaben berücksichtigt.

== Rennschnecke.java ==

<nowiki>
package Schneckenrennen;

import java.util.Random;

/**
* Eine Schnecke, welche an Rennen teilnehmen kann.
* @author André Schulz
* @version 1.0
*/
public class Rennschnecke
{
private String name;
private String rasse;
private double vMax;
private double strecke;// zurückgelegte Strcke am Startpunkt

/**
* Konstruktor für Schnecken.
* @param name Name der Schnecke
* @param rasse Rasse der Schnecke
* @param vMax Maximalgeschwindigkeit der Schnecke
*/
public Rennschnecke(String name, String rasse, double vMax)
{
this.name = name;
this.rasse = rasse;
this.vMax = vMax;
this.strecke = 0;
}

/**
* Bewegt die Schnecke mit einer zufälligen Geschwindigkeit (im Abhängigkeit von der Maximalgeschwindigkeit).
*/
public void krieche()
{
Random random = new Random();
// Mximalgeschwindigkeit wird mit 0,01..1 multipliziert
this.strecke += vMax * (random.nextInt(100) + 1) / 100;
}

/**
* Gibt den Namen der Schnecke zurück.
* @return Name
*/
public String getName()
{
return name;
}

/**
* Gibt die Rasse der Schnecke zurück.
* @return Rasse
*/
public String getRasse()
{
return rasse;
}

/**
* Gibt die Maximalgeschwindigkeit zurück.
* @return Maximalgeschwindigkeit
*/
public double getVMax()
{
return vMax;
}

/**
* Gibt die bereits zurückgelegte Strecke zurück.
* @return zurückgelegt Strecke
*/
public double getStrecke()
{
return strecke;
}

public String toString()
{
return "(" + name + "." + rasse + ":" + vMax + "@" + strecke + ")";
}

/**
* Main-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennschnecke snail = new Rennschnecke("andre", "human", 100);
System.out.println(snail);
}
}// class Rennschnecke
</nowiki>

== Rennen.java ==

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;
import java.util.Iterator;

/**
* Ein Rennen, an dem Schnecken teilnehmen.
* @author André Schulz
* @version 1.0
*/
public class Rennen
{
private String name;
private ArrayList<Rennschnecke> schnecken;
private double renndistanz;

/**
* Konstruktor für Schneckenrennen 
* (Punkt 3)
* @param name Name des Schneckenrennens
* @param renndistanz distance off the race
*/
public Rennen(String name, double renndistanz)
{
this.name = name;
//leere ArrayList von Schnecken
this.schnecken = new ArrayList<Rennschnecke>();
this.renndistanz = renndistanz;
}

/**
* Fügt eine Schnecke dem Rennen hinzu. 
*(Punkt 4)
* @param schnecke eine zum Rennen hinzuzufügende Schnecke
* @throws IllegalArgumentException wenn versucht wird eine Schnecke mehrmals hinzuzufügen
*/
public void addRennschnecke(Rennschnecke schnecke)
{
//überprüfen, ob die Schnecke schon am Rennen teilnimmt (Doppelteilnahme verhindern)
//(Zustazpunkt 1)
if (this.schnecken.contains(schnecke))
{
//Exception werfen, wenn die Schnecke schon am Rennen teilnimmt
//=> muss ein Programmierfehler sein
throw new IllegalArgumentException("This snail is alredy at this race!");
}

this.schnecken.add(schnecke);
}

/**
* Entfernt eine Schnecke aus dem Rennen. 
* (entfernt alle Schnecken, die den jeweiligen Namen haben) 
* (Punkt 5)
* @param name Name der zu entfernende(n) Schnecke(n)
*/
public void removeRennschnecke(String name)
{
Rennschnecke schnecke;
//Iterator um die ArrayList zu durchlaufen
Iterator<Rennschnecke> iter = schnecken.iterator();

//solange es noch Elemente in der ArrayList gibt...
while (iter.hasNext())
{
//...sich den nächsten Eintrag nehmen...
schnecke = iter.next();

//...und überprüfen ob der Name mit dem zu entfernenden Namen übereinstimmt...
if (schnecke.getName().equals(name))
{
//...wenn, dann diesen Eintrag aus der ArrayList entfernen
iter.remove();
}// if
}// while
}// removeSnail

public String toString()
{
//(Punkt 6)

//StringBuilder ist Classe um Strings zu "bauen"
StringBuilder sb = new StringBuilder();

//Metadaten des Rennens (Name, Teilnehmeranzahl, Distanz)
sb.append(this.name + "(" + this.schnecken.size() + ") :" + this.renndistanz + "\n");

//die gesamte ArrayList durchlaufen und alle Schnecke hinzufügen
for (Rennschnecke snail : this.schnecken)
{
sb.append(snail);
sb.append("\n");
}// for

//wenn es einen Gewinner gibt
if (this.getGewinner() != null)
{
//...dann wird er hinzugefügt
sb.append("Gewinner:");
sb.append(this.getGewinner());
}
else
{
//..ansonsten nicht
sb.append("Rennen noch nicht gestartet!");
}

sb.append("\n");

//den gebauten String in eine echte Zeichenkette konvertieren
return sb.toString();
}// toString

/**
* Methode liefert auch einen String, welcher das Rennen repräsentiert,
* doch ist der Aufbau etwas übersichtlicher. (tabellarisch)
* @return String-Repräsentation des Schneckenrennens
*/
public String getPrintString()
{
StringBuilder sb = new StringBuilder();

sb.append("Rennen: '");
sb.append(this.name);
sb.append("' Teilnehmer: ");
sb.append(this.schnecken.size());
sb.append(" Distanz: ");
sb.append(this.renndistanz);
sb.append("\nSchnecken:\n");
sb.append("+Name\t+Rasse\t+vMax\t+Strecke\n");

for (Rennschnecke snail : this.schnecken)
{
sb.append(snail.getName());
sb.append("\t");//zwischen den einzelnen Atributen der Schnecken wird ein TabStop eingefügt
sb.append(snail.getRasse());
sb.append("\t");
sb.append(snail.getVMax());
sb.append("\t");
sb.append(snail.getStrecke());
sb.append("\t\n");
}// for

if (this.getGewinner() != null)
{
sb.append("Gewinner:");
sb.append(this.getGewinner());
}
else
{
sb.append("Rennen noch nicht gestartet!");
}

sb.append("\n");

return sb.toString();
}//getPrintString

/**
* Gibt das Rennen tabellarisch auf der Konsole aus.
*/
public void print()
{
System.out.println(getPrintString());
}// print

/**
* Gibt den Gewinner des Rennens zurück. 
* (Gibt <code>null</code> zurück, wenn das Rennen noch nciht beendet wurde.) 
* (Punkt 8)
* @return Gewinner des Rennens
*/
public Rennschnecke getGewinner()
{
Rennschnecke gewinner = null;//bis jetzt ist noch keiner bekannt...

//durchlaufe alle Schnecken...
for (Rennschnecke schnecke : schnecken)
{
//...überprüfe ob eine die Renndistanz zurückgelegt hat
if (schnecke.getStrecke() > this.renndistanz)
{
//wenn bisher noch kein gewinner ermittelt wurde...
if (gewinner == null)
{
//...dann ist die Schnecke der gewinner
gewinner = schnecke;
}
else
{
//...andernfalls ist die Schnecke welche weiter ist der Gewinner
//(Zusatzpunkt 3)
if (schnecke.getStrecke() > gewinner.getStrecke())
{
gewinner = schnecke;
}
}
}// if
}// for

return gewinner;
}//getWinner

/**
* Gibt alle Schnecken zurück.
* @return alle Schnecken
*/
public ArrayList<Rennschnecke> getSchnecken()
{
return this.schnecken;
}

/**
* Gibt den Namen des Rennens zurück
* @return Rennname
*/
public String getName()
{
return this.name;
}

/**
* Lässt alle Schnecken ein mal kriechen. 
* (Punkt 9)
*/
public void lasseSchneckenKriechen()
{
for (Rennschnecke snail : schnecken)
{
snail.krieche();
}
}

/**
* Führt das Rennen durch 
* Bewegt alle Schnecken so lange, bis eine im Zeil ist. 
* (Punkt 10)
*/
public void durchfuehren()
{
System.out.println("Rennen '" + this.name + "' wird durchgeführt...");

//so lange es keinen Gewinner gibt...
while (this.getGewinner() == null)
{
//...alle Schnecken ein mal kriechen lassen.
this.lasseSchneckenKriechen();
}// while
}

/**
* Maim-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennen testRennen = new Rennen("Test", 100000);

testRennen.addRennschnecke(new Rennschnecke("andre", "human", 100));
testRennen.addRennschnecke(new Rennschnecke("klaus", "human", 90));
testRennen.addRennschnecke(new Rennschnecke("hans", "human", 75));

System.out.println(testRennen);

testRennen.durchfuehren();
System.out.println(testRennen);
}
}// class Rennen
</nowiki>

== Wettbuero.java ==

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;

/**
* Wettbüro (einfache Version)
* @author André Schulz
* @version 1.0
*/
public class Wettbuero
{
private Rennen rennen;
private ArrayList<Wette> wetten;
private double faktor;

/**
* Konstruktor für ein Wettbüro.
* @param rennen das Rennen, welches dieses Wettbüro betreuen soll
* @param faktor der Faktor, welcher bei gewinnen ausgezahlt wird
* @throws IllegalArgumentException wenn versucht wird einen negativen Wetteinsatz zu verwenden
*/
public Wettbuero(Rennen rennen, double faktor)
{
// wenn der Wetteinsatz negativ sein soll => Fehler
// (Zusatzpunkt 2)
if (faktor < 0)
{
throw new IllegalArgumentException("Es dürfen keine Negativen Wetten abgeschlossen werden!");
}

this.rennen = rennen;
this.faktor = faktor;
this.wetten = new ArrayList<Wette>();
}

/**
* Fügt eine Wette hinzu. 
* (Punkt 2)
* @param schneckenname Name der Schnecke auf die gesetzt wird
* @param wetteinsatz der Wetteinsatz
* @param spielername Name des Spielers, welche doe Wette tätigt
*/
public void wetteAnnehmen(String schneckenname, double wetteinsatz, String spielername)
{
wetten.add(new Wette(schneckenname, wetteinsatz, spielername));
}

/**
* Führt das Rennen durch. 
* (Punkt 3)
*/
public void rennenDurchfuehren()
{
this.rennen.durchfuehren();
}

public String toString()
{
// (Punkt 4)

StringBuilder sb = new StringBuilder();

// zu erst das Rennen ausgeben
sb.append("Renen:\n");
sb.append(this.rennen);
sb.append("Wetten:\n");

// dann Wetten ausgeben, wenn vorhanden
if (wetten.size() > 0)
{
for (Wette wette : this.wetten)
{
sb.append(wette);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

return sb.toString();
}// toString

/**
* Gibt das Wettbüro, mit dem dazugehörigen Rennen aus.
*/
public void print()
{
StringBuilder sb = new StringBuilder();

sb.append("Wettbüro für:\n");
sb.append(this.rennen.getPrintString());
sb.append("Wetten:\n");

if (wetten.size() > 0)
{
for (Wette bet : this.wetten)
{
sb.append(bet);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

System.out.println(sb.toString());
}// print

/**
* Main-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennen rennen = new Rennen("testRace", 100000);

rennen.addRennschnecke(new Rennschnecke("andre", "human", 100));
rennen.addRennschnecke(new Rennschnecke("klaus", "human", 90));
rennen.addRennschnecke(new Rennschnecke("hans", "human", 75));

Wettbuero wettbuero = new Wettbuero(rennen, 1.5);

// TODO Wetten hinzufügen

wettbuero.print();

wettbuero.rennenDurchfuehren();

wettbuero.print();

}// main

/**
* Wette.
* @author André Schulz
* @version 1.0
*/
private class Wette
{
private String spielerName;
private String schneckenName;
private double wetteinsatz;

/**
* Konstruktor erstellt eine neue Wette.
* @param schneckenName Name der Schnecke auf die gesetzt werden soll.
* @param wetteinsatz der Wetteinsatz für die Wette
* @param spielerName der Name des Spielers
*/
public Wette(String schneckenName, double wetteinsatz, String spielerName)
{
if (wetteinsatz < 0)
{
throw new IllegalArgumentException("betAmount must be >=0!");
}

this.spielerName = spielerName;
this.schneckenName = schneckenName;
this.wetteinsatz = wetteinsatz;
}// Wette

public String toString()
{
return this.spielerName + ":" + this.wetteinsatz + "@" + this.schneckenName;
}

/**
* Gibt den Namen des Spielers dieser Wette zurück.
* @return Name des Spielers
*/
public String getSpielername()
{
return spielerName;
}

/**
* Gibt den Namen der Schnecke zurück, auf die gesetzt wurde.
* @return Name der Schnecke
*/
public String getSchneckenname()
{
return schneckenName;
}

/**
* Gibt den Wetteinsatz zurück.
* @return Wetteinsatz
*/
public double getWetteinsatz()
{
return wetteinsatz;
}
}// class Wette
}// class Wettbuero</nowiki>

=== Wettbuero_2.java (verbesserte Version) ===

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;
import java.util.Collections;

/**
* Wettbüro (verbesserte Version)
* @author André Schulz
* @version 2.0
*/
public class Wettbuero_2
{
private Rennen rennen;
private ArrayList<Spieler> spieler;
private ArrayList<Wette> wetten;
private double faktor;
private Rennschnecke gewinner;

/**
* Konstruktor für ein Wettbüro.
* @param rennen das Rennen, welches dieses Wettbüro betreuen soll
* @param faktor der Faktor, welcher bei gewinnen ausgezahlt wird
* @throws IllegalArgumentException wenn versucht wird einen negativen Wetteinsatz zu verwenden
*/
public Wettbuero_2(Rennen rennen, double faktor)
{
// wenn der Wetteinsatz negativ sein sollte => Fehler
// (Zusatzpunkt 2)
if (faktor < 0)
{
throw new IllegalArgumentException("Es dürfen keine Negativen Wetten abgeschlossen werden!");
}

this.rennen = rennen;
this.faktor = faktor;
this.spieler = new ArrayList<Spieler>();
this.wetten = new ArrayList<Wette>();
}// Wettbuero_2

/**
* Fügt dem Wettbüro einen neuen Spieler hinzu.
* @param spielerName der Name des Spielers
*/
public Spieler addSpieler(String spielerName)
{
// neunen Spieler erstellen
Spieler spieler = new Spieler(spielerName);

// wenn der Spieler noch nicht vorhanden ist => hinzufügen
if (!this.spieler.contains(spieler))
{
this.spieler.add(spieler);
}

return spieler;
}// addSpieler

/**
* Fügt eine Wette hinzu.
* @param schneckenName der Name der Schnecke, auf die gesetzt werden soll
* @param wetteinsatz der Wetteinsatz aud die Schnecke
* @param spielerName der Name des Spielers
*/
public void addWette(String schneckenName, double wetteinsatz, Spieler spieler)
{
for (Rennschnecke snail : this.rennen.getSchnecken())
{
if (snail.getName().equals(schneckenName))
{
wetten.add(new Wette(snail, wetteinsatz, spieler));
return;
}// if
}// for

throw new IllegalArgumentException("Eine Schnecke mit dem Namen '" + schneckenName + "' gibts in dem Rennen '" + this.rennen.getName() + " nicht!");
}// addWette

/**
* Führt das Rennen durch.
*/
public void rennenDurchfuehren()
{
this.rennen.durchfuehren();
this.gewinner = this.rennen.getGewinner();
}

public String toString()
{
StringBuilder sb = new StringBuilder();

sb.append("Rennen:\n");
sb.append(this.rennen);
sb.append("Wetten:\n");

if (wetten.size() > 0)
{
for (Wette bet : this.wetten)
{
sb.append(bet);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

return sb.toString();
}// toString

/**
* Methode wertet alle Wetten aus.
*/
public void wettenAuswerten()
{
for (Wette wette : this.wetten)
{
wette.setzeGewinn(this.gewinner, this.faktor);
}
}// wettenAuswerten

/**
* Main-Mthode zum Testen.
* @param args (none)
*/
public static void main(String[] args)
{
// rennen erstellen
Rennen race = new Rennen("Testrennen", 100000);

// Schnecken hinzufügen
race.addRennschnecke(new Rennschnecke("andre", "Mensch", 100));
race.addRennschnecke(new Rennschnecke("klaus", "Mensch", 90));
race.addRennschnecke(new Rennschnecke("hans", "Mensch", 75));

// Wettbüro erstellen
Wettbuero_2 wettbuero = new Wettbuero_2(race, 1.5);

// Spieler erstellen
Spieler spielerAndre = wettbuero.addSpieler("andre");
Spieler spielerHans = wettbuero.addSpieler("hans");

// wetten setzen
wettbuero.addWette("andre", 100, spielerAndre);
wettbuero.addWette("hans", 100, spielerHans);
wettbuero.addWette("andre", 10, spielerHans);

// Wettbüro ausgeben (vor dem Lauf)
System.out.println(wettbuero);

// Rennen durchführen udn auswerten
wettbuero.rennenDurchfuehren();
wettbuero.wettenAuswerten();

// Wettbüro ausgeben (nach dem Lauf)
System.out.println(wettbuero);

// zeigt die einzelnen Spieler
System.out.println("Spielerübersicht:");
wettbuero.zeigeSpieler();
}// main

/**
* Methode gibt alle Spieler mit ihren jeweiligen Wetten übersichtlich aus.
*/
public void zeigeSpieler()
{
// sortieren aller Wetten (nach Spielername)
Collections.sort(this.wetten);

String oldSpielerName = "";
double wetteinsatz = 0;// Gesamtwetteinsatz eines Spielers
double wettgewinn = 0;// Gesamtwettgewinn eines Spielers

System.out.println("Spieler\tSchnecke\tEinsatz\tGewinn\tSaldo");
System.out.println("================================================");

for (Wette wette : this.wetten)
{
if (wette.spieler.name == oldSpielerName)
{
System.out.println("\t" + wette.schnecke.getRasse() + "." + wette.schnecke.getName() + "\t" + wette.wetteinsatz + "\t" + wette.wettgewinn + "\t" + (wette.wettgewinn - wette.wetteinsatz));

wetteinsatz += wette.wetteinsatz;
wettgewinn += wette.wettgewinn;
}
else
{
if (oldSpielerName != "")
{
System.out.println("\t\t\t------------------------");
System.out.println("\t\t\t" + wetteinsatz + "\t" + wettgewinn + "\t" + (wettgewinn - wetteinsatz));
}// if

System.out.println(wette.spieler.name);
System.out.println("\t" + wette.schnecke.getRasse() + "." + wette.schnecke.getName() + "\t" + wette.wetteinsatz + "\t" + wette.wettgewinn + "\t" + (wette.wettgewinn - wette.wetteinsatz));

oldSpielerName = wette.spieler.name;
wetteinsatz = wette.wetteinsatz;
wettgewinn = wette.wettgewinn;
}// else
}// for

if (oldSpielerName != "")
{
System.out.println("\t\t\t------------------------");
System.out.println("\t\t\t" + wetteinsatz + "\t" + wettgewinn + "\t" + (wettgewinn - wetteinsatz));
}// if
}// zeigeSpieler

/**
* Eine Wette.
*/
private class Wette implements Comparable<Wette>
{
private Spieler spieler;
private Rennschnecke schnecke;
private double wetteinsatz;
private double wettgewinn;

/**
* Konstruktor für wetten.
* @param schnecke die Schnecke
* @param wetteinsatz der Wetteinsatz
* @param spieler der Spieler der wettet
*/
public Wette(Rennschnecke schnecke, double wetteinsatz, Spieler spieler)
{
if (wetteinsatz < 0)
{
throw new IllegalArgumentException("Wetteinsatz muss >=0 sein!");
}

this.spieler = spieler;
this.schnecke = schnecke;
this.wetteinsatz = wetteinsatz;
this.wettgewinn = -1;
}// Wette

/**
* Methode setzt in Abhängigkeit vom Gewinner den Wettgewinn.
* @param gewinner die Schnecke, welce das Rennen gewonnen hat
* @param faktor der Gewinnfaktor
*/
public void setzeGewinn(Rennschnecke gewinner, double faktor)
{
if (this.schnecke.equals(gewinner))
{
// auf Gewinner gesetzt => Wettgewinn setzen
this.wettgewinn = this.wetteinsatz * faktor;
}
else
{
// auf andere Schnecke gesetzt => kein Gewinn
this.wettgewinn = 0;
}
}// setzeGewinn

public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append(this.spieler);
sb.append(":");
sb.append(this.wetteinsatz);
sb.append("@");
sb.append(this.schnecke);

if (this.wettgewinn != -1)
{
sb.append("->");
sb.append(this.wettgewinn);
}

return sb.toString();
}// toString

@Override
public int compareTo(Wette other)
{
return this.spieler.name.compareTo(other.spieler.name);
}
}// class Bet

/**
* Ein Spieler welcher Wetten tätigt.
* @author André Schulz
* @version 1.0
*/
public class Spieler
{
private String name;

public Spieler(String name)
{
this.name = name;
}

public String getName()
{
return this.name;
}

public String toString()
{
return name;
}
}// calss Spieler
}// class Wettbuero_2
</nowiki>

Javakurs/Übungsaufgaben/Rennschnecke/Musterloesung

2010-03-24T13:53:27Z

Andre: Die Seite wurde neu angelegt: „= Rennschnecke - Musterlösung = == Rennschnecke.java == <nowiki> package Schneckenrennen; import java.util.Random; /** * Eine Schnecke, welche an Rennen te...“

= Rennschnecke - Musterlösung =

== Rennschnecke.java ==

<nowiki>
package Schneckenrennen;

import java.util.Random;

/**
* Eine Schnecke, welche an Rennen teilnehmen kann.
* @author André Schulz
* @version 1.0
*/
public class Rennschnecke
{
private String name;
private String rasse;
private double vMax;
private double strecke;// zurückgelegte Strcke am Startpunkt

/**
* Konstruktor für Schnecken.
* @param name Name der Schnecke
* @param rasse Rasse der Schnecke
* @param vMax Maximalgeschwindigkeit der Schnecke
*/
public Rennschnecke(String name, String rasse, double vMax)
{
this.name = name;
this.rasse = rasse;
this.vMax = vMax;
this.strecke = 0;
}

/**
* Bewegt die Schnecke mit einer zufälligen Geschwindigkeit (im Abhängigkeit von der Maximalgeschwindigkeit).
*/
public void krieche()
{
Random random = new Random();
// Mximalgeschwindigkeit wird mit 0,01..1 multipliziert
this.strecke += vMax * (random.nextInt(100) + 1) / 100;
}

/**
* Gibt den Namen der Schnecke zurück.
* @return Name
*/
public String getName()
{
return name;
}

/**
* Gibt die Rasse der Schnecke zurück.
* @return Rasse
*/
public String getRasse()
{
return rasse;
}

/**
* Gibt die Maximalgeschwindigkeit zurück.
* @return Maximalgeschwindigkeit
*/
public double getVMax()
{
return vMax;
}

/**
* Gibt die bereits zurückgelegte Strecke zurück.
* @return zurückgelegt Strecke
*/
public double getStrecke()
{
return strecke;
}

public String toString()
{
return "(" + name + "." + rasse + ":" + vMax + "@" + strecke + ")";
}

/**
* Main-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennschnecke snail = new Rennschnecke("andre", "human", 100);
System.out.println(snail);
}
}// class Rennschnecke
</nowiki>
== Rennen.java ==

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;
import java.util.Iterator;

/**
* Ein Rennen, an dem Schnecken teilnehmen.
* @author André Schulz
* @version 1.0
*/
public class Rennen
{
private String name;
private ArrayList<Rennschnecke> schnecken;
private double renndistanz;

/**
* Konstruktor für Schneckenrennen 
* (Punkt 3)
* @param name Name des Schneckenrennens
* @param renndistanz distance off the race
*/
public Rennen(String name, double renndistanz)
{
this.name = name;
//leere ArrayList von Schnecken
this.schnecken = new ArrayList<Rennschnecke>();
this.renndistanz = renndistanz;
}

/**
* Fügt eine Schnecke dem Rennen hinzu. 
*(Punkt 4)
* @param schnecke eine zum Rennen hinzuzufügende Schnecke
* @throws IllegalArgumentException wenn versucht wird eine Schnecke mehrmals hinzuzufügen
*/
public void addRennschnecke(Rennschnecke schnecke)
{
//überprüfen, ob die Schnecke schon am Rennen teilnimmt (Doppelteilnahme verhindern)
//(Zustazpunkt 1)
if (this.schnecken.contains(schnecke))
{
//Exception werfen, wenn die Schnecke schon am Rennen teilnimmt
//=> muss ein Programmierfehler sein
throw new IllegalArgumentException("This snail is alredy at this race!");
}

this.schnecken.add(schnecke);
}

/**
* Entfernt eine Schnecke aus dem Rennen. 
* (entfernt alle Schnecken, die den jeweiligen Namen haben) 
* (Punkt 5)
* @param name Name der zu entfernende(n) Schnecke(n)
*/
public void removeRennschnecke(String name)
{
Rennschnecke schnecke;
//Iterator um die ArrayList zu durchlaufen
Iterator<Rennschnecke> iter = schnecken.iterator();

//solange es noch Elemente in der ArrayList gibt...
while (iter.hasNext())
{
//...sich den nächsten Eintrag nehmen...
schnecke = iter.next();

//...und überprüfen ob der Name mit dem zu entfernenden Namen übereinstimmt...
if (schnecke.getName().equals(name))
{
//...wenn, dann diesen Eintrag aus der ArrayList entfernen
iter.remove();
}// if
}// while
}// removeSnail

public String toString()
{
//(Punkt 6)

//StringBuilder ist Classe um Strings zu "bauen"
StringBuilder sb = new StringBuilder();

//Metadaten des Rennens (Name, Teilnehmeranzahl, Distanz)
sb.append(this.name + "(" + this.schnecken.size() + ") :" + this.renndistanz + "\n");

//die gesamte ArrayList durchlaufen und alle Schnecke hinzufügen
for (Rennschnecke snail : this.schnecken)
{
sb.append(snail);
sb.append("\n");
}// for

//wenn es einen Gewinner gibt
if (this.getGewinner() != null)
{
//...dann wird er hinzugefügt
sb.append("Gewinner:");
sb.append(this.getGewinner());
}
else
{
//..ansonsten nicht
sb.append("Rennen noch nicht gestartet!");
}

sb.append("\n");

//den gebauten String in eine echte Zeichenkette konvertieren
return sb.toString();
}// toString

/**
* Methode liefert auch einen String, welcher das Rennen repräsentiert,
* doch ist der Aufbau etwas übersichtlicher. (tabellarisch)
* @return String-Repräsentation des Schneckenrennens
*/
public String getPrintString()
{
StringBuilder sb = new StringBuilder();

sb.append("Rennen: '");
sb.append(this.name);
sb.append("' Teilnehmer: ");
sb.append(this.schnecken.size());
sb.append(" Distanz: ");
sb.append(this.renndistanz);
sb.append("\nSchnecken:\n");
sb.append("+Name\t+Rasse\t+vMax\t+Strecke\n");

for (Rennschnecke snail : this.schnecken)
{
sb.append(snail.getName());
sb.append("\t");//zwischen den einzelnen Atributen der Schnecken wird ein TabStop eingefügt
sb.append(snail.getRasse());
sb.append("\t");
sb.append(snail.getVMax());
sb.append("\t");
sb.append(snail.getStrecke());
sb.append("\t\n");
}// for

if (this.getGewinner() != null)
{
sb.append("Gewinner:");
sb.append(this.getGewinner());
}
else
{
sb.append("Rennen noch nicht gestartet!");
}

sb.append("\n");

return sb.toString();
}//getPrintString

/**
* Gibt das Rennen tabellarisch auf der Konsole aus.
*/
public void print()
{
System.out.println(getPrintString());
}// print

/**
* Gibt den Gewinner des Rennens zurück. 
* (Gibt <code>null</code> zurück, wenn das Rennen noch nciht beendet wurde.) 
* (Punkt 8)
* @return Gewinner des Rennens
*/
public Rennschnecke getGewinner()
{
Rennschnecke gewinner = null;//bis jetzt ist noch keiner bekannt...

//durchlaufe alle Schnecken...
for (Rennschnecke schnecke : schnecken)
{
//...überprüfe ob eine die Renndistanz zurückgelegt hat
if (schnecke.getStrecke() > this.renndistanz)
{
//wenn bisher noch kein gewinner ermittelt wurde...
if (gewinner == null)
{
//...dann ist die Schnecke der gewinner
gewinner = schnecke;
}
else
{
//...andernfalls ist die Schnecke welche weiter ist der Gewinner
//(Zusatzpunkt 3)
if (schnecke.getStrecke() > gewinner.getStrecke())
{
gewinner = schnecke;
}
}
}// if
}// for

return gewinner;
}//getWinner

/**
* Gibt alle Schnecken zurück.
* @return alle Schnecken
*/
public ArrayList<Rennschnecke> getSchnecken()
{
return this.schnecken;
}

/**
* Gibt den Namen des Rennens zurück
* @return Rennname
*/
public String getName()
{
return this.name;
}

/**
* Lässt alle Schnecken ein mal kriechen. 
* (Punkt 9)
*/
public void lasseSchneckenKriechen()
{
for (Rennschnecke snail : schnecken)
{
snail.krieche();
}
}

/**
* Führt das Rennen durch 
* Bewegt alle Schnecken so lange, bis eine im Zeil ist. 
* (Punkt 10)
*/
public void durchfuehren()
{
System.out.println("Rennen '" + this.name + "' wird durchgeführt...");

//so lange es keinen Gewinner gibt...
while (this.getGewinner() == null)
{
//...alle Schnecken ein mal kriechen lassen.
this.lasseSchneckenKriechen();
}// while
}

/**
* Maim-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennen testRennen = new Rennen("Test", 100000);

testRennen.addRennschnecke(new Rennschnecke("andre", "human", 100));
testRennen.addRennschnecke(new Rennschnecke("klaus", "human", 90));
testRennen.addRennschnecke(new Rennschnecke("hans", "human", 75));

System.out.println(testRennen);

testRennen.durchfuehren();
System.out.println(testRennen);
}
}// class Rennen
</nowiki>
== Wettbuero.java ==

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;

/**
* Wettbüro (einfache Version)
* @author André Schulz
* @version 1.0
*/
public class Wettbuero
{
private Rennen rennen;
private ArrayList<Wette> wetten;
private double faktor;

/**
* Konstruktor für ein Wettbüro.
* @param rennen das Rennen, welches dieses Wettbüro betreuen soll
* @param faktor der Faktor, welcher bei gewinnen ausgezahlt wird
* @throws IllegalArgumentException wenn versucht wird einen negativen Wetteinsatz zu verwenden
*/
public Wettbuero(Rennen rennen, double faktor)
{
// wenn der Wetteinsatz negativ sein soll => Fehler
// (Zusatzpunkt 2)
if (faktor < 0)
{
throw new IllegalArgumentException("Es dürfen keine Negativen Wetten abgeschlossen werden!");
}

this.rennen = rennen;
this.faktor = faktor;
this.wetten = new ArrayList<Wette>();
}

/**
* Fügt eine Wette hinzu. 
* (Punkt 2)
* @param schneckenname Name der Schnecke auf die gesetzt wird
* @param wetteinsatz der Wetteinsatz
* @param spielername Name des Spielers, welche doe Wette tätigt
*/
public void wetteAnnehmen(String schneckenname, double wetteinsatz, String spielername)
{
wetten.add(new Wette(schneckenname, wetteinsatz, spielername));
}

/**
* Führt das Rennen durch. 
* (Punkt 3)
*/
public void rennenDurchfuehren()
{
this.rennen.durchfuehren();
}

public String toString()
{
// (Punkt 4)

StringBuilder sb = new StringBuilder();

// zu erst das Rennen ausgeben
sb.append("Renen:\n");
sb.append(this.rennen);
sb.append("Wetten:\n");

// dann Wetten ausgeben, wenn vorhanden
if (wetten.size() > 0)
{
for (Wette wette : this.wetten)
{
sb.append(wette);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

return sb.toString();
}// toString

/**
* Gibt das Wettbüro, mit dem dazugehörigen Rennen aus.
*/
public void print()
{
StringBuilder sb = new StringBuilder();

sb.append("Wettbüro für:\n");
sb.append(this.rennen.getPrintString());
sb.append("Wetten:\n");

if (wetten.size() > 0)
{
for (Wette bet : this.wetten)
{
sb.append(bet);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

System.out.println(sb.toString());
}// print

/**
* Main-Methode (nur zum Testen)
* @param args (keine)
*/
public static void main(String[] args)
{
Rennen rennen = new Rennen("testRace", 100000);

rennen.addRennschnecke(new Rennschnecke("andre", "human", 100));
rennen.addRennschnecke(new Rennschnecke("klaus", "human", 90));
rennen.addRennschnecke(new Rennschnecke("hans", "human", 75));

Wettbuero wettbuero = new Wettbuero(rennen, 1.5);

// TODO Wetten hinzufügen

wettbuero.print();

wettbuero.rennenDurchfuehren();

wettbuero.print();

}// main

// ================================================================================

/**
* Wette.
* @author André Schulz
* @version 1.0
*/
private class Wette
{
private String spielerName;
private String schneckenName;
private double wetteinsatz;

/**
* Konstruktor erstellt eine neue Wette.
* @param schneckenName Name der Schnecke auf die gesetzt werden soll.
* @param wetteinsatz der Wetteinsatz für die Wette
* @param spielerName der Name des Spielers
*/
public Wette(String schneckenName, double wetteinsatz, String spielerName)
{
if (wetteinsatz < 0)
{
throw new IllegalArgumentException("betAmount must be >=0!");
}

this.spielerName = spielerName;
this.schneckenName = schneckenName;
this.wetteinsatz = wetteinsatz;
}// Wette

public String toString()
{
return this.spielerName + ":" + this.wetteinsatz + "@" + this.schneckenName;
}

/**
* Gibt den Namen des Spielers dieser Wette zurück.
* @return Name des Spielers
*/
public String getSpielername()
{
return spielerName;
}

/**
* Gibt den Namen der Schnecke zurück, auf die gesetzt wurde.
* @return Name der Schnecke
*/
public String getSchneckenname()
{
return schneckenName;
}

/**
* Gibt den Wetteinsatz zurück.
* @return Wetteinsatz
*/
public double getWetteinsatz()
{
return wetteinsatz;
}
}// class Wette
}// class Wettbuero</nowiki>
=== Wettbuero_2.java ===

<nowiki>
package Schneckenrennen;

import java.util.ArrayList;
import java.util.Collections;

/**
* Wettbüro (verbesserte Version)
* @author André Schulz
* @version 2.0
*/
public class Wettbuero_2
{
private Rennen rennen;
private ArrayList<Spieler> spieler;
private ArrayList<Wette> wetten;
private double faktor;
private Rennschnecke gewinner;

/**
* Konstruktor für ein Wettbüro.
* @param rennen das Rennen, welches dieses Wettbüro betreuen soll
* @param faktor der Faktor, welcher bei gewinnen ausgezahlt wird
* @throws IllegalArgumentException wenn versucht wird einen negativen Wetteinsatz zu verwenden
*/
public Wettbuero_2(Rennen rennen, double faktor)
{
// wenn der Wetteinsatz negativ sein sollte => Fehler
// (Zusatzpunkt 2)
if (faktor < 0)
{
throw new IllegalArgumentException("Es dürfen keine Negativen Wetten abgeschlossen werden!");
}

this.rennen = rennen;
this.faktor = faktor;
this.spieler = new ArrayList<Spieler>();
this.wetten = new ArrayList<Wette>();
}// Wettbuero_2

/**
* Fügt dem Wettbüro einen neuen Spieler hinzu.
* @param spielerName der Name des Spielers
*/
public Spieler addSpieler(String spielerName)
{
// neunen Spieler erstellen
Spieler spieler = new Spieler(spielerName);

// wenn der Spieler noch nicht vorhanden ist => hinzufügen
if (!this.spieler.contains(spieler))
{
this.spieler.add(spieler);
}

return spieler;
}// addSpieler

/**
* Fügt eine Wette hinzu.
* @param schneckenName der Name der Schnecke, auf die gesetzt werden soll
* @param wetteinsatz der Wetteinsatz aud die Schnecke
* @param spielerName der Name des Spielers
*/
public void addWette(String schneckenName, double wetteinsatz, Spieler spieler)
{
for (Rennschnecke snail : this.rennen.getSchnecken())
{
if (snail.getName().equals(schneckenName))
{
wetten.add(new Wette(snail, wetteinsatz, spieler));
return;
}// if
}// for

throw new IllegalArgumentException("Eine Schnecke mit dem Namen '" + schneckenName + "' gibts in dem Rennen '" + this.rennen.getName() + " nicht!");
}// addWette

/**
* Führt das Rennen durch.
*/
public void rennenDurchfuehren()
{
this.rennen.durchfuehren();
this.gewinner = this.rennen.getGewinner();
}

public String toString()
{
StringBuilder sb = new StringBuilder();

sb.append("Rennen:\n");
sb.append(this.rennen);
sb.append("Wetten:\n");

if (wetten.size() > 0)
{
for (Wette bet : this.wetten)
{
sb.append(bet);
sb.append("\n");
}// for
}
else
{
sb.append("(keine)");
}

return sb.toString();
}// toString

/**
* Methode wertet alle Wetten aus.
*/
public void wettenAuswerten()
{
for (Wette wette : this.wetten)
{
wette.setzeGewinn(this.gewinner, this.faktor);
}
}// wettenAuswerten

/**
* Main-Mthode zum Testen.
* @param args (none)
*/
public static void main(String[] args)
{
// rennen erstellen
Rennen race = new Rennen("Testrennen", 100000);

// Schnecken hinzufügen
race.addRennschnecke(new Rennschnecke("andre", "Mensch", 100));
race.addRennschnecke(new Rennschnecke("klaus", "Mensch", 90));
race.addRennschnecke(new Rennschnecke("hans", "Mensch", 75));

// Wettbüro erstellen
Wettbuero_2 wettbuero = new Wettbuero_2(race, 1.5);

// Spieler erstellen
Spieler spielerAndre = wettbuero.addSpieler("andre");
Spieler spielerHans = wettbuero.addSpieler("hans");

// wetten setzen
wettbuero.addWette("andre", 100, spielerAndre);
wettbuero.addWette("hans", 100, spielerHans);
wettbuero.addWette("andre", 10, spielerHans);

// Wettbüro ausgeben (vor dem Lauf)
System.out.println(wettbuero);

// Rennen durchführen udn auswerten
wettbuero.rennenDurchfuehren();
wettbuero.wettenAuswerten();

// Wettbüro ausgeben (nach dem Lauf)
System.out.println(wettbuero);

// zeigt die einzelnen Spieler
System.out.println("Spielerübersicht:");
wettbuero.zeigeSpieler();
}// main

/**
* Methode gibt alle Spieler mit ihren jeweiligen Wetten übersichtlich aus.
*/
public void zeigeSpieler()
{
// sortieren aller Wetten (nach Spielername)
Collections.sort(this.wetten);

String oldSpielerName = "";
double wetteinsatz = 0;// Gesamtwetteinsatz eines Spielers
double wettgewinn = 0;// Gesamtwettgewinn eines Spielers

System.out.println("Spieler\tSchnecke\tEinsatz\tGewinn\tSaldo");
System.out.println("================================================");

for (Wette wette : this.wetten)
{
if (wette.spieler.name == oldSpielerName)
{
System.out.println("\t" + wette.schnecke.getRasse() + "." + wette.schnecke.getName() + "\t" + wette.wetteinsatz + "\t" + wette.wettgewinn + "\t" + (wette.wettgewinn - wette.wetteinsatz));

wetteinsatz += wette.wetteinsatz;
wettgewinn += wette.wettgewinn;
}
else
{
if (oldSpielerName != "")
{
System.out.println("\t\t\t------------------------");
System.out.println("\t\t\t" + wetteinsatz + "\t" + wettgewinn + "\t" + (wettgewinn - wetteinsatz));
}// if

System.out.println(wette.spieler.name);
System.out.println("\t" + wette.schnecke.getRasse() + "." + wette.schnecke.getName() + "\t" + wette.wetteinsatz + "\t" + wette.wettgewinn + "\t" + (wette.wettgewinn - wette.wetteinsatz));

oldSpielerName = wette.spieler.name;
wetteinsatz = wette.wetteinsatz;
wettgewinn = wette.wettgewinn;
}// else
}// for

if (oldSpielerName != "")
{
System.out.println("\t\t\t------------------------");
System.out.println("\t\t\t" + wetteinsatz + "\t" + wettgewinn + "\t" + (wettgewinn - wetteinsatz));
}// if
}// zeigeSpieler

/**
* Eine Wette.
*/
private class Wette implements Comparable<Wette>
{
private Spieler spieler;
private Rennschnecke schnecke;
private double wetteinsatz;
private double wettgewinn;

/**
* Konstruktor für wetten.
* @param schnecke die Schnecke
* @param wetteinsatz der Wetteinsatz
* @param spieler der Spieler der wettet
*/
public Wette(Rennschnecke schnecke, double wetteinsatz, Spieler spieler)
{
if (wetteinsatz < 0)
{
throw new IllegalArgumentException("Wetteinsatz muss >=0 sein!");
}

this.spieler = spieler;
this.schnecke = schnecke;
this.wetteinsatz = wetteinsatz;
this.wettgewinn = -1;
}// Wette

/**
* Methode setzt in Abhängigkeit vom Gewinner den Wettgewinn.
* @param gewinner die Schnecke, welce das Rennen gewonnen hat
* @param faktor der Gewinnfaktor
*/
public void setzeGewinn(Rennschnecke gewinner, double faktor)
{
if (this.schnecke.equals(gewinner))
{
// auf Gewinner gesetzt => Wettgewinn setzen
this.wettgewinn = this.wetteinsatz * faktor;
}
else
{
// auf andere Schnecke gesetzt => kein Gewinn
this.wettgewinn = 0;
}
}// setzeGewinn

public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append(this.spieler);
sb.append(":");
sb.append(this.wetteinsatz);
sb.append("@");
sb.append(this.schnecke);

if (this.wettgewinn != -1)
{
sb.append("->");
sb.append(this.wettgewinn);
}

return sb.toString();
}// toString

@Override
public int compareTo(Wette other)
{
return this.spieler.name.compareTo(other.spieler.name);
}
}// class Bet

/**
* Ein Spieler welcher Wetten tätigt.
* @author André Schulz
* @version 1.0
*/
public class Spieler
{
private String name;

public Spieler(String name)
{
this.name = name;
}

public String getName()
{
return this.name;
}

public String toString()
{
return name;
}
}// calss Spieler
}// class Wettbuero
</nowiki>

Javakurs/Übungsaufgaben/Cäsar-Chiffre/Musterloesung

2010-03-24T13:38:16Z

Andre: Die Seite wurde neu angelegt: „= Cäsar-Chiffre - Musterlösung = Fas Verschlüsseln und Entschlüsseln wurde der Übersichtlichkeit halber in zwei Klassen aufgeteilt, welche eigenständig lau...“

= Cäsar-Chiffre - Musterlösung =

Fas Verschlüsseln und Entschlüsseln wurde der Übersichtlichkeit halber in zwei Klassen aufgeteilt, welche eigenständig lauffähig sind.

== CaesarEncode.java (Cäsar-Verschlüsselung) ==

Diese Klasse liest eine Datei ein, verschlüsselt sie und speichert sie anschließend.

<nowiki>
package caesar;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;

/**
* Programm welches eine Textdatei mit der Caesar-Verschiebung verschlüsselt. 
* Der Schluessel ist eine genze Zahl zwischen 0 und 26,
* um die alle "normalen" Buchstaben verschoben werden. 
* (nur <code>a..z</code> und <code>A..Z</code>) 
* Der Originaltext wird aus einer Datei eingelesen und
* verschlüsselt in eine andere geschrieben. 
* (eine vorhandene Datei wird dabei ueberschrieben) 
* Parameterliste: Dateiname (Eingabe), Schluessel, Dateiname (Ausgabe)
* @author André Schulz
* @version 1.0 (3/2009)
*/
public class CaesarEncode
{
/**
* Main-Methode fuehrt das Programm aus. 
* Programm verschiebt alle Buchstaben um <code>Schluessel</code> (zwischen 0 und 26).
* @param args [Dateiname fuer Eingabe, Schluessel, Dateiname fuer Ausgabe]
* @throws IOException falls Fehler beim Lesen der Datei auftreten
*/
public static void main(String[] args) throws IOException
{
// bei falscher Argument-Länge wird die Parameterliste ausgegeben
if (args.length != 3)
{
System.out.println("params: <fileIn> <key> <fileOut>");
// beenden des Programms
System.exit(0);
}

// ==++== lesen der Eingabedatei (Klartext)
System.out.println("reading");// Fortschrittausgabe

// erstellt Reader um aus Datei zu lesen
BufferedReader br = new BufferedReader(new FileReader(args[0]));

// liest eine Zeile aus der Datei ein
String line = br.readLine();

// Liste für die verschlüsselten Zeilen
LinkedList<String> encodedLines = new LinkedList<String>();
int key = -1;// initialisieren der Variable für die Verschiebung mit default-Wert

// Ermitteln des Schluessels und Fehlerbehandlung
try
{
// wandelt den String aus dem 2. Parameter in eine Zahl um
key = Integer.parseInt(args[1]);
}
catch (NumberFormatException e)
{
// wenn der String nicht in eine ganze Zahl umgewandelt werden konnte
// wird eine Fehlermeldung ausgegeben und beendet
System.out.println("could not parse key ('" + args[1] + "' is no number!)");
System.exit(0);
}

// Ueberpruefung ob der Schluessel im gueltigen Bereich liegt
if (key < 0 || key > 26)
{
// Fehlermeldung wenn Schluessel ausserhlab Bereich
System.out.println("key must be 0..26");
}

// es werden so lange Zeilen gelesen, wie vorhanden
while (line != null)
{
// fuegt die verschluesselten Zeilen der Zeilen-Liste hinzu
encodedLines.add(encode(line, key));
line = br.readLine();// lesen der naechsten Zeile
}

// schliesst den Reader, da nicht mehr benoetigt
// (Datei ist wieder fuer andere Programme frei)
br.close();
// ==--== lesen der Eingabedatei (Klartext)

// ==++== schreiben der Ausgabedatei (verschluesselt)
System.out.println("writing output...");// Fortschrittausgabe

// erstellt Writer um in eine Datei zu schreiben (vorhandene wird ueberschrieben)
BufferedWriter bw = new BufferedWriter(new FileWriter(args[2]));

// Schleife lauft ueber alle Elemente in der Zeilen-Liste
for (String lineOut : encodedLines)
{
bw.write(lineOut);// schreibt aktuelle Zeile in Datei
bw.write("\n");// schreibt Zeilenumbruch in Datei
// bw.write("\r\n");//schreibt Zeilenumbruch in Datei (Windows-Version)
}

// schliesst Writer, da nicht mehr benoetigt
bw.close();
// ==--== schreiben der Ausgabedatei (verschluesselt)

System.out.println("finsh");// Fortschrittausgabe
}// main

/**
* Methode, welche einen String nach Caesar verschiebt.
* @param text Text der zu verschluesseln ist
* @param key Schluessel, um den Buchstaben verschoben werden sollen (0..26)
* @return verschluesselter Text
*/
private static String encode(String text, int key)
{
// erstellt neuen StringBuilder, um Ausgabe-String zu generieren
StringBuilder sb = new StringBuilder();

int newC;// Code eines alten buchstaben
int oldC;// Code des Buchstaben in neu

// Schleife durchlauft alle Zeichen
while (!text.isEmpty())
{
// der erste Buchstabe wird gelesen
newC = oldC = text.charAt(0);

// Ueberpruefung ob Zeichen ein Buchstabe ist,
// dann wird umgewandelt (ansonsten bleibt Zeichen erhalten)
if (oldC >= 'a' && oldC <= 'z')
{
// Kleinbuchstabe
newC = oldC + key;// Verschluesselung

if (newC > 'z')//Behandlung von Overflows
{
newC -= 26;// anpassen des Buchstaben
}// if
}
else if (oldC >= 'A' && oldC <= 'Z')
{
// Grossbuchstabe
newC = oldC + key;// Verschluesselung

if (newC > 'Z')//Behandlung von Overflows
{
newC -= 26;// anpassen des Buchstaben
}// if
}// if
else
{
// nix, da nur "normale" Buchstaben verschluesselt werden
}

// das aktuelle Zeichen (der verschluesselte Buchstabe)
//wird dem String hinzugefuegt
sb.append((char) newC);

// der momentane Text wird auf den Rest (one erstes Zeichen) gesetzt
text = text.substring(1);
}// while

return sb.toString();// verschluesselter String wird zurueckgegeben
}// encode
}//classs
</nowiki>

== CaesarEncode.java (Cäsar-Entschlüsselung) ==

Diese Klasse entschlüsselt eine verschlüsselte Datei. Dazu gibt es zwei Möglichkeiten:
# man gibt den Schlüssel an nach dem entschlüsselt werden soll (wenn bekannt)
# man gibt keinen Schlüssel an und das Programm ermittelt den Schlüssel.
Bei beiden Versionen wird die entschlüsselte Datei anschließend gespeichert.

<nowiki>
package caesar;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;

/**
* Programm welches eine mit der Caesar-Verschiebung verschlüsselte Textdatei entschluesselt. 
* Der Schluessel wird entweder als Parameter uebergeben oder durch das Programm ermittelt. 
* Bei der eigenstaendigen Ermittlung wird nach dem haefigsten Buchstaben gesucht,
* welcher dann das <code>e</code> sein muesste. 
* Parameterliste: 
* entweder: Dateiname (Eingabe), Schluessel, Dateiname (Ausgabe) 
* oder: Dateiname (Eingabe), Dateiname (Ausgabe)
* @author André Schulz
* @version 1.0 (3/2009)
*/
public class CaesarDecode
{
public static void main(String[] args) throws IOException
{
// Ueberpruefung ob Parameteranzahl falsch ist
if (args.length < 2 || args.length > 3)
{
// Ausgabe der parameterliste und beenden des Programms
System.out.println("params: <fileIn> [<key>] <fileOut>");
System.exit(0);
}

int key = -1;// Schluessel (Initialisierung mit default-Wert)
String fileNameout;// Name der Ausgabedatei

// erstellt Reader um aus verschluesselter Datei zu lesen
BufferedReader br = new BufferedReader(new FileReader(args[0]));

System.out.println("reading");// Fortschrittausgabe
String line = br.readLine();// liest erste Zeile

// Liste fuer die gelesenen Zeilen
LinkedList<String> lines = new LinkedList<String>();

// Schleife so lange, wie gelesene Zeilen Text enthalten
while (line != null)
{
lines.add(line);// hinzufuegen der Zeile zur Liste
line = br.readLine();// lesen der naechsten Zeile
}

// Schliessen der Datei
br.close();

// Auswahl je nach Parameteranzahl
if (args.length == 3)
{
// 3 Parameter: Schluessel vom Benutzer gegeben

try
{
// wandelt den String aus dem 2. Parameter in eine Zahl um
key = Integer.parseInt(args[1]);
}
catch (NumberFormatException e)
{
// wenn der String nicht in eine ganze Zahl umgewandelt werden konnte
// wird eine Fehlermeldung ausgegeben und beendet
System.out.println("could not parse key ('" + args[1] + "' is no number!)");
System.exit(0);
}

// Ueberprueft Schluessel auf Gueltigkeit
if (key < 0 || key > 26)
{
// Fehlerausgabe wenn ungueltig und beendung des Programms
System.out.println("key must be 0..26");
System.exit(0);
}

// setzt Dateiname fuer Ausgabe mit Wert aus 3. Parameter
fileNameout = args[2];
}
else
{
// nicht 3 Parameter => 2 Parameter
// Schluessel ist niciht gegeben uns muss ermittelt werden

// Schluesselermittlung an Hand der gelesenen Zeilen
key = determineKey(lines);
fileNameout = args[1];// Dateiname fuer Ausgabe
System.out.println("key:" + key);// Ausgabe des gefundenen Schluessels
}// else

System.out.println("writing output...");// Fortschrittausgabe

// Writer zum Schreiben der entschluesselten Datei
BufferedWriter bw = new BufferedWriter(new FileWriter(fileNameout));

// Schleife geht alle gelesenen Zeilen durch
for (String lineOut : lines)
{
// jede Linie wird separat decodiert und dann in Datei geschrieben
bw.write(decode(lineOut, key));
bw.write("\n");// Zeilenumbruch
// bw.write("\r\n");//schreibt Zeilenumbruch in Datei (Windows-Version)
}

// Schliessen der Datei
bw.close();
System.out.println("finsh");// Fortschrittausgabe
}// main

/**
* Methode ermittelt den Schluessel an Hand des Textes.
* @param lines Text als Liste der Zeilen
* @return Schluessel mit dem verschluesselt wurde
*/
private static int determineKey(LinkedList<String> lines)
{
int i;// Zaehlvariable (wird mehr mahls verwendet)
int[] lower = new int[26];// Array fuer Haufigkeit der Kleinbuchstaben
int[] upper = new int[26];// Array fuer Haufigkeit der Grossbuchstaben
char c;// aktuelles Zeichen

// ==++== Ermittlung der einzelnen Haeufigkeiten
// Schleife durchlauft alle eingelesenen Zeilen
for (String line : lines)
{
// Zeile wird Zeichen fuer Zeichen durchlaufen
for (i = 0; i < line.length(); i++)
{
c = line.charAt(i);// Zeichen wird gelesen

// wenn Zeichen ein buchstabe ist, wird Stelle im Array incrementiert
if (c >= 'a' && c <= 'z')
{
// Kleinbuchstabe
lower[c - 'a']++;
}
else if (c >= 'A' && c <= 'Z')
{
// Grossbuchstabe
upper[c - 'A']++;
}
}// for
}// for
// ==--== Ermittlung der einzelnen Haeufigkeiten

// Ausgabe der einzelnen Haeufigkeiten
c = 'a';// angefangen bei "a"...
for (i = 0; i < 26; i++)
{
// Ausgabe des Buchstaben und der Haeufigkeit bei Klein- und Grossbuchstaben
System.out.println(c + "\t" + lower[i] + "\t" + upper[i]);
c++;// weiter zum naechsten Buchstaben
}

//==++== Suche nach dem haeufigsten Buchstaben
c = ' ';// default "Buchstabe"
int max = -1;// groesste gefundene Haeufigkeit
// Durchlaufen beider Arrays parallel
for (i = 0; i < 26; i++)
{
// wenn aktueller Buchstabe haeufiger als anderer zuvor
if (lower[i] + upper[i] > max)
{
// merken der groessten Haeufigkeit
max = lower[i] + upper[i];

// merken des Buchstaben
c = (char) ('a' + i);// Rechnung mit Zeichen (z.B.: 'a'+2='c')
}
}// for
//==--== Suche nach dem haeufigsten Buchstaben

// theoretisch steht jetzt in der Variable c der Buchstabe mit der
// groessten Haeufigkeit im eingelesen Text, da bei deutschen Texten das 'e'
// am Haeufigsten auftritt muss dies ein verschluesseltes 'e' sein

int key = c - 'e';// ausrechnen des Schluessels

// anpassen des Schluessels bei einem Overflow
if (key < 0)
{
key += 26;
}

return key;// ermittelter Schluessel wird zurueckgegeben
}// countLetter

/**
* Methode decodiert einen Text bei gegebenen Schluessel.
* @param text zu entschluesselnder Text
* @param key Schluessel, mit dem verschluesslt wurde
* @return entschluesselter Text
*/
private static String decode(String text, int key)
{
// neuer StringBuilder um Ausgabetext zu "bauen"
StringBuilder sb = new StringBuilder();

int newC;// Code eines alten buchstaben
int oldC;// Code des Buchstaben in neu

// Schleife so lange der Text noch Zeichen enthaelt
while (!text.isEmpty())
{
// einlesen des ersten Zeichens
newC = oldC = text.charAt(0);

// Ueberpruefung ob Zeichen ein normaler Buchstabe ist
if (oldC >= 'a' && oldC <= 'z')
{
// Kleinbuchstabe
newC = oldC - key;// Entschluesselung

if (newC < 'a')// Behandlung von Overflows
{
newC += 26;// anpassen des Buchstaben
}// if
}
else if (oldC >= 'A' && oldC <= 'Z')
{
// Grossbuchstabe
newC = oldC - key;// Entschluesselung

if (newC < 'A')// Behandlung von Overflows
{
newC += 26;// anpassen des Buchstaben
}// if
}// if
else
{
// nix, da nur "normale" Buchstaben verschluesselt werden
}

// entschluesselter Buchstabe wird Text hinzugefuegt
sb.append((char) newC);

// der momentane Text wird auf den Rest (one erstes Zeichen) gesetzt
text = text.substring(1);
}// while

return sb.toString();// entschluesselter text wird zurueckgegeben
}// encode
}//class
</nowiki>

C-Kurs/Von der Konsole zum HelloWorld

2009-09-21T08:39:36Z

Andre:

# Sollte das Arbeiten unter Unix neu für dich sein, dann nimm dir etwas Zeit, um dich mit den elementaren Konsolenkommandos vertraut zu machen. Erste Hilfe zu den Kommandos gibt es im Wiki unter [[Javakurs2007/Kommandohilfe | Kommandohilfe]].
# Starte ein Konsolenprogramm deiner Wahl.
# Lege dir ein Verzeichnis "Ckurs" an und kopiere die Vorgaben von [http://docs.freitagsrunde.org/Veranstaltungen/ckurs_2009/vorgaben/VonDerKonsoleZumHelloWorld.tar VonDerKonsoleZumHelloWorld.tar] an diesen Ort.
# Entpacke die Vorgaben, die sich nun in deinem Verzeichnis befinden. (Mit dem Befehl <code>tar -xf VonDerKonsoleZumHelloWorld.tar</code> in einer Shell)
# Lösche im entstandenen Verzeichnis VonDerKonsoleZumHelloWorld/ die Datei WegMitDieserDatei und das Verzeichnis WegMitDiesemVerzeichnis.
# Benenne im selben Verzeichnis die Datei GibMirEinenNamen.txt in CompiliereMich.c um.
# Compiliere die soeben entstandene Datei CompiliereMich.c mit Hilfe von gcc CompiliereMich.c -o CompiliereMich.
# Führe das Programm in der entstandenen Datei CompiliereMich aus.
# Öffne einen Texteditor deiner Wahl. Schreibe ein Programm, das "HalloWelt" auf der Konsole ausgibt und teste es.