Objekte Array, überschrieben?

[Haumdaucher]

hallo!

also ich hab ein kleines problem:
rufe in einer Klasse die Klasse Karten auf, die folgendermaßen ausschaut:

public class Karten {
	static Karte[] karten;
	static Spieler[] spieler;
	static int[] mischzahlen;
	
	public Karten() {

		karten = new Karte[32];

		spieler = new Spieler[4];

		karten[0] = new Karte("gras", "7", 0,0);
		karten[1] = new Karte("gras", "8", 1,0);
		karten[2] = new Karte("gras", "9", 2,0);
		karten[3] = new Karte("gras", "K", 3,4);
		karten[4] = new Karte("gras", "10", 4,10);
		karten[5] = new Karte("gras", "A", 5,11);
		karten[6] = new Karte("gras", "U", 15,2);
		karten[7] = new Karte("gras", "O", 19,3);


		karten[8] = new Karte("herz", "7", 7,0);
		karten[9] = new Karte("herz", "8", 8,0);
		karten[10] = new Karte("herz", "9", 9,0);
		karten[11] = new Karte("herz", "K", 10,4);
		karten[12] = new Karte("herz", "10", 11,10);
		karten[13] = new Karte("herz", "A", 12,11);
		karten[14] = new Karte("herz", "U", 14,2);
		karten[15] = new Karte("herz", "O", 18,3);

		karten[16] = new Karte("schelle", "7", 0,0);
		karten[17] = new Karte("schelle", "8", 1,0);
		karten[18] = new Karte("schelle", "9", 2,0);
		karten[19] = new Karte("schelle", "K", 3,4);
		karten[20] = new Karte("schelle", "10", 4,10);
		karten[21] = new Karte("schelle", "A", 5,11);
		karten[22] = new Karte("schelle", "U", 13,2);
		karten[23] = new Karte("schelle", "O", 17,3);

		karten[24] = new Karte("eichel", "7", 0,0);
		karten[25] = new Karte("eichel", "8", 1,0);
		karten[26] = new Karte("eichel", "9", 2,0);
		karten[27] = new Karte("eichel", "K", 3,4);
		karten[28] = new Karte("eichel", "10", 4,10);
		karten[29] = new Karte("eichel", "A", 5,11);
		karten[30] = new Karte("eichel", "U", 16,2);
		karten[31] = new Karte("eichel", "O", 20,3);
		

		mischzahlen = mischen();

		for(int i=0;i<4;i++)
		{
			spieler[i]=new Spieler(karten[mischzahlen[0+i*8]], karten[mischzahlen[1+i*8]], karten[mischzahlen[2+i*8]], karten[mischzahlen[3+i*8]], karten[mischzahlen[4+i*8]], karten[mischzahlen[5+i*8]], karten[mischzahlen[6+i*8]], karten[mischzahlen[7+i*8]]);
		}
		
		
	}
	
	public static int[] getMischzahlen()
	{
		return mischzahlen;
	}

	public static Spieler getSpieler(int i){
		return spieler[i];
	}
	
	public static Karte[] getKarten(){
		return karten;
	}

	public static int[] mischen() {
		int[] gemischt = { -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 };

		Random r = new Random();
		;
		for (int i = 0; i < 32; i++) {
			do {
				gemischt[i] = r.nextInt(32);
			} while (existiert(gemischt, i));
		}

		return gemischt;
	}

	
	public static boolean existiert(int[] gemischt, int i) {
		boolean ex = false;
		for (int l = 0; l < i; l++) {
			if (gemischt[l] == gemischt[i]) {
				ex = true;
				break;
			}

		}
		return ex;
	}

}

Die Klasse Karte:

public class Karte {
	static String farbe, zahl;
	static int priori, wert;

	public Karte(String farbe, String zahl, int priori, int wert) {
		this.farbe = farbe;
		this.zahl = zahl;
		this.priori=priori;
		this.wert=wert;
	}
	
	public static int getWert(){
		return wert;
	}

	public static String getFarbe() {
		return farbe;
	}

	public static String getZahl() {
		return zahl;
	}
	public static int getPriori(){
		return priori;
	}
	public void setPriori(int priori){
		this.priori=priori;
	}
}

also an sich nichts aufregendes. aber "irgendwie" wird, wenn ich jede einzelne der 32 Karten erzeuge, die Karte davor überschrieben bzw die Karten davor haben die selben Eigenschaften wie die letzte... an was liegt des?
am schluß haben alle karten die farbe "eichel" und die zahl "ober" weil des ja die allerletzte karte is...

bin am verzweifeln!

HILFE!!!

vielen dank

 

[Bert Brenner]

Weil die Klasse Karte keine Instanzvariablen hat.

entferne mal die static´s

 

[Haumdaucher]

also wenn du die statics in der Klasse Karte (also vor allen get und set) meinst, hilft nix...
hab gemeint, im speicher wird für jedes objekt ein speicher angelegt... oder etwa nich?
was meinst du dann mit instanzvariablen?
mfg

 

[norman]

ich schätze er meinte diese statics:

public class Karte {
   static String farbe, zahl;
   static int priori, wert;

 

[Haumdaucher]

argh!

ich idiot! was ein bischen nachdenken alles geholfen hätte ;-)

trotzdem danke!

 

[norman]

btw: wozu sind deine get-Methoden static? du wirst kaum irgendwo Karte.getWert(); aufrufen, sondern vielmehr karten[7].getWert();, oder?

[edit]

int[] gemischt = { -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 };

da du die werte im anschluss eh überschreibst, tut's hier doch auch ein

int[] gemischt = new int[32]