mehrere Instanzen einer Klasse, trotz Random immer das Selbe

[Silver-Blue]

Hi ich hab hier ein Problem jedesmal wenn ich das SPiel startet sollten eigentlich für jeden Raum eine neue Instanz der Klasse Raum erzeugt werden, in der Klasse Raum werden aus einer HashMap zufällig ein paar Gegenstände herausgeholt und im Raum verteilt, aber jedes mal hab ich in jedem Raum die selben Sachen. Ich erzeug mit Random eine Zufallszahl und die bestimmt welcher Gegenstand oder mehrere in das Array für Gegenstaende(as) kommt. Es gibt noch eine Klasse Gegenstaende in der die Inhalte der HashMap zurück gegeben werden. ISt Random so blöd das er mir für jeden Raum immer wieder die selben zahlen erzeugt, das kann ja fast nicht sein mir kommt so vor als würde er die Gegenstände nur einmal erzeugen und dann auf alle verteilen. Ich dachte mit new würde ich eine frische Instanz erzeugen.

Das ist jeweil nur Teilcode nicht die Vollstaendige Klasse

class Spiel 
{
     
     * Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
     */
    private void raeumeAnlegen()
    {
        Raum draussen, hoersaal, cafeteria, labor, buero;
        
      
        // die Räume erzeugen
        draussen = new Raum("vor dem Haupteingang der Universität",dingens);
        hoersaal = new Raum("in einem Vorlesungssaal",dingens);
        cafeteria = new Raum("in der Cafeteria der Uni",dingens);
        labor = new Raum("in einem Rechnerraum",dingens);
        buero = new Raum("im Verwaltungsbüro der Informatik",dingens);
        
        // 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);

        aktuellerRaum = draussen;  // das Spiel startet draussen

Hier die Klasse Raum

public class Raum 
{
    private String beschreibung;
    private HashMap ausgaenge;        // die Ausgänge dieses Raums
    private Gegenstaende dinge;
    private ArrayList as;
    private String ergeb;
    /**
     * 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,Gegenstaende dinge) 
    {
        this.beschreibung = beschreibung;
        ausgaenge = new HashMap();
        this.dinge = dinge;
        as = new ArrayList();
        ergeb = "";
        inventar();
        things();
        
       
    }

       private void inventar()
   {
       
       Random zufall = new Random();
       int y = zufall.nextInt(4);
       y+=1;
       int ix = zufall.nextInt(y);
       for (int i =0; ix > as.size(); i++)
       {
           int yx = zufall.nextInt(dinge.getListengroesse());
           
           as.add(dinge.getGegenstand(yx));
        }
    }
        private void things()
        {
           ergeb = "";
           for (Iterator it = as.iterator(); it.hasNext();)
        {
            String x =(String) it.next();
            ergeb += x +"(" + dinge.getDing(x) + ")";
        }
        }
        
   
   
  }  
}

 

[daLenz]

hi, also ich setze beim random noch folgendes

zufall.setSeed(new Date().getTime());

so kann man sicher davon ausgehen, dass jedesmal ein völlig anderer Random erzeugt wird....

hoffe das hilft weiter!

greetz

 

[dotlens]

Lass dir doch die zufallszahl zurückgeben, um zu testen ob sie sich verändert.

 

[Silver-Blue]

Ok danke, werd mich gleich dran machen. Vielen Dank

 

[Silver-Blue]

Geht alles nicht egal was ich mach.
Hab mit dem Debugger nun festgestellt das er beim erzeugen der Räume, also genau an den new Stellen tatsächlich für jeden Raum verschiedene Gegenstände erzeugt.Irgendwo wird das überschrieben, ich weis blos nicht wo. Hock jetzt schon über einen Tag an dem Sch... er nimmt irgendwie später die Gegenstände vom ersten Raum für alle anderen. Die Beschreibung vom Raum hingegen bringt er richtig. Wenn ich so ein paar Räume erzeuge und da mal die Methoden gibLangeBeschreibung aufrufe gibt sie auch verschiedene Wert zurück je nach Raum. Das ist echt seltsam alles...ggg. Es spuckt.



:autsch: ???:L :bae:
[schild=1 fontcolor=000000 shadowcolor=C0C0C0 shieldshadow=1]HuiBUUUUUUHHH[/schild]

 

[Illuvatar]

Höchstens spukt es. In deinem Code oben kann ich übrigens nix erkennen, was das überschreibt.

 

[dotlens]

also das objekt 'Gegentaende' das du übergibst (dingens) ist immer das selbe. ich nehme mal an hier sind alle Gegenstände enthalten??

Wieso arbeitest du nicht mit Math.random()? Der erzeugt immer neue Zahlen...

 

[Silver-Blue]

Also hier mal der ganze Code, nur falls jemand die muse hat mal zu schauen. Es git noch 3 weiter Klassen Parser, Befehl, Befehlswörter. Das ist Übung 8 für die JavaVorlesung. Wir sollen eine bereits vorhandenes Prog das Spiel Zuul erweitern. Die Methoden aufheben und ablegen hab ich noch nicht fertig, da ich diesen Fehler erst finden muss, ich steh kurz davor das Komplette Spiel neu zu schreiben :autsch:

import java.util.Set;
import java.util.HashMap;
import java.util.Iterator;
import java.util.*;
/*
 * Diese Klasse modelliert Räume in der Welt von Zuul.
 * 
 *  */

public class Raum 
{
    private String beschreibung;
    private HashMap ausgaenge;        // die Ausgänge dieses Raums
    private Gegenstaende dinge;
    private ArrayList as;
    private String ergeb;
    /**
     * 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,Gegenstaende dinge) 
    {
        this.beschreibung = beschreibung;
        ausgaenge = new HashMap();
        this.dinge = dinge;
        as = new ArrayList();
        ergeb = "";
        inventar();
        things();
        
       
    }



    /**
     * 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);
    }

    /**
     * Liefere die 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
     */
    public String gibLangeBeschreibung()
    {
        
            
        return "Sie sind " + beschreibung + ".\n" +"In dem Raum gibt es folgende Gegenstaende :" +"\n" + ergeb + "\n"+ gibAusgaengeAlsString();
    }

    /**
     * Liefere eine Zeichenkette, die die Ausgänge dieses Raums
     * beschreibt, beispielsweise
     * "Ausgänge: north west".
     */
    private String gibAusgaengeAlsString()
    {
        String ergebnis = "Ausgänge:";
        Set keys = ausgaenge.keySet();
        for(Iterator iter = keys.iterator(); iter.hasNext(); )
            ergebnis += " " + iter.next();
        return ergebnis;
    }

    /**
     * Liefere den Raum, den wir erreichen, weint ix = zufall.nextInt(dinge.getListengroesse());nn 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.
     */
    public Raum gibAusgang(String richtung) 
    {
        return (Raum)ausgaenge.get(richtung);
    }
    
   private void inventar()
   {
       
       Random zufall = new Random();
       int y = zufall.nextInt(4);
       y+=1;
       int ix = zufall.nextInt(y);
       for (int i =0; ix > as.size(); i++)
       {
           int yx = zufall.nextInt(dinge.getListengroesse());
           
           as.add(dinge.getGegenstand(yx));
        }
    }
        private void things()
        {
           ergeb = "";
           for (Iterator it = as.iterator(); it.hasNext();)
        {
            String x =(String) it.next();
            ergeb += x +"(" + dinge.getDing(x) + ")";
        }
        }
        
   
   
    public void gegenstandAblegen(String gegenstand)
    {
        
        String b = gegenstand;
        b += "("+ dinge.getDing(gegenstand)+ ")"+"\n";
        as.add(b);
        things();
    }
   public void gegenstandAufheben(String gegenstand)
   {
       
        for (Iterator it = as.iterator(); it.hasNext();)
        {
          String x = (String) it.next();
          if(gegenstand.equals(x)){
          it.remove();  
       }
        things();
       
    }  
}  
}

Hier die Klasse Spiel die methode void spielen ist praktisch main von hier aus geht alles los.

import java.util.*;
/**
 *  Dies ist die Hauptklasse der Anwendung "Die Welt von Zuul".
 */

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

    /**
     * Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
     */
    private void raeumeAnlegen()
    {
        Raum draussen, hoersaal, cafeteria, labor, buero;
        
      
        // die Räume erzeugen
        draussen = new Raum("vor dem Haupteingang der Universität",dingens);
        hoersaal = new Raum("in einem Vorlesungssaal",dingens);
        cafeteria = new Raum("in der Cafeteria der Uni",dingens);
        labor = new Raum("in einem Rechnerraum",dingens);
        buero = new Raum("im Verwaltungsbüro der Informatik",dingens);
        
        // 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);

        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.");
    }

    /**
     * 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).
     * Wenn der Befehl das Spiel beendet, wird 'true' zurückgeliefert,
     * andernfalls 'false'.
     */
    private boolean verarbeiteBefehl(Befehl befehl) 
    {
        boolean moechteBeenden = false;

        if(befehl.istUnbekannt()) {
            System.out.println("Ich weiß 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("take"))
            aktuellerRaum.gegenstandAufheben(befehl.gibZweitesWort());
        else if (befehlswort.equals("quit")) {
            moechteBeenden = beenden(befehl);
        }
        
        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, 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("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. Liefere '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.
    }
}