# globale Variable deklarieren



## spielor (10. Apr 2010)

Hallo,
ich bin noch relativ unerfahren in Java und stehe vor folgendem Problem:
Ich will ein Programm für Conways Spiel des Lebens schreiben, dazu muss ich eine Funktion schreiben, die alle Nachbarn eines Index' eines 2dimensionalen Arrays zählt. Ich weiß, dass ich eine unorthodoxe Methode dazu verwendet habe, allerdings wollte ich es so einmal ausprobieren. Der Haken:
Diese Methode greift auf ein Array zu, das global deklariert und durch "Random Generator" mit boolean'schen Werten vollgestopft werden sollte, , allerdings geschieht dies erst in der main-Methode.
Wie kann also die Methode "nachbar" auf dieses erzeugte Array zugreifen? Kann man das Array global, also innerhalb der Klasse deklarieren?


```
import java.util.Random;

public class Conway
{
	
	
	public static int nachbar(int x, int y)                           //nachbarn zählen
	{

		int anzahl = 0;
		
		
		switch (x)
		{
			case 0:
			switch (y)
			{
				case 0:                                            //links oben
				if(array[x][y+1]) anzahl++;
				if(array[x+1][y]) anzahl++;
				if(array[x+1][y+1]) anzahl++;	
				break;
				case 9:                                            //links unten
				if(array[x][y-1]) anzahl++;
				if(array[x+1][y]) anzahl++;
				if(array[x+1][y-1]) anzahl++;
				break;
				default: 											//links mitte
				if(array[x][y+1]) anzahl++;
				if(array[x][y-1]) anzahl++;
				if(array[x+1][y+1]) anzahl++;
				if(array[x+1][y-1]) anzahl++;
				if(array[x+1][y]) anzahl++;
				break;				
			}
			break;
			case 9:
			switch (y)
			{
				case 0:                                            //rechts oben
				if(array[x][y+1]) anzahl++;
				if(array[x-1][y]) anzahl++;
				if(array[x-1][y+1]) anzahl++;	
				break;
				case 9:                                            //rechts unten
				if(array[x][y-1]) anzahl++;
				if(array[x-1][y]) anzahl++;
				if(array[x-1][y-1]) anzahl++;
				break;
				default: 											//rechts mitte
				if(array[x-1][y]) anzahl++;
				if(array[x-1][y+1]) anzahl++;
				if(array[x-1][y-1]) anzahl++;
				if(array[x][y-1]) anzahl++;
				if(array[x][y+1]) anzahl++;
				break;				
			}
			break;
			default:
			switch (y)
			{
				case 0:                                            //mitte oben
				if(array[x][y+1]) anzahl++;
				if(array[x+1][y+1]) anzahl++;
				if(array[x+1][y]) anzahl++;
				if(array[x-1][y]) anzahl++;
				if(array[x-1][y+1]) anzahl++;
				break;
				case 9:                                            //mitte unten
				if(array[x][y-1]) anzahl++;
				if(array[x+1][y]) anzahl++;
				if(array[x+1][y-1]) anzahl++;
				if(array[x-1][y]) anzahl++;
				if(array[x-1][y-1]) anzahl++;
				break;
				default: 											//mitte mitte
				if(array[x][y-1]) anzahl++;
				if(array[x][y+1]) anzahl++;
				if(array[x+1][y]) anzahl++;
				if(array[x+1][y+1]) anzahl++;
				if(array[x+1][y-1]) anzahl++;
				if(array[x-1][y]) anzahl++;
				if(array[x-1][y+1]) anzahl++;
				if(array[x-1][y-1]) anzahl++;
				break;				
			}
			break;
							
		}
		
		return anzahl;
		
	}
	
	public static void main(String[] args)                     //main-methode, druckt die muster aus
	{
		boolean[][] array = new boolean[10][10];          //2dimensionales array (boolean) wird erzeugt, durch random mit werten belegt
		Random generator = new Random();
		double zufallswert;
		for (int i = 0; i<10;i++)
		{
			for (int j = 0;j<10;j++)
			{
				zufallswert = generator.nextDouble();
				if (zufallswert >=0.5)
					array[i][j] = true;
			}
		}
		
		System.out.println("Dies ist die erste Generation");   //werte vom array werden gedruckt, indem für "true" ein "X"
															  //und für "false" ein " " angezeigt wird
		for(int i = 0;i<10;i++)
		{
			for(int j = 0;j<10;j++)
			{
				if (array[i][j])
				{
					System.out.print("X");
				}
				else
				{
					System.out.print(" ");
				}
			}
			
			System.out.print("\n");
		}
		
		System.out.println("\n\nDies ist die zweite Generation");
		
		for(int a = 0; a<10;a++)             //wie erster ausdruck, nur wird hier jedes Feld auf nachbarn überprüft
		{								     //und dementsprechen mit einem "X" oder " " versehen
		for(int b = 0; b<10;b++)
		{
		switch (nachbar(a,b))
		{
			case 0: 
			case 1:
			System.out.print(" ");
			break;
			case 2:
			if(array[a][b])
			{
				System.out.print("X");
			}
			else
			{
				System.out.print(" ");
			}
			break;
			case 3:
			System.out.print("X");
			break;
			default:
			System.out.print(" ");
			break;
		}
		}
		System.out.print("\n");
		}
		
		System.out.println(nachbar(3,3));    //nur zum Test, die Methode nachbar geht also nicht
		
	}	
}
```

Vielen vielen Dank für alle antworten, ich geh jetzt pennen


----------



## Schumi (10. Apr 2010)

Ja, Du kannst das Array einfach als (statische) Klassenvariable setzen. Kannst es aber auch der Methode als zusätzlichen Parameter übergeben.


----------



## spielor (10. Apr 2010)

Danke für die Antwort,
ich habe jetzt Klassenvariablen (danke für das Stichwort) in einem anderen Programm ausprobiert. Wenn ich nur einen Wert für eine Variable (static) in der Klasse festlege, kann main darauf zugreifen. Allerdings kann ich keine weiteren Befehle für die Variable eingeben (vermutlich weil sie static ist??), wie zum Beispiel, dass eine int Variable noch vor der main-Methode um eins erhöht wird.
Auf die Aufgabe übertragen:
wie kann ich dieses Array erstellen (das ist noch möglich) und dann mit Werten füllen (das ist für mich nicht möglich), wenn das Array statisch ist. Und das so,dass alle darauf zugreifen können?

```
boolean[][] array = new boolean[10][10];
        Random generator = new Random();
        double zufallswert;
        for (int i = 0; i<10;i++)
        {
            for (int j = 0;j<10;j++)
            {
                zufallswert = generator.nextDouble();
                if (zufallswert >=0.5)
                    array[i][j] = true;
            }
        }
```


----------



## XHelp (10. Apr 2010)

Ich habe es zwar nicht ausprobiert, aber folgendes müsste klappen:

```
public class FillArrayTest {
	public static boolean[][] array = fillArray();
	
	private static boolean[][] fillArray() {
		Random generator = new Random();
		boolean[][] tmpArray = new boolean[20][10];
		for (int i = 0; i<tmpArray.length;i++)
        {
            for (int j = 0;j<tmpArray[j].length;j++)
            {
                if (generator.nextDouble() >=0.5) {
                	tmpArray[i][j] = true;
                }
            }
        }
		return tmpArray;
	}
}
```


----------



## spielor (10. Apr 2010)

Ja genauso hab ichs dann auch gemacht. Mein fertiger Quelltet macht zwar keine Probleme beim kompilieren, aber die Nachbarn werden falsch gezählt, obwohl ich die Methode zig mal kontrolliert habe.
Auf jeden Fall danke für die bisherige Hilfe!!


```
import java.util.Random;

public class Conway2
{
	public static boolean[][] machearray(int k,int l)
	{
		boolean[][] array = new boolean[k][l];          //2dimensionales kxl array (boolean) wird erzeugt, durch random mit werten belegt
		Random generator = new Random();
		double zufallswert;
		for (int i = 0; i<k;i++)
		{
			for (int j = 0;j<l;j++)
			{
				zufallswert = generator.nextDouble();
				if (zufallswert >=0.5)
					array[i][j] = true;
			}
		}
		return array;
	}

	static boolean[][] weltarray = machearray(10,10);

	
	
	public static int nachbar(int x, int y)                           //nachbarn zählen
	{

		int anzahl = 0;
		
		
		switch (x)
		{
			case 0:
			switch (y)
			{
				case 0:                                            //links oben
				if(weltarray[x][y+1]) anzahl++;
				if(weltarray[x+1][y]) anzahl++;
				if(weltarray[x+1][y+1]) anzahl++;	
				break;
				case 9:                                            //links unten
				if(weltarray[x][y-1]) anzahl++;
				if(weltarray[x+1][y]) anzahl++;
				if(weltarray[x+1][y-1]) anzahl++;
				break;
				default: 											//links mitte
				if(weltarray[x][y+1]) anzahl++;
				if(weltarray[x][y-1]) anzahl++;
				if(weltarray[x+1][y+1]) anzahl++;
				if(weltarray[x+1][y-1]) anzahl++;
				if(weltarray[x+1][y]) anzahl++;
				break;				
			}
			break;
			case 9:
			switch (y)
			{
				case 0:                                            //rechts oben
				if(weltarray[x][y+1]) anzahl++;
				if(weltarray[x-1][y]) anzahl++;
				if(weltarray[x-1][y+1]) anzahl++;	
				break;
				case 9:                                            //rechts unten
				if(weltarray[x][y-1]) anzahl++;
				if(weltarray[x-1][y]) anzahl++;
				if(weltarray[x-1][y-1]) anzahl++;
				break;
				default: 											//rechts mitte
				if(weltarray[x][y-1]) anzahl++;
				if(weltarray[x][y+1]) anzahl++;
				if(weltarray[x-1][y]) anzahl++;
				if(weltarray[x-1][y+1]) anzahl++;
				if(weltarray[x-1][y-1]) anzahl++;
				break;				
			}
			break;
			default:
			switch (y)
			{
				case 0:                                            //mitte oben
				if(weltarray[x][y+1]) anzahl++;
				if(weltarray[x+1][y+1]) anzahl++;
				if(weltarray[x+1][y]) anzahl++;
				if(weltarray[x-1][y]) anzahl++;
				if(weltarray[x-1][y+1]) anzahl++;
				break;
				case 9:                                            //mitte unten
				if(weltarray[x][y-1]) anzahl++;
				if(weltarray[x+1][y]) anzahl++;
				if(weltarray[x+1][y-1]) anzahl++;
				if(weltarray[x-1][y]) anzahl++;
				if(weltarray[x-1][y-1]) anzahl++;
				break;
				default: 											//mitte mitte
				if(weltarray[x][y-1]) anzahl++;
				if(weltarray[x][y+1]) anzahl++;
				if(weltarray[x+1][y]) anzahl++;
				if(weltarray[x+1][y+1]) anzahl++;
				if(weltarray[x+1][y-1]) anzahl++;
				if(weltarray[x-1][y]) anzahl++;
				if(weltarray[x-1][y+1]) anzahl++;
				if(weltarray[x-1][y-1]) anzahl++;
				break;				
			}
			break;
							
		}
		
		return anzahl;
		
	}
	
	public static void main(String[] args)                     //main-methode, druckt die muster aus
	{
		
		System.out.println("Dies ist die erste Generation");   //werte vom weltarray werden gedruckt, indem für "true" ein "X"
										   					  //und für "false" ein " " angezeigt wird
		for(int i = 0;i<10;i++)                              //andere funktionen werden noch nicht eingebunden
		{
			for(int j = 0;j<10;j++)
			{
				if (weltarray[i][j])
				{
					System.out.print("X");
				}
				else
				{
					System.out.print(" ");
				}
			}
			
			System.out.print("\n");
		}
		
		System.out.println("\n\nDies ist die zweite Generation");
		
		for(int a = 0; a<10;a++)             //wie erster ausdruck, nur wird hier jedes Feld auf nachbarn überprüft
		{								     //und dementsprechen mit einem "X" oder " " versehen
		for(int b = 0; b<10;b++)             //nachbar-funktion wird eingebunden=>jedes feld einzeln auf nacharn überprüft
		{
		switch (nachbar(a,b))
		{
			case 0: 
			case 1:
			System.out.print(" ");
			break;
			case 2:
			if(weltarray[a][b])
			{
				System.out.print("X");
			}
			else
			{
				System.out.print(" ");
			}
			break;
			case 3:
			System.out.print("X");
			break;
			default:
			System.out.print(" ");
			break;
		}
		}
		System.out.print("\n");
		}
		System.out.println("Der Punkt 3/3 hat "+nachbar(3,3)+" Nachbarn"); //hier kommen die falschen Ergebnisse heraus
		System.out.println("Der Punkt 0/0 hat "+nachbar(0,0)+" Nachbarn");
		System.out.println("Der Punkt 9/9 hat "+nachbar(9,9)+" Nachbarn");
	}	
}
```


----------



## Landei (10. Apr 2010)

Kleiner Tipp: Schreibe eine kleine Methode, die dir den Wert einer Arrayposition zurückgibt, aber false, wenn die Koordinaten außerhalb des Arrays sind. Dann kannst du dir die Fallunterscheidungen sparen.


```
public static boolean get(int x, int y) {
  return (x < 0 || x >= 10 || y < 0 || y >= 10) ? false : weltarray[x][y];
}
```


----------



## XHelp (10. Apr 2010)

Falls ich dein Vorhaben richtig verstanden habe, brauchst du gar keine statische Objekte. Du könntest es auch wie folgt machen:


```
import java.util.Random;

/**
 * Klasse zum Verwaltes des Spielfeldes
 * 
 * @author XHelp
 * 
 */
public class ConwayStorage {

	private boolean[][] field;
	private int width;
	private int height;

	/**
	 * @param width
	 *            Breite des Spielfeldes
	 * @param height
	 *            Länge des Spielfeldes
	 */
	public ConwayStorage(int width, int height) {
		this.width = width;
		this.height = height;
		field = new boolean[width][height];
		generateField();
	}

	/**
	 * Feld generieren
	 */
	public void generateField() {
		Random random = new Random();
		for (int i = 0; i < width; i++) {
			for (int j = 0; j < height; j++) {
				field[i][j] = random.nextBoolean();
			}
		}
	}

	/**
	 * Anzahl der Nachbaren bekommen
	 * 
	 * @param x
	 *            x-Koordinate
	 * @param y
	 *            y-Koordinate
	 * @return Anzahl der Nachbaren
	 */
	public int getNeighborCount(int x, int y) {
		int neighbors = 0;
		for (int i = -1; i <= 1; i++) {
			for (int j = -1; j <= 1; j++) {
				if (!(i == 0 && j == 0)) {
					if (getFieldEntry(x + i, y + j)) {
						neighbors++;
					}
				}
			}
		}
		return neighbors;
	}

	/**
	 * Wert eines Feldes zurückbekommen
	 * 
	 * @param x
	 *            x-Koordinate
	 * @param y
	 *            y-Koordinate
	 * @return Feldeintrag oder false, falls das Feld außerdhalb des Spielfeldes
	 *         liegt
	 */
	public boolean getFieldEntry(int x, int y) {
		return ((x >= 0) && (x < width) && (y >= 0) && (y < height)) ? field[x][y]
				: false;
	}

	/**
	 * Spielfeld ausgeben
	 */
	public void printField() {
		for (int i = 0; i < width; i++) {
			for (int j = 0; j < height; j++) {
				System.out.print((getFieldEntry(i, j) ? "X" : "_") + " ");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		int x = 10;
		int y = 10;
		ConwayStorage conwayField = new ConwayStorage(x, y);
		conwayField.printField();
		System.out.println("NeighborsCount table:");
		for (int i = 0; i < x; i++) {
			for (int j = 0; j < y; j++) {
				System.out.print(conwayField.getNeighborCount(i, j) + " ");
			}
			System.out.println();
		}
	}

}
```

Das ersparrt die viele spätere Probleme und du kannst es problemlos in andere Module einbauen.


----------



## spielor (10. Apr 2010)

Du hast dir ja richtig Mühe gegeben, danke. Die Lösung von dir entspricht in etwa der Musterlösung des Buches. Mich wunderts aber, weshalb meine Methode (nachbar) nicht klappt.
Und mir fällt gerade auf, dass du bei der Methode countneighbor keine Exception dafür  gemacht hast, dass in der Schleife ein Index outofbounds geht, oder war das beabsichtigt und ich übersehe etwas???


----------



## XHelp (10. Apr 2010)

Du berechnest falsch die Generationen.
Du gibst zwar das richtige Ergebnis aus, aber das wird ja nicht gespeichert. Dementsprechend bezieht sich nachbar immer noch auf die Ausgangswerte.
Allerdings kannst du jetzt auch nicht
[JAVA=146]
System.out.print(" ");
weltarray[a]* = false;
[/code]
machen, weil du damit die Spiellogik veränderst.
Du müsstest eine Kopie des Spielfeldes erstellen. Auf dem einen die Nachbaren prüfen und auf dem anderen Felder verändern.*


----------



## XHelp (10. Apr 2010)

Antwort auf dein Updaten:
Ich bekomme keine Exceptions. Das ist genau das, was dir Landei gesagt hat:
Du greifst nicht direkt auf array zu, sondern machst eine extra Methode. Dieser übergibst du x und y. Du überprüfst, ist x und y IM Spielfeld, dann lese es aus, ansonsten gib false zurück.


----------



## spielor (10. Apr 2010)

Oh mann, ich bin gerade so verwirrt. Wie gesagt, ich bin Anfänger, ich habe bis jetzt nur Programme geschrieben, die schön sequentiell aufgebaut sind. Die ganzen Funktionen, private oder public und Klassen und...ahh die machen mich fertig. Ich dank euch allen auf jeden Fall für die Mühe, ich werde mir alles noch mal in aller Ruhe zu Gemüte führen...und wahrscheinlich alles nachschlagen müssen.Danke


----------

