2D Array eingabe vom Benutzer

Hamudi Bachir

Hamudi Bachir

Mitglied
Für ein Hochschul projekt brauch ich für das bekannte spiel des Lebens eine benutzerdefinierte eingabe für die große des Spiel felds.

Das ganze in einem 2D Array. Ich habe meine Code angefangen zu schreiben und die eingabe funktioniert aber es kommt eine fehlermeldung mit der ich nix anfangen kann.

Der code:


import java.util.Scanner ;


public class Main {

public static void main(String[] args) {

// Begrüßung/ Erklärung/Regeln vom Spiel

System.out.println("Willkommen bei dem Simulationsspiel Spiel des Lebens.");
System.out.println("Das Spiel des Lebens ist eine einfache Simulation von Wachstumsprozessen.");


// Eingabe vom Benutzer für die Größe des Spielfelds in einem 2D Array

Scanner sc = new Scanner (System.in);

System.out.println("Bitte geben sie die Zeilen anzahl des Spielfeldes ein. ");
int i = sc.nextInt() ;
System.out.println("Bitte geben sie die Spalten anzahl des Spielfelds ein.");
int j= sc.nextInt() ;

int Spielfeld [][] = new int [j] ;


for (i=0; i<Spielfeld.length; i++){

for (j=0; i<Spielfeld.length; j++)

System.out.println(Spielfeld[j]);
}



}

}

Fehlermeldung : Screenshot (29).png
 
Wenn du Englisch kannst ist die Aussage doch eindeutig: Du versuchst auf einen Index des Arrays zuzugreifen, den es nicht gibt.

Verwende für Code bitte die Code-Tags (</> im Editor). [i] wird sonst als kursiv interpretiert und fehlt damit im gezeigten Code.

Ansonsten, schau dir mal deine Schleifenbedingungen genau an.
 
Also erst einmal wäre es super, denn Du Code in Code-Tags schreiben würdest. Das geht am einfachsten über den Knopf </> oberhalb der Eingabe.
Sonst wird z.B. das [i] als Start einer rekursiven Darstellung gewertet.

Daher sehe ich jetzt erst einmal nicht das Problem bei Deinem Code. Kernaussage der Fehlermeldung ist, dass Du auf Index 5 zugreifst von einem Array, das nur 5 Felder groß ist (Index von 0 bis 4).

Aber die Schleife besagt auch sauber, dass es jeweils < ist.
 
kneitzel hat gesagt.:
Also erst einmal wäre es super, denn Du Code in Code-Tags schreiben würdest. Das geht am einfachsten über den Knopf </> oberhalb der Eingabe.
Sonst wird z.B. das [i] als Start einer rekursiven Darstellung gewertet.

Daher sehe ich jetzt erst einmal nicht das Problem bei Deinem Code. Kernaussage der Fehlermeldung ist, dass Du auf Index 5 zugreifst von einem Array, das nur 5 Felder groß ist (Index von 0 bis 4).

Aber die Schleife besagt auch sauber, dass es jeweils < ist.
Zum Vergrößern anklicken....

temi hat gesagt.:
Wenn du Englisch kannst ist die Aussage doch eindeutig: Du versuchst auf einen Index des Arrays zuzugreifen, den es nicht gibt.

Verwende für Code bitte die Code-Tags (</> im Editor). [i] wird sonst als kursiv interpretiert und fehlt damit im gezeigten Code.

Ansonsten, schau dir mal deine Schleifenbedingungen genau an.
Zum Vergrößern anklicken....
Danke erstmal.
Hier der Code nochmal als Scrennshot. Dann weiß ich für das nächste mal mit der Eingabe bescheid.

Also mein Problem hab ich jetzt nicht wirklich gefunden. Ich habe versucht das der Benutzer eine Eingabe tätigt für ein Spielfeld. Nach der Eingabe wird halt das Spielfeld in einem 2D array erstellt.

"Halten Sie die Größe des Spielfelds flexibel, indem Sie die Zahl der Zeilen und Spalten als symbolische Konstanten definieren. Sehen Sieauch eine Möglichkeit vor, die Ausgangsbedingung zufällig zu erzeugen" <- Der teil der aufgaben Stellung.
Screenshot (30).png
 
Ansonsten noch ein Tipp: Variablennamen mit einem Buchstaben, wie "i" sind für Schleifenvariablen i.d.R. in Ordung, aber gerade bei mehrdimensionalen Arrays führen sie häufig zu Verwirrung. Besser wäre es aussagekräftige Namen wie "zeile" und "spalte" zu nehmen. Dann muss man nicht so viel denken. 😉
 
temi hat gesagt.:
Ansonsten noch ein Tipp: Variablennamen mit einem Buchstaben, wie "i" sind für Schleifenvariablen i.d.R. in Ordung, aber gerade bei mehrdimensionalen Arrays führen sie häufig zu Verwirrung. Besser wäre es aussagekräftige Namen wie "zeile" und "spalte" zu nehmen. Dann muss man nicht so viel denken. 😉
Zum Vergrößern anklicken....
Klingt viel besser. Danke !
 
temi hat gesagt.:
Ganz genau ansehen!
Zum Vergrößern anklicken....
Kann es sein das ich in den Zeilen 26 und 28 nach der Eingabe die Eingabe sozusagen wieder auf 0 zurück setzte ?

hier der Code richtig eingefügt hoffe ich mal 😀

Java: 
import java.util.Scanner ;


public class Main {

    public static void main(String[] args) {
            
        // Begrüßung/ Erklärung/Regeln vom Spiel
        
        System.out.println("Willkommen bei dem Simulationsspiel Spiel des Lebens.");
        System.out.println("Das Spiel des Lebens ist eine einfache Simulation von Wachstumsprozessen.");
    
        
        // Eingabe vom Benutzer für die Größe des Spielfelds in einem 2D Array
        
        Scanner sc = new Scanner (System.in);
        
        System.out.println("Bitte geben sie die Zeilen anzahl des Spielfeldes ein. ");
        int zeilen = sc.nextInt() ;
        System.out.println("Bitte geben sie die Spalten anzahl des Spielfelds ein.");
        int spalten = sc.nextInt() ;
        
        int Spielfeld [][] = new int [zeilen][spalten] ;
        
        
                    for (zeilen =0; zeilen<Spielfeld.length; zeilen++){         
                    
                        for (spalten =0; spalten <Spielfeld[i].length; spalten++)
                            
                                System.out.println(Spielfeld[zeilen][spalten]);
        }
        
        
        
    }

}
 
Hamudi Bachir hat gesagt.:
Der Fehler ist gefunden aber wenn ich jetzt 26 = : Zeilen = 0 ; raus lösche muss ich zeilen dann irgendwie als eingabe vom benutzer da irgendwie deffinieren?
Zum Vergrößern anklicken....
Ich verstehe die Frage nicht. Warum willst du in Zeile 26 etwas löschen?

Und dann war da noch: In Java gibt es Konventionen. Klassennamen beginnen mit einem Großbuchstaben und Variablen-, sowie Methodennamen mit einem Kleinbuchstaben. Demnach "Spielfeld" => "spielfeld". Es ist sinnvoll sich daran zu halten, dann tun sich alle leichter, den Code zu lesen.
 
temi hat gesagt.:
Ich verstehe die Frage nicht. Warum willst du in Zeile 26 etwas löschen?
Zum Vergrößern anklicken....
Hab meine Fehler gefunden und hat es hat funktioniert danke. Wenn der Benutzer 5 x 5 eingibt gebt mir die Console 26 mal die 0 raus weil noch nix im array gespeichert ist.

Ich hätte noch eine weitere frage was genau mit n x m Zellen gemeint ist.

Aufgabenstellung :

"Die Simulation erfolgt typischerweise auf einem zweidimensionalen Spielfeld mit n x m Zellen."

Soll es heißen das das Array im Aufbau so aussehen soll? und n und m sozusagen dann die zeilen und spalten sind?
 
temi hat gesagt.:
Ja, gibt es natürlich. Du musst es halt anders ausgeben.

Die Spalten ohne Zeilenumbruch mit print() und für die Zeilen dann einen Zeilenumbruch mit println().
Zum Vergrößern anklicken....
Ich habe jetzt weiter dran gearbeitet und versucht die arrays mit jeweils 0 und 1 zu füllen für tote oder lebende zelle.

In den Zeilen 39 und 41 zeigt er mir an das die variablen sich doppeln aber ich benutze die doch für das selbe oder?

funktioniert meine variante mit der zufalls genaration von 0 und 1 so überhaupt?


[CODE lang="java" title="math random" highlight="39-42"]import java.util.Scanner ;



public class Main {

public static void main(String[] args) {

// Begrüßung

System.out.println("Willkommen bei dem Simulationsspiel Spiel des Lebens.");
System.out.println("Das Spiel des Lebens ist eine einfache Simulation von Wachstumsprozessen.");


// Eingabe vom Benutzer für die Größe des Spielfelds in einem 2D Array

Scanner sc = new Scanner (System.in);

System.out.println("Bitte geben sie die Zeilen anzahl des Spielfeldes ein. ");
int zeilen = sc.nextInt() ;
System.out.println("Bitte geben sie die Spalten anzahl des Spielfelds ein.");
int spalten = sc.nextInt() ;


// Array erstellt mit Eingabe vom Benutzer

int Spielfeld [][] = new int [zeilen][spalten] ;


for (zeilen =0; zeilen<Spielfeld.length; zeilen++){

for (spalten =0; spalten <Spielfeld[zeilen].length; spalten++)

System.out.print(Spielfeld[zeilen][spalten]);

// Zufällig 0 und 1 in array einspeichern


for(int zeilen = 0; zeilen<Spielfeld.length; zeilen++){

for(int spalten = 0; spalten<Spielfeld[0].length; spalten++){

Spielfeld[zeilen][spalten] = Math.round(Math.random());
}
}




}




}

}
[/CODE]
 
Du deklarierst die Variable aber erneut. Du kannst keine zwei lokalen Variablen mit dem gleichen Namen haben.

Wenn Du die Variable von oben erneut verwenden willst, dann, dann lass das int weg. Aber dieses Variablen mehrfach benutzen ist ein Unding, das man nicht machen sollte! Das führt automatisch zu Problemen - so wie bei Dir, denn du hast die Schleifen ja verschachtelt - Du wirst in der inneren Schleife mit "zeile" ja nicht die Schleifenvariable zeile der äußeren Schleife überschreiben wollen ...

Und dann ein Tipp, den Du Dir zu Herzen nehmen solltest: Teile es in Methoden auf! Du verzettelst Dich ganz offensichtlich total. Eine so tiefe Verschachtelung ist einfach unleserlich und wenn erfahrene Entwickler sowas vermeiden: Was meinst Du, das Du einen besseren Überblick hast?
 
kneitzel hat gesagt.:
Du deklarierst die Variable aber erneut. Du kannst keine zwei lokalen Variablen mit dem gleichen Namen haben.

Wenn Du die Variable von oben erneut verwenden willst, dann, dann lass das int weg. Aber dieses Variablen mehrfach benutzen ist ein Unding, das man nicht machen sollte! Das führt automatisch zu Problemen - so wie bei Dir, denn du hast die Schleifen ja verschachtelt - Du wirst in der inneren Schleife mit "zeile" ja nicht die Schleifenvariable zeile der äußeren Schleife überschreiben wollen ...

Und dann ein Tipp, den Du Dir zu Herzen nehmen solltest: Teile es in Methoden auf! Du verzettelst Dich ganz offensichtlich total. Eine so tiefe Verschachtelung ist einfach unleserlich und wenn erfahrene Entwickler sowas vermeiden: Was meinst Du, das Du einen besseren Überblick hast?
Zum Vergrößern anklicken....
Also ich habe gedacht das ich um die arrays mit 0 und 1 zu füllen zufällig wieder die gleiche variable nehmen muss. Könnte ich also eine andere variable deklarien und die dann in das array speichern?

Wie genau ist es gemeint es in Methoden aufzuteilen ? Ich merke es auch das ich mich sehr verzettelte. Danke schonmal für die Hilfe.
 
Hamudi Bachir hat gesagt.:
Wie genau ist es gemeint es in Methoden aufzuteilen ?
Zum Vergrößern anklicken....
Du könntest z. B. eine Methode ausgeben(int[][] feld) schreiben, die nur für die Ausgabe zuständig ist, also das, was du in den ersten beiden verschachtelten Schleifen gemacht hat. Innerhalb dieser Methoden kannst du, falls erforderlich, die gleichen Bezeichnungen für die Variablen verwenden, weil es sich um andere, lokale Variablen handelt.

Java: 
public class Main {

    public static void main(String[] args) {
          
        // code..
      
        // Array erstellt mit Eingabe vom Benutzer
      
        int spielfeld [][] = new int [zeilen][spalten] ;
        ausgeben(spielfeld); // leeres Spielfeld ausgeben
      
        zufaelligFuellen(spielfeld);
      
        ausgeben(spielfeld); // zufällig gefülltes Spielfeld ausgeben
      
        // mehr code..
    }
  
    public static void ausgeben(int[][] feld) {
        // code..
    }
  
    public static void zufaelligFuellen(int[][] feld) {
        // code..
    }

Hamudi Bachir hat gesagt.:
Also ich habe gedacht das ich um die arrays mit 0 und 1 zu füllen zufällig wieder die gleiche variable nehmen muss. Könnte ich also eine andere variable deklarien und die dann in das array speichern?
Zum Vergrößern anklicken....
Welche Variablen möchtest du denn im Array speichern? Ein int-Array kann ja nur int-Werte aufnehmen. Ansonsten kannst du die Variablen für den Zugriff auf den Arrayindex natürlich so nennen wie du willst. Die Benennung sollte halt sinnvoll sein, damit man später noch durchblickt.
 
Zuletzt bearbeitet:
Also ein wichtiger Schritt ist immer, dass Du Dir überlegst, was Du genau machen willst.

Du willst:
-> Für Jede Zeile des Felder ..
--> Für jedes Spalte der Zeile ...
---> Dann erneut jede Zeile des Feldes ..
----> für jede Spalte des Feldes ...
etwas machen? Das ist so großer Quatsch. Daher: Schreib genau auf, was Du machen willst:

Du willst doch nur:
- Alle Zeilen durchgehen
- dann für jede Zeile alle Spalten/Felder durchgehen
- mit jedem Feld etwas machen ...

Die Methoden werden wichtig, weil Du dann wirklich nichts durcheinander werfen kannst:

Java: 
public static int[][] createPlayground(int rowCount, int columnCount) {
    return new int[rowCount][columnCount];
}

// In die main kommt dann nur noch:
int [][] spielfeld = createPlayground(zeilen, spalten);

Das mit dem Füllen wäre dann etwas wie folgt:
Java: 
public static void fillPlayground(int[][] playground) {
    for (int row = 0; row < playground.length; row++) {
        for (int column = 0; column < playground[row].length; column++) {
            playground[row][column] = getRandomFieldContent();
        }
    }
}

public static int getRandomFieldContent() {
    return .... // Hier dann deine Zufallszahl generieren ...
}

Das nur um den Ansatz zu zeigen. Die englischen Begriffe kannst Du gerne eindeutschen. Aber Ziel ist, viele kleine Methoden zu bekommen, deren Name genau aussagt, was die Methoden machen. Und dann wird Code deutlich lesbarer. Und wenn Methoden kurz bleiben, dann wird es auch einfach... Das füllen kann man auch noch unterteilen ... Du kannst für jede Zeile ein fillPlaygroundRow(int[] playgroundRow) aufrufen ...

Du musst es nicht übertreiben - aber maximale Verschachtelung von Schleifen sollte 2 sein. Mehr wie 2 Schleifen ineinander darf es nicht geben - da ist die Erfahrung, dass Anfänger da keinen Überblick haben, was da genau passiert.

Das einfach mal als kurze Erläuterung. Ich weiss, dass ich da evtl. jetzt mit neuen Dingen um die Ecke komme, aber das ist etwas, das aus meiner Sicht vieles vereinfacht und ich kann nicht verstehen, dass Leute, die Anderen die Entwicklung von Software beibringen, sowas nicht von Anfang an zumindest immer zeigen!
 
temi hat gesagt.:
Du könntest z. B. eine Methode ausgeben(int[][] feld) schreiben, die nur für die Ausgabe zuständig ist, also das, was du in den ersten beiden verschachtelten Schleifen gemacht hat. Innerhalb dieser Methoden kannst du, falls erforderlich, die gleichen Bezeichnungen für die Variablen verwenden, weil es sich um andere, lokale Variablen handelt.

Java: 
public class Main {

    public static void main(String[] args) {
         
        // code..
     
        // Array erstellt mit Eingabe vom Benutzer
     
        int spielfeld [][] = new int [zeilen][spalten] ;
        ausgeben(spielfeld); // leeres Spielfeld ausgeben
     
        zufaelligFuellen(spielfeld);
     
        ausgeben(spielfeld); // zufällig gefülltes Spielfeld ausgeben
     
        // mehr code..
    }
 
    public static void ausgeben(int[][] feld) {
        // code..
    }
 
    public static void zufaelligFuellen(int[][] feld) {
        // code..
    }


Welche Variablen möchtest du denn im Array speichern? Ein int-Array kann ja nur int-Werte aufnehmen. Ansonsten kannst du die Variablen für den Zugriff auf den Arrayindex natürlich so nennen wie du willst. Die Benennung sollte halt sinnvoll sein, damit man später noch durchblickt.
Zum Vergrößern anklicken....
Es geht um das Spiel des Lebens und ich möchte 0/1 zufällig zuerst in das Array speichern damit ich danach mit den Regeln bestimmt wird ob die zelle weiter lebt oder ausstirbt.

Ich werde das mal mit den verschiedenen methoden ausprobieren.
kneitzel hat gesagt.:
Also ein wichtiger Schritt ist immer, dass Du Dir überlegst, was Du genau machen willst.

Du willst:
-> Für Jede Zeile des Felder ..
--> Für jedes Spalte der Zeile ...
---> Dann erneut jede Zeile des Feldes ..
----> für jede Spalte des Feldes ...
etwas machen? Das ist so großer Quatsch. Daher: Schreib genau auf, was Du machen willst:

Du willst doch nur:
- Alle Zeilen durchgehen
- dann für jede Zeile alle Spalten/Felder durchgehen
- mit jedem Feld etwas machen ...

Die Methoden werden wichtig, weil Du dann wirklich nichts durcheinander werfen kannst:

Java: 
public static int[][] createPlayground(int rowCount, int columnCount) {
    return new int[rowCount][columnCount];
}

// In die main kommt dann nur noch:
int [][] spielfeld = createPlayground(zeilen, spalten);

Das mit dem Füllen wäre dann etwas wie folgt:
Java: 
public static void fillPlayground(int[][] playground) {
    for (int row = 0; row < playground.length; row++) {
        for (int column = 0; column < playground[row].length; column++) {
            playground[row][column] = getRandomFieldContent();
        }
    }
}

public static int getRandomFieldContent() {
    return .... // Hier dann deine Zufallszahl generieren ...
}

Das nur um den Ansatz zu zeigen. Die englischen Begriffe kannst Du gerne eindeutschen. Aber Ziel ist, viele kleine Methoden zu bekommen, deren Name genau aussagt, was die Methoden machen. Und dann wird Code deutlich lesbarer. Und wenn Methoden kurz bleiben, dann wird es auch einfach... Das füllen kann man auch noch unterteilen ... Du kannst für jede Zeile ein fillPlaygroundRow(int[] playgroundRow) aufrufen ...

Du musst es nicht übertreiben - aber maximale Verschachtelung von Schleifen sollte 2 sein. Mehr wie 2 Schleifen ineinander darf es nicht geben - da ist die Erfahrung, dass Anfänger da keinen Überblick haben, was da genau passiert.

Das einfach mal als kurze Erläuterung. Ich weiss, dass ich da evtl. jetzt mit neuen Dingen um die Ecke komme, aber das ist etwas, das aus meiner Sicht vieles vereinfacht und ich kann nicht verstehen, dass Leute, die Anderen die Entwicklung von Software beibringen, sowas nicht von Anfang an zumindest immer zeigen!
Zum Vergrößern anklicken....
Vielen Dank für die Hilfe. Ja mit den Methoden zu vereinfachen und es übersichtlicher zu gestalten hatten wir bei den Vorlesungen an der Hoschule leider noch nicht. Ich setzt mich ran und versuch mich da durch zu codieren 😀
 
kneitzel hat gesagt.:
Also ein wichtiger Schritt ist immer, dass Du Dir überlegst, was Du genau machen willst.

Du willst:
-> Für Jede Zeile des Felder ..
--> Für jedes Spalte der Zeile ...
---> Dann erneut jede Zeile des Feldes ..
----> für jede Spalte des Feldes ...
etwas machen? Das ist so großer Quatsch. Daher: Schreib genau auf, was Du machen willst:

Du willst doch nur:
- Alle Zeilen durchgehen
- dann für jede Zeile alle Spalten/Felder durchgehen
- mit jedem Feld etwas machen ...

Die Methoden werden wichtig, weil Du dann wirklich nichts durcheinander werfen kannst:

Java: 
public static int[][] createPlayground(int rowCount, int columnCount) {
    return new int[rowCount][columnCount];
}

// In die main kommt dann nur noch:
int [][] spielfeld = createPlayground(zeilen, spalten);

Das mit dem Füllen wäre dann etwas wie folgt:
Java: 
public static void fillPlayground(int[][] playground) {
    for (int row = 0; row < playground.length; row++) {
        for (int column = 0; column < playground[row].length; column++) {
            playground[row][column] = getRandomFieldContent();
        }
    }
}

public static int getRandomFieldContent() {
    return .... // Hier dann deine Zufallszahl generieren ...
}

Das nur um den Ansatz zu zeigen. Die englischen Begriffe kannst Du gerne eindeutschen. Aber Ziel ist, viele kleine Methoden zu bekommen, deren Name genau aussagt, was die Methoden machen. Und dann wird Code deutlich lesbarer. Und wenn Methoden kurz bleiben, dann wird es auch einfach... Das füllen kann man auch noch unterteilen ... Du kannst für jede Zeile ein fillPlaygroundRow(int[] playgroundRow) aufrufen ...

Du musst es nicht übertreiben - aber maximale Verschachtelung von Schleifen sollte 2 sein. Mehr wie 2 Schleifen ineinander darf es nicht geben - da ist die Erfahrung, dass Anfänger da keinen Überblick haben, was da genau passiert.

Das einfach mal als kurze Erläuterung. Ich weiss, dass ich da evtl. jetzt mit neuen Dingen um die Ecke komme, aber das ist etwas, das aus meiner Sicht vieles vereinfacht und ich kann nicht verstehen, dass Leute, die Anderen die Entwicklung von Software beibringen, sowas nicht von Anfang an zumindest immer zeigen!
Zum Vergrößern anklicken....
Also werden die einzelnen bestandteile in verschiedenen Klassen geschrieben und dann in der Main klasse zusammen gefügt sozusagen? oder hab ich es da falsch verstanden ?
 
Nein, in Methoden einer Klasse. Es ist noch kein Objektorientierter Ansatz. Das dürfte bei dem, was Du da lernst, erst später kommen. Das wäre zwar aus meiner Sicht besser und das würde ich Dir auch gerne aufzeigen, aber da würde ich vermutlich über das Ziel hinaus schießen.

Also nur eine Klasse und in dieser dann viele Methoden. Die Methoden sind dann auch alle "static" - also noch nicht man im Ansatz Objektorientiert (Da wird der klare Ratschlag kommen, das static Schlüsselwort komplett zu verbannen bis auf die public static void main - und ggf. noch Konstanten oder so ...)
 
kneitzel hat gesagt.:
Also ein wichtiger Schritt ist immer, dass Du Dir überlegst, was Du genau machen willst.

Du willst:
-> Für Jede Zeile des Felder ..
--> Für jedes Spalte der Zeile ...
---> Dann erneut jede Zeile des Feldes ..
----> für jede Spalte des Feldes ...
etwas machen? Das ist so großer Quatsch. Daher: Schreib genau auf, was Du machen willst:

Du willst doch nur:
- Alle Zeilen durchgehen
- dann für jede Zeile alle Spalten/Felder durchgehen
- mit jedem Feld etwas machen ...

Die Methoden werden wichtig, weil Du dann wirklich nichts durcheinander werfen kannst:

Java: 
public static int[][] createPlayground(int rowCount, int columnCount) {
    return new int[rowCount][columnCount];
}

// In die main kommt dann nur noch:
int [][] spielfeld = createPlayground(zeilen, spalten);

Das mit dem Füllen wäre dann etwas wie folgt:
Java: 
public static void fillPlayground(int[][] playground) {
    for (int row = 0; row < playground.length; row++) {
        for (int column = 0; column < playground[row].length; column++) {
            playground[row][column] = getRandomFieldContent();
        }
    }
}

public static int getRandomFieldContent() {
    return .... // Hier dann deine Zufallszahl generieren ...
}

Das nur um den Ansatz zu zeigen. Die englischen Begriffe kannst Du gerne eindeutschen. Aber Ziel ist, viele kleine Methoden zu bekommen, deren Name genau aussagt, was die Methoden machen. Und dann wird Code deutlich lesbarer. Und wenn Methoden kurz bleiben, dann wird es auch einfach... Das füllen kann man auch noch unterteilen ... Du kannst für jede Zeile ein fillPlaygroundRow(int[] playgroundRow) aufrufen ...

Du musst es nicht übertreiben - aber maximale Verschachtelung von Schleifen sollte 2 sein. Mehr wie 2 Schleifen ineinander darf es nicht geben - da ist die Erfahrung, dass Anfänger da keinen Überblick haben, was da genau passiert.

Das einfach mal als kurze Erläuterung. Ich weiss, dass ich da evtl. jetzt mit neuen Dingen um die Ecke komme, aber das ist etwas, das aus meiner Sicht vieles vereinfacht und ich kann nicht verstehen, dass Leute, die Anderen die Entwicklung von Software beibringen, sowas nicht von Anfang an zumindest immer zeigen!
Zum Vergrößern anklicken....
Zu dem Code eine frage. Bei Row und column sind dann die Zeilen und Spalten gemeint oder etwas anderes ? weil in Zeile 6 dann zeilen und spalten aufeinmal geschrieben wurde. Das verstehe ich nicht ganz
 
Hamudi Bachir hat gesagt.:
Zu dem Code eine frage. Bei Row und column sind dann die Zeilen und Spalten gemeint oder etwas anderes ? weil in Zeile 6 dann zeilen und spalten aufeinmal geschrieben wurde. Das verstehe ich nicht ganz
Zum Vergrößern anklicken....
Ja genau, das wären die eingegebenen zeilen / spalten. Die Variablen hießen in Deinem Code noch i / j. Du kannst die Variablen deutsch lassen (zeilen / spalten) oder auf Englisch schreiben (rows / columns) ... ich bin es auf Englisch gewohnt, denn sonnst passt es nicht mit dem Java Framework. Da ist halt alles auf Englisch.
 
Das war ein weiteres Beispiel der Unterteilung. Die Methode getRandomFieldContent musst Du natürlich noch schreiben. Den Rahmen hatte ich in dem Code etwas weiter unten schon gezeigt - wobei die eigentliche Funktionalität durch ... ersetzt war. (Da dürfte halt einfach ein Zufallsgenerator rein, der eben zufällig eine 0 oder 1 erzeugt - was Du bereits als Math.round(Math.random()) geschrieben hattest.)
 
kneitzel hat gesagt.:
Das war ein weiteres Beispiel der Unterteilung. Die Methode getRandomFieldContent musst Du natürlich noch schreiben. Den Rahmen hatte ich in dem Code etwas weiter unten schon gezeigt - wobei die eigentliche Funktionalität durch ... ersetzt war. (Da dürfte halt einfach ein Zufallsgenerator rein, der eben zufällig eine 0 oder 1 erzeugt - was Du bereits als Math.round(Math.random()) geschrieben hattest.)
Zum Vergrößern anklicken....
[CODE lang="java" title="java"]import java.util.Scanner;

public class Main {

public static void main(String[] args) {


// Begrüßung

System.out.println("Willkommen bei dem Simulationsspiel Spiel des Lebens.");
System.out.println("Das Spiel des Lebens ist eine einfache Simulation von Wachstumsprozessen.");

// Spielfeld groeße nach Benutzer Eingabe

Scanner sc = new Scanner(System.in) ;

System.out.println("Bitte geben sie die Zeilen anzahl des Spielfeldes ein. ");
int zeilen = sc.nextInt() ;
System.out.println("Bitte geben sie die Spalten anzahl des Spielfelds ein.");
int spalten = sc.nextInt() ;



int [][] spielfeld = spielfelderstellen(zeilen , spalten ) ;

sc.close();
}


// Array erstellen
public static int[][] spielfelderstellen (int zeilen, int spalten ) {

return new int[zeilen][spalten];

}


public static void spielfeldfüllen (int [][] spielfeld ) {

for ( int zeilen = 0 ; zeilen < spielfeld.length; zeilen++ ) {
for ( int spalten = 0 ; spalten < spielfeld.length; spalten++) {
spielfeld [zeilen]][spalten] = zufallsgenerator();



}

}

}
public static int zufallsgenarator() {


for ( int zeilen=0; zeilen < spielfeld.length ; zeilen++) {

for ( int spalten=0 ; spalten < spielfeld.length, spalten ++ ) {
int spiel [zeilen ][ spalten] = Math.round(math.random()) ;


return zufallsgenarator() ;

}

}




}



}





[/CODE]

Nachdem ich an meinem Code weiter gearbeitet habe und versucht habe eure tipps umzusetzen zeigt er mir in der Methode zufallsgenarator wieder an das Zeilen und Spalten sich doppeln.
 
Zufallsgenerator soll doch nur eine Zufallszahl generieren und zurück geben. Sonst nichts.

Also keine verschachtelten for Schleifen. Auch kein Zugriff auf irgend ein Array.

Die Syntax ist auch recht dubios:
int spiel [zeilen ][ spalten] = Math.round(math.random()) ;
Das int an erste Stelle bedeutet ja, dass Du eine neue lokale Variable deklarierst. Das willst Du ja auch nicht und wäre so auch nicht korrekt von der Syntax her.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Schriftgröße vom Benutzer änderbar
Antworten: 9
Arrays vom Benutzer einlesen
Antworten: 2
Menü Item "abhaken" lassen vom Benutzer
Antworten: 2
Uhrzeit vom Benutzer eingeben lassen.
Antworten: 5
Vom Benutzer eingebene Integer addieren und ausgeben.
Antworten: 11

Zurück
Oben