Ein neues Thema erstellen Auf das Thema antworten  [ 4 Beiträge ] 

Vorheriges Thema | Nächstes Thema 

Autor Nachricht
 Betreff des Beitrags: GameOfLife und OOP
BeitragVerfasst: 30. August 2010, 08:48 
Frisch immatrikuliert

Registriert: 29. August 2010, 13:38
Beiträge: 1
Hallo, ich stecke bei der 2. Aufgabe von Kapitel 6 fest. Man soll das GameOfLife objektorientiert programmieren.

Mein Programm lässt sich zwar kompilieren und ausführen, nur leider berechnet er irgendwie die Folgegeneration falsch. Es muss irgendein Fehler beim zählen der Umgebung oder der Regelanwendung vorliegen. Ich weiß nur nicht welcher.

Beispiel des Fehlers

Generation 1
X X X O X
O O O O O
X O X X X
O X X X O
X O O O O

Generation 2
O X O X O
X O X X X
O O O O X
X O O O X
O X X O X

Ich habe zu diesem Programm 4 Klassen geschrieben. Die Hauptklasse für das Programm an sich, Petrischalen-Klasse, Zellen-Klasse und eine Klasse zur Ausgabe von Text.

  1. import java.util.Random; // wird später erleutert
  2. import java.io.*;
  3. public class SpielDesLebens {
  4.  
  5.     public static void main (String args[]) {
  6.        
  7.         int breite;
  8.         int hoehe;
  9.         int maxGen; 
  10.        
  11.         Text t1         = new Text();
  12.        
  13.         breite  = t1.frageBreite();
  14.         hoehe   = t1.frageHoehe();
  15.         maxGen  = t1.frageGenerationen();
  16.        
  17.         Petrischale p1  = new Petrischale(maxGen, breite, hoehe);
  18.         Zelle[][] z1    = new Zelle[breite][hoehe];
  19.         for (int i = 0; i < breite ; i++)
  20.         {
  21.             for (int j = 0; j < hoehe; j++)
  22.             {
  23.                 z1[i][j] = new Zelle();
  24.             }
  25.            
  26.         }
  27.        
  28.         p1.gebePetrischaleAus(z1);
  29.        
  30.         t1.frageNaechsteGeneration(p1, z1);
  31.        
  32.     }
  33. }

  1. import java.util.Random; // wird später erleutert
  2. import java.io.*;
  3. public class Petrischale { 
  4.     //  Eigenschaften
  5.     private int istGen;
  6.     private int maxGen;
  7.     private int breite;
  8.     private int hoehe;
  9.        
  10.     //  Konstruktor
  11.     public Petrischale(int mg, int b, int h) {
  12.         istGen  = 1;
  13.         maxGen  = mg;
  14.         breite  = b;
  15.         hoehe   = h;
  16.     }
  17.        
  18.     //  get und set
  19.    
  20.     public int getIstGen() {
  21.         return istGen;
  22.     }
  23.    
  24.     public void setIstGen(int ig) {
  25.         istGen = ig;
  26.     }
  27.    
  28.     public int getMaxGen() {
  29.         return maxGen;
  30.     }
  31.    
  32.     public int getBreite() {
  33.         return breite;
  34.     }
  35.    
  36.     public int getHoehe() {
  37.         return hoehe;
  38.     }
  39.  
  40.        
  41.        
  42.     //  Methoden
  43.    
  44.     public void gebePetrischaleAus(Zelle[][] z) {
  45.         System.out.println("Generation "+getIstGen());
  46.         for (int x=0; x<this.getHoehe(); x++)
  47.         {
  48.             for (int y=0; y<this.getBreite(); y++)
  49.             {
  50.                 z[y][x].gebeZelleAus();
  51.             }
  52.             System.out.println();
  53.         }
  54.     }
  55.    
  56.     // Prüft, wie viel lebendige Zellen in der Umgebung einer Zelle sind   
  57.     public int zaehleNachbarn(Zelle[][] z, int x, int y) {
  58.         int ret = 0;
  59.         for (int i=(x-1);i<(x+2);++i)
  60.         {  
  61.             for (int j=(y-1);j<(y+2);++j){
  62.                 try
  63.                 {
  64.                     if (z[i][j].getZustand())
  65.                         ret +=1;
  66.                 }
  67.                 catch (IndexOutOfBoundsException e) {}
  68.             }
  69.         }
  70.         // einen zuviel mitgezählt?
  71.         if (z[x][y].getZustand())
  72.             ret -= 1;
  73.            
  74.         return ret;
  75.     }
  76.    
  77.     public Zelle[][] wendeRegelnAn(Zelle[][] z) {
  78.         int nachbarn;
  79.        
  80.        
  81.         //  Erstelle Die Zelle zum Zurückgeben erstellen
  82.         Zelle[][] nz    = new Zelle[this.getBreite()][this.getHoehe()];
  83.         for (int i = 0; i < this.getBreite(); i++)
  84.         {
  85.             for (int j = 0; j < this.getHoehe(); j++)
  86.             {
  87.                 nz[i][j] = new Zelle();
  88.             }
  89.         }
  90.        
  91.         for (int i = 0; i < this.getBreite(); i++)
  92.         {
  93.             for (int j = 0; j < this.getHoehe(); j++)
  94.             {
  95.                 //Zaehle die Nachbarn
  96.                 nachbarn = this.zaehleNachbarn(z, i, j);
  97.                                
  98.                 if (z[i][j].getZustand())
  99.                 {
  100.                     // Regel 1 & 2:
  101.                     if ((nachbarn<2) || (nachbarn>3))
  102.                         nz[i][j].setZustand(false);
  103.                                    
  104.                     // Regel 3:
  105.                     if ((nachbarn==2) || (nachbarn==3))
  106.                         nz[i][j].setZustand(true);
  107.                 }
  108.                 else
  109.                 {
  110.                     // Regel 4;
  111.                     if (nachbarn==3)
  112.                         nz[i][j].setZustand(true);
  113.                 }      
  114.             }   
  115.         }
  116.         return nz;
  117.     }
  118.    
  119.     public void addGeneration(Zelle[][] z) {
  120.         this.setIstGen(this.getIstGen()+ 1);
  121.         z = this.wendeRegelnAn(z);
  122.         this.gebePetrischaleAus(z);
  123.     }
  124. }

  1. import java.util.Random; // wird später erleutert
  2. import java.io.*;
  3. public class Zelle {
  4.    
  5.     //  Eigenschaften
  6.    
  7.     private boolean zustand;
  8.    
  9.     //  Konstruktor
  10.     public Zelle() {
  11.         Random generator = new Random();
  12.         double zufallswert;
  13.         zufallswert = generator.nextDouble();
  14.         if (zufallswert >=0.5)
  15.             zustand = true;
  16.         else
  17.             zustand = false;
  18.     }
  19.    
  20.     //  get und set
  21.    
  22.     public boolean getZustand() {
  23.         return zustand;
  24.     }
  25.    
  26.     public void setZustand(boolean z) {
  27.         this.zustand = z;
  28.     }
  29.    
  30.     //  Methoden
  31.    
  32.     public void gebeZelleAus() {
  33.         if (this.getZustand())
  34.             System.out.print("X ");
  35.         else
  36.             System.out.print("  ");
  37.     }   
  38. }

  1. import java.util.Random; // wird später erleutert
  2. import java.io.*;
  3. public class Text {
  4.    
  5.     public Text() {
  6.         System.out.println("Willkommen zum Spiel des Lebens!");
  7.         System.out.println("Sie müssen erst Ihre Welt erstellen, bevor Sie mit dem Spiel");
  8.         System.out.println("beginnen können.");
  9.         System.out.println();
  10.     }
  11.    
  12.     public static int frageBreite() {
  13.         System.out.println("Bitte geben Sie die Breite Ihrer Welt ein.");
  14.         System.out.print("Eingabe: ");
  15.         int breite = 0;
  16.         try
  17.         {
  18.             InputStreamReader isrB  = new InputStreamReader(System.in);
  19.             BufferedReader burB     = new BufferedReader(isrB);
  20.             String strB = burB.readLine();
  21.             breite      = Integer.parseInt(strB);
  22.            
  23.             if (breite == 0)
  24.             {
  25.                 System.out.println("Programmierhinweis: Fehler bei der Benutzereingabe!");
  26.                 System.exit(1);
  27.             }
  28.  
  29.         }
  30.         catch (IOException eIO)
  31.         {
  32.             System.out.println("Folgender Fehler trat auf: "+eIO);
  33.             System.exit(1);
  34.         }
  35.         System.out.println();
  36.         return breite;
  37.     }
  38.    
  39.     public static int frageHoehe() {
  40.         System.out.println("Bitte geben Sie die Hoehe Ihrer Welt ein.");
  41.         System.out.print("Eingabe: ");
  42.         int hoehe = 0;
  43.         try
  44.         {
  45.             InputStreamReader isrH  = new InputStreamReader(System.in);
  46.             BufferedReader burH = new BufferedReader(isrH);
  47.             String strH = burH.readLine();
  48.             hoehe = Integer.parseInt(strH);
  49.             if (hoehe == 0)
  50.             {
  51.                 System.out.println("Programmierhinweis: Fehler bei der Benutzereingabe!");
  52.                 System.exit(1);
  53.             }
  54.         }
  55.         catch (IOException eIO)
  56.         {
  57.             System.out.println("Folgender Fehler trat auf: "+eIO);
  58.             System.exit(1);
  59.         }   
  60.         System.out.println();
  61.         return hoehe;
  62.     }
  63.    
  64.     public static int frageGenerationen() {
  65.         System.out.println("Bitte geben Sie die Anzahl der Generationen ein.");
  66.         System.out.print("Eingabe: ");
  67.         int anzahlGen = 0;
  68.         try
  69.         {
  70.             InputStreamReader isrG  = new InputStreamReader(System.in);
  71.             BufferedReader burG = new BufferedReader(isrG);
  72.             String strG = burG.readLine();
  73.             anzahlGen = Integer.parseInt(strG);
  74.             if (anzahlGen == 0)
  75.             {
  76.                 System.out.println("Programmierhinweis: Fehler bei der Benutzereingabe!");
  77.                 System.exit(1);
  78.             }
  79.         }
  80.         catch (IOException eIO)
  81.         {
  82.             System.out.println("Folgender Fehler trat auf: "+eIO);
  83.             System.exit(1);
  84.         }
  85.         System.out.println();
  86.         return anzahlGen;
  87.     }
  88.    
  89.     // fragt solange, bis die maximale generation erreicht wurde,
  90.     // oder der Benutzer abbricht.
  91.    
  92.     public static void frageNaechsteGeneration(Petrischale p, Zelle[][] z) {
  93.         while (p.getIstGen() < p.getMaxGen()) // istGeneration ist kleiner als gesamtGenerationen
  94.         {
  95.             System.out.println();
  96.             System.out.println("Nächste Generation anzeigen? (y)(n)");
  97.             System.out.print("Eingabe: ");
  98.             try
  99.             {
  100.                 InputStreamReader isrE  = new InputStreamReader(System.in);
  101.                 BufferedReader burE = new BufferedReader(isrE);
  102.                 String egb = burE.readLine();
  103.                 if (egb.equals("y"))
  104.                 {
  105.                     p.addGeneration(z);
  106.                 }
  107.                 else if (egb.equals("n"))
  108.                 {
  109.                     System.out.println("Danke, dass Sie das Programm benutzt haben!");
  110.                     System.exit(1);
  111.                 }
  112.                 else
  113.                 {
  114.                     System.out.println("Falsche Eingabe!");
  115.                 }
  116.             }
  117.             catch (IOException eIO)
  118.             {
  119.                 System.out.println("Folgender Fehler trat auf: "+eIO);
  120.                 System.exit(1);
  121.             }
  122.             System.out.println();
  123.         }
  124.     }
  125. }


Nach oben
 Offline     Profil  
 
 Betreff des Beitrags: Re: GameOfLife und OOP
BeitragVerfasst: 4. September 2010, 14:28 
Administrator
Benutzeravatar

Registriert: 28. April 2008, 12:03
Beiträge: 1238
Wohnort: Berlin
Ohne genauer auf Deinen Code zu schauen ... hast Du vielleicht versäumt, die
Ergebnisse in eine neue Petrischale zu schreiben? Dann greift er in den Schleifen
auf alte und neue Werte zu, was zu Fehlern führen kann.

Marco

_________________
Schachblocki

--------------------------------
"Qui dilisit disciplinam - dilisit scientiam."
Prov.XII.1.


Nach oben
 Offline     Profil  
 
 Betreff des Beitrags: Re: GameOfLife und OOP
BeitragVerfasst: 23. Dezember 2012, 01:30 
1.Semester

Registriert: 29. Mai 2012, 14:14
Beiträge: 2
hallo,

stecke total in diesem beispiel fest. hab die klasse Zelle.java und die testklasse Petrischale.java. Was mir irgendwie nicht richtig aufgehen will ist, warum bei den Nachbarn nur Werte von 0 oder 9 möglich sind und nicht 2, 3 usw. irgendwas muss mit der variable ret und das zählen der umgebung nicht stimmen.

Zelle.java
  1. public class Zelle{
  2.     //EI
  3. public int status;
  4.  
  5. //konstruktor
  6. public Zelle(int s){
  7. status = s;
  8. }
  9.  
  10. //get und set
  11. public int getStatus(){
  12. return status;
  13. }
  14. public void setStatus(int s){
  15. status=s;
  16. }
  17.  
  18. public String info(){
  19.         return "Status"+getStatus();
  20.     }
  21.  
  22. }

Petrischale.java
  1.  
  2. import java.util.Random;
  3.  
  4. public class Petrischale{
  5.  
  6.  
  7.  
  8.  
  9.     public static void gebeAus(Zelle [][] z){
  10.  
  11.    
  12.     for (int i=0;i<11;i++){
  13.         for (int j=0;j<11;j++){
  14.  
  15.            
  16.             System.out.print(z[i][j].getStatus()+"|");
  17.         }
  18.         System.out.println(); //zeilenumbruch
  19.     }
  20.     }//gebeAus zu
  21.  
  22.     public static int zaehleUmgebung(Zelle [][] z, int x, int y){
  23.     int ret = 0;
  24.     int wert;
  25.    
  26.  
  27.  
  28. for (int i=(x-1);i<(x+2);++i){
  29.         for (int j=(y-1);j<(y+2);++j){
  30.  
  31.             wert=z[x][y].getStatus();
  32.  
  33.                 if (wert==1){
  34.                     ret += 1;
  35.  
  36.  
  37.                     }
  38.                 if (wert==0){
  39.                     ret += 0;
  40.  
  41.                     }
  42.  
  43.            
  44.         }
  45. }
  46.  
  47.  
  48.  
  49.  
  50.  
  51. return ret;
  52.  
  53. }
  54.  
  55.  
  56. public static void main(String[] args){
  57.  
  58. Zelle[][] z = new Zelle[11][11];
  59. Zelle[][] z_neu = new Zelle[11][11];
  60.  
  61. //initialisiere z
  62. Random r=new Random();
  63.     for (int i=0;i<11;i++){
  64.         for (int j=0;j<11;j++){
  65.  
  66.             //gibt abwechselnd 0 und 1 für die zellen
  67.             z[i][j]=new Zelle(r.nextInt(2));
  68.            
  69.         }
  70.        
  71.     }
  72.    
  73.  
  74. //initialisiere z_neu
  75. for (int i=0;i<11;i++){
  76.         for (int j=0;j<11;j++){
  77.             z_neu[i][j]=new Zelle(1);   
  78.         }
  79. }
  80. System.out.println("Generation 1");
  81. Petrischale.gebeAus(z);
  82. System.out.println("Test z_neu Initialisierung");
  83. Petrischale.gebeAus(z_neu);
  84.  
  85.  
  86.  
  87. int nachbarn;
  88. System.out.println("Nachbarn");
  89. for (int i=0;i<11;i++){
  90.         for (int j=0;j<11;j++){
  91.             //zaehle die nachbarn
  92.             nachbarn = zaehleUmgebung(z, i, j);
  93.  
  94. System.out.print(nachbarn+"|");
  95. int wert=z[i][j].getStatus();
  96.  
  97.            
  98.            
  99.             if(wert==1){
  100.            
  101.  
  102.             //Regel 1,2
  103.             if ((nachbarn<2) || (nachbarn>3))
  104.                 z_neu[i][j].setStatus(0);
  105.  
  106.             //Regel 3
  107.             if ((nachbarn==2) || (nachbarn==3))
  108.                 z_neu[i][j].setStatus(1);
  109.             }else{
  110.  
  111.                 //Regel 4
  112.                 if (nachbarn==3)
  113.                 z_neu[i][j].setStatus(1);
  114.                            
  115.  
  116.             }
  117.            
  118.         }
  119.         System.out.println();
  120. }
  121. //Ausgabe der 2. Generation
  122. System.out.println("Generation 2");
  123. Petrischale.gebeAus(z_neu);
  124.  
  125.  
  126. }
  127. }


Ausgabe:
Generation 1
0|0|0|1|1|1|0|0|0|1|1|
1|0|1|1|1|0|0|1|1|0|1|
1|1|0|0|0|0|0|0|0|0|0|
1|1|1|1|0|1|0|1|0|1|0|
1|0|1|1|1|0|0|0|0|1|1|
0|0|0|0|1|1|1|0|0|1|0|
0|1|1|1|1|0|1|1|1|0|0|
0|0|0|0|0|0|1|0|0|1|1|
1|1|1|0|1|1|1|1|0|1|1|
1|1|1|0|0|0|0|1|0|1|0|
0|0|0|1|0|0|1|0|0|0|1|
Test z_neu Initialisieru
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
1|1|1|1|1|1|1|1|1|1|1|
Nachbarn
0|0|0|9|9|9|0|0|0|9|9|
9|0|9|9|9|0|0|9|9|0|9|
9|9|0|0|0|0|0|0|0|0|0|
9|9|9|9|0|9|0|9|0|9|0|
9|0|9|9|9|0|0|0|0|9|9|
0|0|0|0|9|9|9|0|0|9|0|
0|9|9|9|9|0|9|9|9|0|0|
0|0|0|0|0|0|9|0|0|9|9|
9|9|9|0|9|9|9|9|0|9|9|
9|9|9|0|0|0|0|9|0|9|0|
0|0|0|9|0|0|9|0|0|0|9|
Generation 2
1|1|1|0|0|0|1|1|1|0|0|
0|1|0|0|0|1|1|0|0|1|0|
0|0|1|1|1|1|1|1|1|1|1|
0|0|0|0|1|0|1|0|1|0|1|
0|1|0|0|0|1|1|1|1|0|0|
1|1|1|1|0|0|0|1|1|0|1|
1|0|0|0|0|1|0|0|0|1|1|
1|1|1|1|1|1|0|1|1|0|0|
0|0|0|1|0|0|0|0|1|0|0|
0|0|0|1|1|1|1|0|1|0|1|
1|1|1|0|1|1|0|1|1|1|0|


Nach oben
 Offline     Profil  
 
 Betreff des Beitrags: Re: GameOfLife und OOP
BeitragVerfasst: 7. Januar 2013, 15:17 
1.Semester

Registriert: 29. Mai 2012, 14:14
Beiträge: 2
schon gelöst. der fehler war dass ich den falschen index verwendet hab in der funktion zaehleUmgebung



  1. import java.util.Random;
  2.  
  3. public class Petrischale{
  4.  
  5.     public static void gebeAus(Zelle [][] z){
  6.  
  7.     for (int i=0;i<11;i++){
  8.         for (int j=0;j<11;j++){
  9.    
  10.             System.out.print(z[i][j].getStatus()+"|");
  11.         }
  12.         System.out.println(); //zeilenumbruch
  13.     }
  14.     }//gebeAus zu
  15.  
  16.     public static int zaehleUmgebung(Zelle [][] z, int x, int y){
  17.     int ret = 0;
  18.    
  19.     int wert=0;
  20.  
  21.  
  22. for (int i=(x-1);i<(x+2);++i){
  23.         for (int j=(y-1);j<(y+2);++j){
  24. try{
  25.  
  26.                 if (z[i][j].getStatus()==1){
  27.                     ret += 1;
  28.  
  29.                     }
  30.                 if (z[i][j].getStatus()==0){
  31.                     ret += 0;
  32.  
  33.                     }
  34.  
  35.             }catch (IndexOutOfBoundsException e){}
  36.         }
  37. }
  38.  
  39. if (z[x][y].getStatus()==1){
  40. ret-=1;
  41. }
  42. return ret;
  43. }
  44.  
  45. public static void main(String[] args){
  46.  
  47. Zelle[][] z = new Zelle[11][11];
  48. Zelle[][] z_neu = new Zelle[11][11];
  49.  
  50. //initialisiere z
  51. Random r=new Random();
  52.     for (int i=0;i<11;i++){
  53.         for (int j=0;j<11;j++){
  54.  
  55.             //gibt abwechselnd 0 und 1 für die zellen
  56.             z[i][j]=new Zelle(r.nextInt(2));
  57.            
  58.         }
  59.     }   
  60.  
  61. //initialisiere z_neu
  62. for (int i=0;i<11;i++){
  63.         for (int j=0;j<11;j++){
  64.             z_neu[i][j]=new Zelle(1);   
  65.         }
  66. }
  67. System.out.println("Generation 1");
  68. Petrischale.gebeAus(z);
  69. System.out.println("Test z_neu Initialisierung");
  70. Petrischale.gebeAus(z_neu);
  71.  
  72. int nachbarn;
  73. System.out.println("Nachbarn");
  74. for (int i=0;i<11;i++){
  75.         for (int j=0;j<11;j++){
  76.             //zaehle die nachbarn
  77.             nachbarn = zaehleUmgebung(z, i, j);
  78.  
  79. System.out.print(nachbarn+"|");
  80. int wert=z[i][j].getStatus();
  81.  
  82.             if(wert==1){
  83.  
  84.             //Regel 1,2
  85.             if ((nachbarn<2) || (nachbarn>3)){
  86.                 z_neu[i][j].setStatus(0);}
  87.  
  88.             //Regel 3
  89.             if ((nachbarn==2) || (nachbarn==3)){
  90.                 z_neu[i][j].setStatus(1);}
  91.             }if(wert==0){
  92.  
  93.                 //Regel 4
  94.                 if (nachbarn==3){
  95.                 z_neu[i][j].setStatus(1);
  96.                 }else{
  97.                     z_neu[i][j].setStatus(0);
  98.                     }
  99.             }   
  100.         }
  101.         System.out.println();
  102. }
  103. //Ausgabe der 2. Generation
  104. System.out.println("Generation 2");
  105. Petrischale.gebeAus(z_neu);
  106.  
  107. }
  108. }


Nach oben
 Offline     Profil  
 
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 4 Beiträge ] 


Wer ist online?

Mitglieder in diesem Forum: Google [Bot] und 2 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron
Powered by phpBB © 2007 phpBB Group


Picksel Media Marco Block © 2006-2009 – ImpressumKontakt
Gestaltung und Umsetzung Tobias Losch, www.picksel-media.de