# Java mit BlueJ - Hilfe - Gegenstände



## Parad0x (14. Nov 2013)

Guten Tag,

Ich bin Schüler der 11. Klasse am Gymnasium (1. Semester)
und wir haben jetzt in Informatik mit dem objektorientierten programmieren mit Java angefangen.
Benutzen tun wir dafür die kostenlose software von bluej. Die gibt es hier bluej.

Ich würde die Leute bitten, die mir helfen wollen sich bluej runterzuladen, da es amsonsten ziemlich umständlich wäre. Ich werde mein bluej Projekt hier als *.zip Datei anhängen.

Das Problem ist folgendes:

Wir haben ein Projekt bekommen namens "Zuul besser" es handelt sich dabei um ein einfaches text basierendes Java Spiel indem ma durch Befehle wie "gehe sueden" in verschiedene Räume gehen kann. Das Spiel ist endlos. Ich habe in dem beigelegten Projekt bereits 2 weitere Räume hinzugefügt. (war eine Aufgabe, die aber total einfach war)

Unser Lehrer hat gesagt das er es toll fände wenn wir es hinbekommen würden "Gegenstände" ins Spiel mit zu integrieren und man die möglichkeit hätte diese aufzuheben. Er hat gesagt wenn man das schafft kann man ihm das Projekt gerne per USB-Stick mitgeben und er guckt sich das an und bewertet das. Er meinte das wäre, dafür, das wir erst mit Java angefangen haben im sehr guten Bereich.

Nun wäre meine Frage ob ihr mir helfen könntet und mir sagen könntet wie ich das hinkriegen kann, dass ich z.B. einen Schlüssel in einen Raum tuhe und man diesen aufheben kann wenn man ihn betritt und man damit z.B eine Tür (also im Sinne von "gehe norden") öffnen kann, die man vorher ohne Schlüssel nicht betreten konnte.

Ich habe das Projekt lieber als *.zip angehängt weil es aus ingesamt 5 Klassen besteht und es so zu unübersichtlich wäre würde ich alle codes posten. Zudem könnt ihr es so direkt ausprobieren. Könnt ihr mir auch sagen ob ich nur an der "Spiel" Klasse was ändern muss oder auch die anderen Klassen wie "Parser" oder "Räume"?

Ich hätte nämlich den Vorschlag, dass man das ganze mit einem counter macht + if else Abfrage aber ich weiß nicht so ganz wie das geht und ob das auch so funktioniert wie ich denke.

Sorry für den langen Text und danke schonmal im voraus falls mir jemand antwortet.

Falls ihr irgendwelche anderen Infos braucht schreibt ruhig.


----------



## diggaa1984 (14. Nov 2013)

Allgemein würde es sich anbieten weitere Klassen einzuführen. Zb. die Klasse Gegenstand, welche diverse Attribute (im einfachsten Fall eine Bezeichnung) beinhaltet. Sowie eine Klasse Inventar, welche eine Menge von Gegenständen beinhaltet. 

Sicherlich ist das eine Menge, wenn man erst mit Java angefangen hat, aber früh übt sich der Java-Neuling in objektorientierter Programmierung und Strukturierung der Software 

Du kannst die ja diesbezüglich Überlegungen machen und dieser erst einmal hier nennen. Und wenn du dann schon Code-Ansätze hast um das, wenn auch nur ansatzweise, umzusetzen, dann sollte dir Hilfe durchaus zustehen ^^


----------



## Parad0x (14. Nov 2013)

diggaa1984 hat gesagt.:


> Allgemein würde es sich anbieten weitere Klassen einzuführen. Zb. die Klasse Gegenstand, welche diverse Attribute (im einfachsten Fall eine Bezeichnung) beinhaltet. Sowie eine Klasse Inventar, welche eine Menge von Gegenständen beinhaltet.
> 
> Sicherlich ist das eine Menge, wenn man erst mit Java angefangen hat, aber früh übt sich der Java-Neuling in objektorientierter Programmierung und Strukturierung der Software
> 
> Du kannst die ja diesbezüglich Überlegungen machen und dieser erst einmal hier nennen. Und wenn du dann schon Code-Ansätze hast um das, wenn auch nur ansatzweise, umzusetzen, dann sollte dir Hilfe durchaus zustehen ^^



Ohje.. das klingt aber ziemlich kompliziert. Wie eine Klasse im allgemeinen aufgebaut ist weiß ich. Ich weiß nur nicht wie ich das was ich mir vorstelle wie es funktionieren könnte umsetzen soll, da ich ja nicht alle Java Befehle kenne bzw. auch nicht genau weiß was welcher Java Befehl genau macht.

Ich hätte mir das so gedacht das man (falls das geht?) dem "Gegenstand" eine Art Variable zuordnet und man dann beim aufheben des Schlüssels (welche man vielleicht durch puren Text simulieren könnte) diese Variable erhält. Mann könnte dann bei der Tür eine if else Abfrage machen und überprüfen ob man diese Variable hat. Wenn es zutrifft dann kommt ein println unter dem if statement welches z.b sagt "Du hast die Tür mit dem Schlüssel geöffnet" und wenn eben nicht dann else "Du brauchst einen Schlüssel"

Einen counter wollte ich einbauen um zu verhindern das man den Schlüssel jedesmal aufheben kann wenn man den Raum betritt. 

Vielleicht helfen dies Informationen ja weiter? Danke schonmal im voraus.


----------



## diggaa1984 (14. Nov 2013)

Das mit der Abfrage ist soweit ok, es ging mir dann nur noch darum, dass du diesen Schlüssel/Gegenstand nicht irgendwo im Code unterbringst, sondern diesen als eigene Klasse realisierst, denn dann kannst du viele Gegenstände instanziieren, welche alle dieser Klasse angehören. 

Welche Klassen beinhaltet dein Projekt momentan? Ich werde BlueJ nicht installieren, ich hatte das mal gemacht, ich fand es gruselig


----------



## Parad0x (14. Nov 2013)

diggaa1984 hat gesagt.:


> Das mit der Abfrage ist soweit ok, es ging mir dann nur noch darum, dass du diesen Schlüssel/Gegenstand nicht irgendwo im Code unterbringst, sondern diesen als eigene Klasse realisierst, denn dann kannst du viele Gegenstände instanziieren, welche alle dieser Klasse angehören.
> 
> Welche Klassen beinhaltet dein Projekt momentan? Ich werde BlueJ nicht installieren, ich hatte das mal gemacht, ich fand es gruselig



Das Projekt enthält folgende Klassen:

-Spiel
-Parser
-Raum
-Befehl
-Befehlswörter

Ich werde sie dann doch einfach mal posten wenn's ok ist.

Spiel:

```
/**
 *  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 2008.03.30
 */

class Spiel 
{
    private Parser parser;
    private Raum aktuellerRaum;
    /**
     * Erzeuge ein Spiel und initialisiere die interne Raumkarte.
     */
    public Spiel() 
    {
        raeumeAnlegen();
        parser = new Parser();
    }

    /**
     * Erzeuge alle Raeume und verbinde ihre Ausgaenge miteinander.
     */
    private void raeumeAnlegen()
    {
        Raum draussen, hoersaal, cafeteria, labor, buero, flur, kunst, musik;
      
        // die Raeume erzeugen
        draussen = new Raum("vor dem Haupteingang der Universitaet.\n");
        hoersaal = new Raum("in einem Vorlesungssaal.\n");
        cafeteria = new Raum("in der Cafeteria der Uni.\n");
        labor = new Raum("in einem Rechnerraum.\n");
        buero = new Raum("im Verwaltungsbuero der Informatik.\n");
        flur = new Raum("auf dem Flur.\n");
        kunst = new Raum("im Kunstraum.\n");
        musik = new Raum("im Musikraum... im Süden funkelt etwas, schauen sie sich das genauer an.\n");
        
        
        
        
        // die Ausgaenge initialisieren
        draussen.setzeAusgang("osten", hoersaal);
        draussen.setzeAusgang("sueden", labor);
        draussen.setzeAusgang("westen", cafeteria);
        draussen.setzeAusgang("norden", flur);
        

        hoersaal.setzeAusgang("westen", draussen);
        

        cafeteria.setzeAusgang("osten", draussen);
        

        labor.setzeAusgang("norden", draussen);
        labor.setzeAusgang("osten", buero);
        

        buero.setzeAusgang("westen", labor);
        
        
        flur.setzeAusgang("sueden", draussen);
        flur.setzeAusgang("osten", kunst);
        flur.setzeAusgang("westen", musik);
        
        
        musik.setzeAusgang("osten", flur);
        
        
        kunst.setzeAusgang("westen", flur);
        

        aktuellerRaum = draussen;  // das Spiel startet draussen
    }

    /**
     * Die Hauptmethode zum Spielen. Laeuft 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("\nDanke fuers spielen. Auf Wiedersehen.");
    }

    /**
     * Einen Begruessungstext fuer den Spieler ausgeben.
     */
    private void willkommenstextAusgeben()
    {
        System.out.println();
        System.out.println("Willkommen zu Zuul!\n");
        System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.\n");
        System.out.println("Tippen sie 'hilfe' ein, wenn Sie Hilfe brauchen.\n");
        System.out.println("Wenn sie den Raum wechseln möchten tippen sie...\n");
        System.out.println("'gehe' + die verfügbare Himmelsrichtung.\n");
        System.out.println("Um das Spiel zu beenden tippen sich einfach 'ende' ein.");
        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("\nIch weiss nicht, was Sie meinen...");
            return false;
        }

        String befehlswort = befehl.gibBefehlswort();
        if (befehlswort.equals("hilfe")) {
            hilfstextAusgeben();
        }
        else if (befehlswort.equals("gehe")) {
            wechsleRaum(befehl);
        }
        else if (befehlswort.equals("ende")) {
            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 Befehlswoerter.
     */
    private void hilfstextAusgeben() 
    {
        System.out.println("\nSie haben sich verlaufen. Sie sind allein.\n");
        System.out.println("Sie irren auf dem Unigelaende herum.");
        System.out.println();
        System.out.println("Ihnen stehen folgende Befehle zur Verfuegung:\n");
        parser.zeigeBefehle();
        System.out.println();
    }

    /**
     * Versuche, den Raum zu wechseln. 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("\nWohin moechten Sie gehen?");
            return;
        }

        String richtung = befehl.gibZweitesWort();

        // Wir versuchen den Raum zu verlassen.
        Raum naechsterRaum = aktuellerRaum.gibAusgang(richtung);

        if (naechsterRaum == null) {
            System.out.println("\nDort ist keine Tuer!");
        }
        else {
            aktuellerRaum = naechsterRaum;
            System.out.println(aktuellerRaum.gibLangeBeschreibung());
        }
    }

    /**
     * "quit" wurde eingegeben. Ueberpruefe 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.
        }
    }
}
```

Parser:

```
import java.util.Scanner;

/**
 * Dieser Parser liest Benutzereingaben und wandelt sie in
 * Befehle fuer das Adventure-Game um. Bei jedem Aufruf
 * liest er eine Zeile von der Konsole und versucht, diese als
 * einen Befehl aus bis zu zwei Woertern zu interpretieren. Er
 * liefert den Befehl als ein Objekt der Klasse Befehl zurueck.
 * 
 * Der Parser verfuegt ueber einen Satz an bekannten Befehlen. Er
 * vergleicht die Eingabe mit diesen Befehlen. Wenn die Eingabe
 * keinen bekannten Befehl enthaelt, dann liefert der Parser ein als 
 * unbekannter Befehl gekennzeichnetes Objekt zurueck.
 * 
 * @author  Michael K�lling und David J. Barnes
 * @version 2008.03.30
 */
class Parser 
{
    private Befehlswoerter befehle;  // haelt die gueltigen Befehlswoerter
    private Scanner leser;         // Lieferant fuer eingegebene Befehle

    /**
     * Erzeuge einen Parser, der Befehle von der Konsole einliest.
     */
    public Parser() 
    {
        befehle = new Befehlswoerter();
        leser = new Scanner(System.in);
    }

    /**
     * @return Den naechsten Befehl des Benutzers.
     */
    public Befehl liefereBefehl() 
    {
        String eingabezeile;   // fuer die gesamte Eingabezeile
        String wort1 = null;
        String wort2 = null;

        System.out.print("\n> ");     // Eingabeaufforderung

        eingabezeile = leser.nextLine();
        
        // Finde bis zu zwei Woerter in der Zeile
        Scanner zerleger = new Scanner(eingabezeile);
        if(zerleger.hasNext()) {
            wort1 = zerleger.next();     // erstes Wort lesen
            if (zerleger.hasNext()) {
                wort2 = zerleger.next();    // zweites Wort lesen
                // Hinweis: Wir ignorieren den Rest der Eingabezeile.
            }
        }
        
        // Jetzt pruefen, ob der Befehl bekannt ist. Wenn ja, erzeugen
        // wir das passende Befehl-Objekt. Wenn nicht, erzeugen wir
        // einen unbekannten Befehl mit 'null'.
        if(befehle.istBefehl(wort1)) {
            return new Befehl(wort1, wort2);
        }
        else {
            return new Befehl(null, wort2);
        }
    }

    /**
     * Gib eine Liste der bekannten Befehlswoerter aus.
     */
    public void zeigeBefehle()
    {
        befehle.alleAusgeben();
    }
}
```

Raum:

```
import java.util.Set;
import java.util.HashMap;
import java.util.Iterator;

/**
 * Diese Klasse modelliert Raeume in der Welt von Zuul.
 * 
 * Ein "Raum" repraesentiert einen Ort in der virtuellen Landschaft des
 * Spiels. Ein Raum ist mit anderen Raeumen ueber Ausgaenge verbunden.
 * Fuer jeden existierenden Ausgang haelt ein Raum eine Referenz auf 
 * den benachbarten Raum.
 * 
 * @author  Michael K�lling und David J. Barnes
 * @version 2008.03.30
 */

class Raum 
{
    private String beschreibung;
    private HashMap<String, Raum> ausgaenge;        // die Ausgaenge dieses Raums

    /**
     * Erzeuge einen Raum mit einer Beschreibung. Ein Raum
     * hat anfangs keine Ausgaenge.
     * @param beschreibung enthaelt eine Beschreibung in der Form
     *        "in einer Kueche" oder "auf einem Sportplatz".
     */
    public Raum(String beschreibung) 
    {
        this.beschreibung = beschreibung;
        ausgaenge = new HashMap<String, Raum>();
    }

    /**
     * Definiere einen Ausgang fuer diesen Raum.
     * @param richtung die Richtung, in der der Ausgang liegen soll
     * @param nachbar der Raum, der ueber diesen Ausgang erreicht wird
     */
    public void setzeAusgang(String richtung, Raum nachbar) 
    {
        ausgaenge.put(richtung, nachbar);
    }

    /**
     * @return die kurze Beschreibung dieses Raums (die dem Konstruktor
     * uebergeben wurde).
     */
    public String gibKurzbeschreibung()
    {
        return beschreibung;
    }

    /**
     * Liefere eine lange Beschreibung dieses Raums, in der Form:
     *     Sie sind in der Kueche.
     *     Ausgaenge: nord west
     * @return eine lange Beschreibung dieses Raumes.
     */
    public String gibLangeBeschreibung()
    {
        return "\nSie sind " + beschreibung + "\n" + gibAusgaengeAlsString();
    }

    /**
     * Liefere eine Beschreibung der Ausgaenge dieses Raumes,
     * beispielsweise
     * "Ausgaenge: north west".
     * @return Eine Beschreibung der Ausgaenge dieses Raumes.
     */
    private String gibAusgaengeAlsString()
    {
        String ergebnis = "Ausgaenge:";
        Set<String> keys = ausgaenge.keySet();
        for(String ausgang : keys)
            ergebnis += " " + ausgang;
        return ergebnis;
    }

    /**
     * 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.
     */
    public Raum gibAusgang(String richtung) 
    {
        return ausgaenge.get(richtung);
    }
}
```

Befehl:

```
/**
 * Objekte dieser Klasse halten Informationen ueber Befehle,
 * die der Benutzer eingegeben hat. Ein Befehl besteht momentan
 * aus zwei Zeichenketten: einem Befehlswort und einem zweiten
 * Wort. Beim Befehl "nimm karte" beispielsweise sind die beiden
 * Zeichenketten "nimm" und "karte".
 * 
 * Befehle werden von Benutzern dieser Klasse auf Gueltigkeit
 * ueberprueft. Wenn ein Spieler einen ungueltigen Befehl eingegeben
 * hat (ein unbekanntes Befehlswort), dann ist das Befehlswort <null>.
 *
 * Wenn der Befehl nur aus einem Wort bestand, dann ist das
 * zweite Wort <null>.
 * 
 * @author  Michael K�lling und David J. Barnes
 * @version 2008.03.30
 */

class Befehl
{
    private String befehlswort;
    private String zweitesWort;

    /**
     * Erzeuge ein Befehlsobjekt. Beide Woerter muessen angegeben werden,
     * aber jedes oder beide duerfen 'null' sein.
     * @param erstesWort Das erste Wort des Befehls. Sollte
     *                   'null' sein, wenn dieser Befehl als nicht
     *                   vom Spiel erkannt gekennzeichnet werden soll.
     * @param zweitesWort Das zweite Wort des Befehls.
     */
    public Befehl(String erstesWort, String zweitesWort)
    {
        befehlswort = erstesWort;
        this.zweitesWort = zweitesWort;
    }

    /**
     * Liefere das Befehlswort (das erste Wort) dieses Befehls.
     * Wenn der Befehl nicht verstanden wurde, ist das Ergebnis
     * 'null'.
     * @return Das Befehlswort.
     */
    public String gibBefehlswort()
    {
        return befehlswort;
    }

    /**
     * @return Das zweite Wort dieses Befehls. Liefere 'null', wenn
     * es kein zweites Wort gab.
     */
    public String gibZweitesWort()
    {
        return zweitesWort;
    }

    /**
     * @return 'true', wenn dieser Befehl nicht verstanden wurde.
     */
    public boolean istUnbekannt()
    {
        return (befehlswort == null);
    }

    /**
     * @return 'true', wenn dieser Befehl ein zweites Wort hat.
     */
    public boolean hatZweitesWort()
    {
        return (zweitesWort != null);
    }
}
```

Befehlswörter:

```
/*
 * Diese Klasse haelt eine Aufzaehlung aller Befehlswoerter, die dem
 * Spiel bekannt sind. Mit ihrer Hilfe werden eingetippte Befehle
 * erkannt.
 *
 * @author  Michael K�lling und David J. Barnes
 * @version 2008.03.30
 */

class Befehlswoerter
{
    // ein konstantes Array mit den gueltigen Befehlsw�rtern
    private static final String gueltigeBefehle[] = {
        "gehe", "ende", "hilfe"
    };

    /**
     * Konstruktor - initialisiere die Befehlswoerter.
     */
    public Befehlswoerter()
    {
        // nichts zu tun momentan...
    }

    /**
     * Pruefe, ob eine gegebene Zeichenkette ein gueltiger
     * Befehl ist.
     * @return 'true', wenn die gegebene Zeichenkette ein gueltiger
     * Befehl ist, 'false' sonst.
     */
    public boolean istBefehl(String eingabe)
    {
        for(int i = 0; i < gueltigeBefehle.length; i++) {
            if(gueltigeBefehle[i].equals(eingabe))
                return true;
        }
        // Wenn wir hierher gelangen, wurde die Eingabe nicht
        // in den Befehlswoerter gefunden.
        return false;
    }

    /**
     * Gib alle gueltigen Befehlswoerter auf die Konsole aus.
     */
    public void alleAusgeben() 
    {
        for(String befehl : gueltigeBefehle) {
            System.out.print(befehl + "  ");
        }
        System.out.println();
    }
}
```

Das Problem beim erstellen der neuen Klasse ist auch einfach, dass ich nicht genau weiß wie ich sie mit den anderen Klassen verknüpfe bzw. sie integriere... außerdem denke ich mal das ein einziger Gegenstand reicht.

Danke im voraus.


----------



## diggaa1984 (14. Nov 2013)

Ok also "ohne größeren Aufwand" und zuviel Klassen würde ich vorschlagen:

Eine neue Klasse Gegenstand wird erzeugt, welche beliebige Attribute erhalten könnte. Für den Anfang reicht aber eine Bezeichnung. 

Die Klasse Raum erhält Methoden zum Platzieren und Entfernen/Aufheben von Gegenständen. 
In der Raumklasse brauchst du dann noch ein Klassenattribut um die Gegenstände im Raum zu speichern. Weiterhin, um deinen Beispiel zu folgen, kannst du dem Raum ein Attribut "verschlossen" geben, welches angibt, dass du nur mit einem Schlüssel herein kannst.
Welcher Datentyp reicht hier?

In der Klasse Spiel beim Anlegen der Räume kannst du die Gegenstände mit den neuen Methoden dem Raum hinzufügen. 
Weiterhin musst du dann beim Laufen prüfen ob ein Raum verschlossen ist oder nicht und ob "Du" (eine Spielerfigur gibt es nicht wirklich) einen Schlüssel hast. 
Man könnte der Einfachheit halber ein Attribut "Inventar" der Klasse Spiel hinzufügen und dort Gegenstände die man in Räumen findet hinzufügen.

Soweit sollte das abgedeckt sein ^^
Jetzt kommst du


----------



## Parad0x (14. Nov 2013)

diggaa1984 hat gesagt.:


> Ok also "ohne größeren Aufwand" und zuviel Klassen würde ich vorschlagen:
> 
> Eine neue Klasse Gegenstand wird erzeugt, welche beliebige Attribute erhalten könnte. Für den Anfang reicht aber eine Bezeichnung.
> 
> ...



Ich werde dann jetzt mal ein bisschen herumprobieren ob ich was hinbekomme (könnte etwas dauern bei meiner Java Erfahrung^^...)

Ich melde mich dann später wieder.


----------



## Parad0x (14. Nov 2013)

Hmmpf.. ich habe jetzt die ganze Zeit rumprobiert, bin aber zu keinem Ergebnis gekommen. Ein Code Beispiel von jemandem wäre ganz hilfreich um den Dreh rauszubekommen :/ wie gesagt bin ich totaler Java Anfänger und kenne jediglich die basics der basics.


----------



## ARadauer (14. Nov 2013)

So wie Beschreibung von raum. Ich würde zu Beginn mal einfach einen string nehmen. In spiel könnte man eine arraylist von strings als Inventar haben. Aber grundsätzlich wirds ohne Grundkenntnisse schwer...


----------



## diggaa1984 (14. Nov 2013)

Was ist denn das Ergebnis deines Probierens? Was hast du probiert und wie weit bist du gekommen?


----------



## Sotsch (14. Nov 2013)

Hey Parad0x,

Es wäre hilfreich wenn du einmal zeigst wie deine 
	
	
	
	





```
main
```
 - Methode aussieht.
Vielleicht kann ich dir dann ein bisschen weiterhelfen. 
Dir einfach Quelltext zurecht zu legen würde dir nicht weiterhelfen, schließlich willst du ja Java verstehen und wissen was objektorientiert heißt!

Du hast geschrieben das dir noch nicht ganz klar ist wie du verschiedene Klassen zusammenarbeiten lässt. 
Und weil du ja Gegenstände aufheben können möchtest, bietet sich an erst einmal eine neue Klasse zu erstellen, die Gegenstände (oder konkret einen Schlüssel) repräsentiert. 
In deiner Welt sollen Gegenstände sicher mehr sein als nur Text. Sie sollen unter Umständen Türen öffnen, dunkle Räume erhellen, je nachdem was dir gerade einfällt.

Das Erste was du sicher schon weißt ist, dass eine Klasse grundlegend eine Sammlung von Attributen und Funktionen/Methoden ist.
Ein Gegenstand wie z.B. ein Schlüssel hat auch Attribute (wie Name, Beschreibung, Farbe, passendes Schloß...)
sowie eine funktionalität (z.B. die Methode 
	
	
	
	





```
versucheTuerZuOeffnen(Tuer tuer)
```
).

Du könntest also zunächst so Anfangen eine neue Klasse zu definieren, die nach folgendem Schema aufgebaut ist:


```
class Schluessel
{
  private String bezeichnung;
  private Tuer passendeTuer;
  private ...

  public boolean versucheTuerZuOeffnen(Tuer tuer){ 
    // Pruefe ob dieser Schluessel die hier hin uebergebene Tuer oeffnen kann, wenn ja, dann liefere true,
    // wenn nein dann liefere false
  }

}
```

Wie du vielleicht siehst wird es darauf hinauslaufen eine Klasse Tuer zu definieren (Wenn du nach diesem Schema arbeitest).
Eine andere Möglichkeit wäre es nur zu sagen das ein Schlüssel einen bestimmten Raum öffnen kann.
Dann müsstest du wie folgt vorgehen:



```
class Schluessel
{
  private String bezeichnung;
  private Raum passenderRaum; //Der Raum zu dem der Schluessel passt
  private ...

  public boolean versucheRaumZuOeffnen(Raum raum){ 
    // Pruefe ob dieser Schluessel den hier hin uebergebenen Raum frei gibt, wenn ja, dann liefere true,
    // wenn nein dann liefere false
  }

  public void bestimmePassendenRaum(Raum raum){
     passenderRaum = raum; //Setze den passenden Raum
  }

}
```

Ich hoffe das konnte ein wenig helfen. Ich denke erstmal solltest du dich damit vertraut machen eigene Klassen zu schreiben.
Wie du in meinem kleinen Entwurf vielleicht erkennst, hast du eine kleine Interaktion zwischen der Klasse Raum und der Klasse Schluessel geschaffen. Die Methode versucheRaumZuOeffnen ist eine solche Interaktion, eine Schnittstelle.


----------

