public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
System.out.println(aktuellerGegenstand.keller.gegenstaendeAnzeigen());
}
public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
System.out.println(aktuellerGegenstand.buero.gegenstaendeAnzeigen());
}
Vllt wäre ein Karriere als Stand-Up-Comedian was für dich?Also die Aufgaben bisher habe ich auch ganz gut verstanden
Doch - fast alles, was bisher behandelt wurde.Da fehlt sicherlich gar nicht viel zur Lösung!
Das sehe ich. Aber mit dem Kopf durch die Wand ist es keine Lernmethode, wenn man sich das "Problemlösen" aneignen möchte.Ja, ok.^^ Ich gebe mir Mühe.
Das Verständnis für Programmabläufe aufbauen. Du hängst an dem selben Problem - wie man über eine Collection iteriert und etwas dediziert ausgibt - schon seit 3 Threads.Welche Schritte muss ich jetzt machen?
* Iteriere über eine Collection
* Gib eine Eigenschaft des Objekts in der Collection aus
Ja. Um das zu sagen, muss ich noch nicht mal wissen, aus welcher Klasse die Codeschnipsel kommen (ich rate mal, es ist die Klasse "Raum"). Wie schon seit ca. 1 Jahr, programmierst du nicht, sondern rätst. Nach wie vor kann ich noch nicht mal ein Grundverständnis von objektorientierter Programmierung erkennen.Ist Schwachsinn?
Welche Informationen bzw. Eigenschaften hat denn so ein Gegenstand, die man ausgeben könnte?
for (Student student : studenten) {
student.ausgeben();
}
public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
aktuellerGegenstand.();
}
public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
aktuellerGegenstand.gibBeschreibung();
}
Die MethodeUnd jetzt ist das Problem, dass es einen Keller und ein Büro gibt!
gegenstaendeAnzeigen
gehört zu Raum, richtig?Das liegt wahrscheinlich daran, dass du nicht imstande bist, einmal gelerntes in einem ähnlichen Zusammenhang anzuwenden. Für dich ist wahrscheinlich eine Iteration über eine ArrayList<Gegenstand> was vollkommen anderes alsdie Iteration über eine ArrayList<Student>.Ich finde schon, dass sich diese Aufgabe stark von den anderen unterscheidet.
Ja, aber es gibt immer nur einen aktuellen Raum, und mit den darin enthaltten Gegenständen sollst du was machen: drüber iterieren und deren Eigenschaften ausgeben.Diesmal sollen nicht einfach alle Artikel oder was auch immer
ausgegeben werden, sondern es gibt unterschiedliche Räume...
Richtig!Die Methode gegenstaendeAnzeigen gehört zu Raum, richtig?
Nicht dieselbe Instanz, aber dieselbe Klasse.Nicht das selbe!
Was funktioniert denn nicht?Bis wohin ist der Code richtig?
Ja, es kommt aber noch ne Fehlermeldung.
Ohne die Fehlermeldung könnte ich das wenigstens testen...
Die aus seinem Screenshot.Und das heißt? Welche Fehlermeldung?
Lege zwei Instanzen von Gegenstand an. Erzeuge eine Instanz von Raum. Füge die Gegenstände in den Raum ein. Gibt "gibBeschreibung" das richtige aus? Wenn ja- Wird diese Methode überhaupt aufgerufen,wenn du "look" eingibst?
/**
* Dies ist die Hauptklasse der Anwendung "Die Welt von Zuul".
* "Die Welt von Zuul" ist ein sehr einfaches, textbasiertes
* Adventure-Game. Ein Spieler kann sich in einer Umgebung bewegen,
* mehr nicht. Das Spiel sollte auf jeden Fall ausgebaut werden,
* damit es interessanter wird!
*
* Zum Spielen muss eine Instanz dieser Klasse erzeugt werden und
* an ihr die Methode "spielen" aufgerufen werden.
*
* Diese Instanz dieser Klasse erzeugt und initialisiert alle
* anderen Objekte der Anwendung: Sie legt alle Räume und einen
* Parser an und startet das Spiel. Sie wertet auch die Befehle
* aus, die der Parser liefert und sorgt für ihre Ausführung.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
import java.util.ArrayList;
class Spiel
{
private Parser parser;
private Raum aktuellerRaum;
private Gegenstand aktuellerGegenstand;
private ArrayList<Gegenstand> gegenstaende;
private Gegenstand buch;
private Gegenstand computer;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel()
{
raeumeAnlegen();
parser = new Parser();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen()
{
Raum draussen, hoersaal, cafeteria, labor, buero, keller;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang der Universität");
hoersaal = new Raum("in einem Vorlesungssaal");
cafeteria = new Raum("in der Cafeteria der Uni");
labor = new Raum("in einem Rechnerraum");
buero = new Raum("im Verwaltungsbüro der Informatik");
keller = new Raum("im Keller");
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
hoersaal.setzeAusgang("west", draussen);
cafeteria.setzeAusgang("east", draussen);
labor.setzeAusgang("north", draussen);
labor.setzeAusgang("east", buero);
buero.setzeAusgang("west", labor);
buero.setzeAusgang("down", keller);
keller.setzeAusgang("up", buero);
//Gegenstände erzeugen
buch = new Gegenstand("Buch", 150);
computer = new Gegenstand("Computer", 1500);
keller.addGegenstand(buch);
buero.addGegenstand(computer);
aktuellerRaum = draussen; // das Spiel startet draussen
}
/**
* Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels
* in einer Schleife.
*/
public void spielen()
{
willkommenstextAusgeben();
// Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
// und führen sie aus, bis das Spiel beendet wird.
boolean beendet = false;
while (! beendet) {
Befehl befehl = parser.liefereBefehl();
beendet = verarbeiteBefehl(befehl);
}
System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
}
private void umsehen()
{
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
private void essen()
{
System.out.println(aktuellerRaum.gibEssensBeschreibung());
}
private void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
System.out.print("Ausgänge: ");
if (aktuellerRaum.gibAusgang("north") != null) {
System.out.print("north ");
}
if(aktuellerRaum.gibAusgang("east") != null) {
System.out.print("east ");
}
if(aktuellerRaum.gibAusgang("south") != null) {
System.out.print("south ");
}
if(aktuellerRaum.gibAusgang("west") != null) {
System.out.print("west ");
}
System.out.println();
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben()
{
System.out.println();
System.out.println("Willkommen zu Zuul!");
System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.");
System.out.println("Tippen sie 'help', wenn Sie Hilfe brauchen.");
System.out.println();
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
/**
* Verarbeite einen gegebenen Befehl (führe ihn aus).
* @param befehl Der zu verarbeitende Befehl.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean verarbeiteBefehl(Befehl befehl)
{
boolean moechteBeenden = false;
if(befehl.istUnbekannt()) {
System.out.println("Ich weiss nicht, was Sie meinen...");
return false;
}
String befehlswort = befehl.gibBefehlswort();
if (befehlswort.equals("help")) {
hilfstextAusgeben();
}
else if (befehlswort.equals("go")) {
wechsleRaum(befehl);
}
else if (befehlswort.equals("look")) {
umsehen();
}
else if (befehlswort.equals("eat")) {
essen();
}
else if (befehlswort.equals("quit")) {
moechteBeenden = beenden(befehl);
}
// ansonsten: Befehl nicht erkannt.
return moechteBeenden;
}
// Implementierung der Benutzerbefehle:
/**
* Gib Hilfsinformationen aus.
* Hier geben wir eine etwas alberne und unklare Beschreibung
* aus, sowie eine Liste der Befehlswörter.
*/
private void hilfstextAusgeben()
{
System.out.println("Sie haben sich verlaufen. Sie sind allein.");
System.out.println("Sie irren auf dem Unigelände herum.");
System.out.println();
System.out.println("Ihnen stehen folgende Befehle zur Verfügung:");
parser.zeigeBefehle();
}
/**
* Versuche, in eine Richtung zu gehen. Wenn es einen Ausgang gibt,
* wechsele in den neuen Raum, ansonsten gib eine Fehlermeldung
* aus.
*/
private void wechsleRaum(Befehl befehl)
{
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return;
}
String richtung = befehl.gibZweitesWort();
// Wir versuchen, den Raum zu verlassen.
Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);
if (naechsterRaum == null) {
System.out.println("Dort ist keine Tür!");
}
else {
aktuellerRaum = naechsterRaum;
System.out.println(aktuellerRaum.gibLangeBeschreibung());
}
}
/**
* "quit" wurde eingegeben. Überprüfe den Rest des Befehls,
* ob das Spiel wirklich beendet werden soll.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean beenden(Befehl befehl)
{
if(befehl.hatZweitesWort()) {
System.out.println("Was soll beendet werden?");
return false;
}
else {
return true; // Das Spiel soll beendet werden.
}
}
}
import java.util.Set;
import java.util.HashMap;
import java.util.ArrayList;
/**
* Diese Klasse modelliert Räume in der Welt von Zuul.
*
* Ein "Raum" repräsentiert einen Ort in der virtuellen Landschaft des
* Spiels. Ein Raum ist mit anderen Räumen über Ausgänge verbunden.
* Für jeden existierenden Ausgang hält ein Raum eine Referenz auf
* den benachbarten Raum.
*
* @author Michael Kölling und David J. Barnes
* @version 31.07.2011
*/
class Raum
{
private String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
private Raum aktuellerRaum;
private ArrayList<Gegenstand> gegenstaende;
/**
* Erzeuge einen Raum mit einer Beschreibung. Ein Raum
* hat anfangs keine Ausgänge.
* @param beschreibung enthält eine Beschreibung in der Form
* "in einer Küche" oder "auf einem Sportplatz".
*/
public Raum(String beschreibung)
{
this.beschreibung = beschreibung;
ausgaenge = new HashMap<String, Raum>();
gegenstaende = new ArrayList<Gegenstand>();
}
public String gibBeschreibung()
{
return beschreibung;
}
public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
aktuellerGegenstand.gibBeschreibung();
}
}
public void addGegenstand(Gegenstand gegenstand)
{
gegenstaende.add(gegenstand);
}
/**
* Definiere einen Ausgang für diesen Raum.
* @param richtung die Richtung, in der der Ausgang liegen soll
* @param nachbar der Raum, der über diesen Ausgang erreicht wird
*/
public void setzeAusgang(String richtung, Raum nachbar)
{
ausgaenge.put(richtung, nachbar);
}
/**
* @return die kurze Beschreibung dieses Raums (die dem Konstruktor
* übergeben wurde).
*/
public String gibKurzbeschreibung()
{
return beschreibung;
}
/**
* Liefere eine lange Beschreibung dieses Raums, in der Form:
* Sie sind in der Küche.
* Ausgänge: nord west
* @return eine lange Beschreibung dieses Raumes.
*/
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
public String gibEssensBeschreibung()
{
return "Sie haben nun gegessen und sind nicht mehr hungrig!";
}
public String gibAusgaengeAlsString2()
{
String ergebnis = "Ausgänge: ";
if (aktuellerRaum.gibAusgang("north") != null) {
ergebnis += "north";
if (aktuellerRaum.gibAusgang("east") != null) {
ergebnis += "east";
if (aktuellerRaum.gibAusgang("south") != null) {
ergebnis += "south";
if (aktuellerRaum.gibAusgang("west") != null) {
ergebnis += "west";
}
}
}
}
return ergebnis;
}
/**
* Liefere eine Beschreibung der Ausgänge dieses Raumes,
* beispielsweise
* "Ausgänge: north west".
* @return eine Beschreibung der Ausgänge dieses Raumes.
*/
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
public Raum gibAusgang(String richtung)
{
return ausgaenge.get(richtung);
}
/**
* Liefere den Raum, den wir erreichen, wenn wir aus diesem Raum
* in die angegebene Richtung gehen. Liefere 'null', wenn in
* dieser Richtung kein Ausgang ist.
* @param richtung die Richtung, in die gegangen werden soll.
* @return den Raum in der angegebenen Richtung.
*/
}
/**
* Beschreiben Sie hier die Klasse Gegenstand.
*
* @author (Ihr Name)
* @version (eine Versionsnummer oder ein Datum)
*/
public class Gegenstand
{
// Instanzvariablen - ersetzen Sie das folgende Beispiel mit Ihren Variablen
private int x;
private String gegenstandBeschreibung;
private int gegenstandGewicht;
private String beschreibung;
/**
* Konstruktor für Objekte der Klasse Gegenstand
*/
public Gegenstand(String beschreibung, int gewicht)
{
this.gegenstandBeschreibung = beschreibung; // Instanzvariable initialisieren
this.gegenstandGewicht = gewicht;
x = 0;
}
public String gibBeschreibung()
{
return beschreibung;
}
/**
* Ein Beispiel einer Methode - ersetzen Sie diesen Kommentar mit Ihrem eigenen
*
* @param y ein Beispielparameter für eine Methode
* @return die Summe aus x und y
*/
public int beispielMethode(int y)
{
// tragen Sie hier den Code ein
return x + y;
}
}
private String beschreibung;
public void gegenstaendeAnzeigen()
{
for(Gegenstand aktuellerGegenstand: gegenstaende){
aktuellerGegenstand.gibBeschreibung.keller.gegenstaendeAnzeigen();
}
}
private void umsehen()
{
System.out.println(aktuellerRaum.gibLangeBeschreibung());
System.out.println(aktuellerRaum.gegenstaendeAnzeigen());
}
Nein *riesenseufzer*. Die Variable wird lediglich deklariert. Sie bekommt nie einen Wert.Die Variable "beschreibung" wird doch initialisiert? Klasse Gegenstand.
Die Gedanken eventuell, aber für den resultierenden Code gibt es 0 von 10 möglichen Punkten. Das ist kein Programmieren, sondern nur rumraten.Sind meine Gedanken so richtig?
public Gegenstand(String beschreibung, int gewicht)
{
this.gegenstandBeschreibung = beschreibung; // Instanzvariable initialisieren
this.gegenstandGewicht = gewicht;
this.beschreibung = beschreibung;
x = 0;
}
Wie lange dauert die Ausbildung zum FIAE?
Schreibe dir eine Methode gibGegenstaendeAlsString, und baue die so ähnlich auf wie gibAusgaengeAlsString() mit einem String als Rückgabewert
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
Sowas meine ich. Du hast den Code vor Augen, aber verstehst ihn nicht. Wie willst du jemals eine Klausur oder eine Prüfung bestehen?Was wird da gemacht? Ich weiss es nicht.
Hier ne winzige Erklärung:Code:private String gibAusgaengeAlsString() { String ergebnis = "Ausgänge:"; Set<String> keys = ausgaenge.keySet(); for(String ausgang : keys) ergebnis += " " + ausgang; return ergebnis; }
Ja, ich muss erstmal verstehen was gemacht wird, stimmt.
Eine Aufgabe im Buch ist auch zu beschreiben was diese Methode macht....die habe ich ausgelassen -.-
Was wird da gemacht? Ich weiss es nicht.
String ergebnis = "Ausgänge:";
ergebnis
mit "Ausgänge:"
. Das heißt der String ergebnis
hat den Wert "Ausgänge:"
. Soweit so gut.Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
ergebnis
ein Leerzeichen und ausgang
zugewiesen werden.return ergebnis;
gibst du das ergebnis
als Rückgabewert der Methode zurück. Und diesen Rückgabewert musst do wohl irgenwo benutzen müssen. Wo genau dass kann ich dir auch nicht sagen.Ein Set ist keine Liste. Listen und Sets haben unterschiedliche Eigenschaften. Z.B. kann dasselbe Element in einer Liste mehrfach enthalten sein, in einem Set aber nicht.Set<String> keys = ausgaenge.keySet();
Hier legst du eine Collection an, also eine Liste vom Typ String
War nur zum Grobverständiss gedacht. Aber ja du hast Recht.Ein Set ist keine Liste. Listen und Sets haben unterschiedliche Eigenschaften. Z.B. kann dasselbe Element in einer Liste mehrfach enthalten sein, in einem Set aber nicht.
Nicht so ganz. Für jeden "ausgang" aus dem Set<String> "keys" soll dem String "ergebnis" ein Leerstring und der Wert von "ausgangs" angehängt werden.Hier sagst du praktisch. Für jeden ausgang von der Liste keys soll ergebnis ein Leerzeichen und ausgang zugewiesen werden.
private String gibGegenstaendeAlsString()
{
String ergebnis = "Ausgänge";
Set<String> gegenstaende = ausgaenge.keySet();
for(String aktuellerGegenstand : gegenstaende)
ergebnis += " " + aktuellerGegenstand;
return ergebnis;
}
ausgaenge.keySet();
ergebnis += " " + aktuellerGegenstand;
Was macht die Methode keySet() ?
Das heisst doch: ergebnis = ergebnis " " + aktuellerGegenstand ?
String s1 = "Hallo";
String s2 = "Welt";
// Kurzschreibweise
s1 += " " + s2;
System.out.println(s1); // Ergebnis: Hallo Welt
// gleiches Ergebnis, nur ausführlicher geschrieben:
s1 = s1 + " " + s2;
System.out.println(s1); // Ergebnis: Hallo Welt
Das ist Käse. Mit einem weiteren Pluszeichen wirds aber richtig.Das heisst doch: ergebnis = ergebnis " " + aktuellerGegenstand ?
Soll die Frageform andeuten, dass du vergessen hast, was "ausgaenge" ist? Deine Ausbilder bzw. Kommilitonen tun mir jetzt schon leid.Woher der Name ausgaenge? Die Ausgänge dieses Raums?
Was macht die Methode keySet() ?
Gute Empfehlung. Die hat er wohl schon 100 Mal bekommen. Umgesetzt hat er sie aber offensichtlich bisher nicht.dann empfehle ich dir, dich nochmal richtig hinzusetzen und die Basics zu lernen
private String gibGegenstaendeAlsString()
{
String ergebnis = "Ausgänge";
Set<String> gegenstaende = ausgaenge.keySet();
for(String aktuellerGegenstand : gegenstaende)
ergebnis += " " + aktuellerGegenstand;
return ergebnis;
}
HashMap<String, Raum>
String ist der Typ der Objekte der in der Map sein soll, und Raum ist der Typ des Schlüssels.
Beide Typen können auch gleich sein!
Code:private String gibGegenstaendeAlsString() { String ergebnis = "Ausgänge"; Set<String> gegenstaende = ausgaenge.keySet(); for(String aktuellerGegenstand : gegenstaende) ergebnis += " " + aktuellerGegenstand; return ergebnis; }
Wie schreibe ich nun die Methode?