non static method cannot be referenced from static context

Status
Nicht offen für weitere Antworten.

Janus88

Mitglied
Hallo,
ich bin neu hier. Und ja ich habe die Suchfunktion benutzt, Lösungsvorschläge gefunden, allerdings leider nicht selbst anwenden können.

Fehlermeldung:

Spiel7.java:196: non-static method pop() cannot be referenced from a static context
Karte element = SpielerStapel.pop();
^

Code:
class Stapel
{
private Karte [] Karte = new Karte[32];
public Stapel()
{
Karte[0] = new Karte("Karo", "7", 1);
Karte[1] = new Karte("Herz", "7", 2);
Karte[2] = new Karte("Pik", "7",3);
Karte[3] = new Karte("Kreuz", "7", 4);
Karte[4] = new Karte("Karo", "8", 5);
Karte[5] = new Karte("Herz", "8", 6);
Karte[6] = new Karte("Pik", "8", 7);
Karte[7] = new Karte("Kreuz", "8",8);
Karte[8] = new Karte("Karo", "9", 9);
Karte[9] = new Karte("Herz", "9", 10);
Karte[10] = new Karte("Pik", "9", 11);
Karte[11] = new Karte("Kreuz", "9", 12);
Karte[12] = new Karte("Karo", "10", 13);
Karte[13] = new Karte("Herz", "10", 14);
Karte[14] = new Karte("Pik", "10", 15);
Karte[15] = new Karte("Kreuz", "10", 16);
Karte[16] = new Karte("Karo", "Bube", 17);
Karte[17] = new Karte("Herz", "Bube", 18);
Karte[18] = new Karte("Pik", "Bube", 19);
Karte[19] = new Karte("Kreuz", "Bube", 20);
Karte[20] = new Karte("Karo", "Dame", 21);
Karte[21] = new Karte("Herz", "Dame", 22);
Karte[22] = new Karte("Pik", "Dame", 23);
Karte[23] = new Karte("Kreuz", "Dame", 24);
Karte[24] = new Karte("Karo", "Koenig", 25);
Karte[25] = new Karte("Herz", "Koenig", 26);
Karte[26] = new Karte("Pik", "Koenig", 27);
Karte[27] = new Karte("Kreuz", "Koenig", 28);
Karte[28] = new Karte("Karo", "Ass", 29);
Karte[29] = new Karte("Herz", "Ass", 30);
Karte[30] = new Karte("Pik", "Ass", 31);
Karte[31] = new Karte("Kreuz", "Ass", 32);
}

public void mischen()
{


int stapel [] = {32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

int [] gemischt = new int [32];

int i;

int h = 0;

for(int z = 31; z >= 0; z--)
{	
i = (int) (Math.random()*z);
gemischt [h] = stapel[i];
stapel[i] = 0;
Bubblesort2.sort (stapel);
h++;

}
Stack SpielerStapel = new Stack(16);
Stack ComputerStapel = new Stack(16);
for(int j=0; j<16; j++)
{
int g = gemischt[j];
SpielerStapel.push(Karte[g]);
}
for(int j=16; j<=31; j++)
{
int g = gemischt[j];
ComputerStapel.push(Karte[g]);
}

} 
}
class SpielerStapel
{
private Karte[] array;
private int top = 0;
public SpielerStapel(int nr)
{
array = new Karte[nr];
}
public void push(Karte element)
{
array[top++] = element;
}
public Karte pop()
{
return array[--top];
}
public boolean isEmpty()
{
if (top == 0)
{
return true;
}
else
{
return false;
}
}
public boolean isFull()
{
if (top == array.length)
{
return true;
}
else
{
return false;
}
}
}
class ComputerStapel
{
private Karte[] array;
private int top = 0;
public ComputerStapel(int nr)
{
array = new Karte[nr];
}
public void push(Karte element)
{
array[top++] = element;
}
public Karte pop()
{
return array[--top];
}
public boolean isEmpty()
{
if (top == 0)
{
return true;
}
else
{
return false;
}
}
public boolean isFull()
{
if (top == array.length)
{
return true;
}
else
{
return false;
}
}
}

class Karte
{
private String farbe;
private String zahl;
private int wert;
public Karte(String farbe, String zahl, int wert)
{
this.farbe= farbe;
this.zahl= zahl;
this.wert= wert;
}
public String getFarbe()
{
return farbe;
}
public String getZahl()
{
return zahl;
}
public int getWert()
{
return wert;
}
public void print()
{
System.out.println(farbe + zahl + wert);
}
}


public class Spiel7
{

public static void main(String[] args)
{
Stapel SpielStapel;
SpielStapel = new Stapel();
SpielStapel.mischen();
Karte element = SpielerStapel.pop();
System.out.println("Spielerkarte :");
element.print();

}
}
JA ich weis es ist etwas durcheinander und verwirrend. Allerdings für mich als Anfänger nicht besser realisierbar.
Ich hoffe mir kann evtl doch jemand weiterhelfen, und evtl. eine Problemlösung finden.

Grüße Helmut
 

mahe

Aktives Mitglied
Du hast sowohl eine Variable als auch eine Klasse namens "SpielerStapel". Beim Aufruf der Methode "pop" wird dann versucht dieses aus der Klasse auszuführen anstatt der Instanz.

Also musst Du Deine Variable umbenennen.

Wenn man sich bei den Variablen- und Klassennamen an die gängigen Koventionen hält, passiert so etwas erst gar nicht.
 

Janus88

Mitglied
Hallo,
dies ist mir gar nicht aufgefallen. Allerdings auch beim abändern des Klassennamens, tritt der Fehler weiter auf :-(.

Grüße Helmut
 

Janus88

Mitglied
Soderle,
extra früh aufgestanden und über das Problem weiter nachgedacht. Es war wohl nicht sehr objektorientiert 3 Klassen für ein und dasselbe Problem zu erstellen. Ich hoffe ich habe mich gebessert und die Variablen alle richtig geschrieben usw. Ich kann es jetzt sogar compilieren, allerdings bekomme ich beim ausführen folgende Fehlermeldung:

Exception in thread "main" java.lang.NullPointerException
at Stapel.print(Spiel7.java:158)
at Spiel7.main(Spiel7.java:180)

Code:
class Spieler
{
	private int punkte;
	public Spieler()  //anlegen von Spieler und Computer als Gegner
	{
		this.punkte = punkte;
	}
	
	
}

class Karte
{
	private String farbe;
	private String zahl;
	private int wert;
	public Karte(String farbe, String zahl, int wert)
	{
		this.farbe= farbe;
		this.zahl= zahl;
		this.wert= wert;
	}
	public String getFarbe()
	{
		return farbe;
	}
	public String getZahl()
	{
		return zahl;
	}
	public int getWert()
	{
		return wert;
	}
	public void print()
	{
		System.out.println(farbe + zahl + wert);
	}
	
}

class Stapel
{
	private Karte [] karten = new Karte[32];
	private Karte[] array;
	private Stapel spielerStapel; // = new Stapel(16);
	private Stapel computerStapel; // = new Stapel(16);
	private int top = 0;
	public Stapel()					//Karten anlegen und auf einen Stapel legen
	{
		karten[0] = new Karte("Karo", "7", 1);
		karten[1] = new Karte("Herz", "7", 2);
		karten[2] = new Karte("Pik", "7",3);
		karten[3] = new Karte("Kreuz", "7", 4);
		karten[4] = new Karte("Karo", "8", 5);
		karten[5] = new Karte("Herz", "8", 6);
		karten[6] = new Karte("Pik", "8", 7);
		karten[7] = new Karte("Kreuz", "8",8);
		karten[8] = new Karte("Karo", "9", 9);
		karten[9] = new Karte("Herz", "9", 10);
		karten[10] = new Karte("Pik", "9", 11);
		karten[11] = new Karte("Kreuz", "9", 12);
		karten[12] = new Karte("Karo", "10", 13);
		karten[13] = new Karte("Herz", "10", 14);
		karten[14] = new Karte("Pik", "10", 15);
		karten[15] = new Karte("Kreuz", "10", 16);
		karten[16] = new Karte("Karo", "Bube", 17);
		karten[17] = new Karte("Herz", "Bube", 18);
		karten[18] = new Karte("Pik", "Bube", 19);
		karten[19] = new Karte("Kreuz", "Bube", 20);
		karten[20] = new Karte("Karo", "Dame", 21);
		karten[21] = new Karte("Herz", "Dame", 22);
		karten[22] = new Karte("Pik", "Dame", 23);
		karten[23] = new Karte("Kreuz", "Dame", 24);
		karten[24] = new Karte("Karo", "Koenig", 25);
		karten[25] = new Karte("Herz", "Koenig", 26);
		karten[26] = new Karte("Pik", "Koenig", 27);
		karten[27] = new Karte("Kreuz", "Koenig", 28);
		karten[28] = new Karte("Karo", "Ass", 29);
		karten[29] = new Karte("Herz", "Ass", 30);
		karten[30] = new Karte("Pik", "Ass", 31);
		karten[31] = new Karte("Kreuz", "Ass", 32);
	}
	public Stapel(int nr)				//Stack fuer Spieler/Computer Stapel
	{
		array = new Karte[nr];
	}
	
	public void mischenUndAusteilen()
	{
		Stapel spielerStapel = new Stapel(16);
		Stapel computerStapel = new Stapel(16);
		
		int zufallsZahlen [] = {31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
					 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
				 
		int [] gemischt = new int [32];
		
		int i;
		
		int h = 0;
			 
		for(int z = 31; z >= 0; z--)
		{		
			i = (int) (Math.random()*z);
			gemischt [h] = zufallsZahlen[i];
			zufallsZahlen[i] = 0;
			Bubblesort2.sort (zufallsZahlen);
			h++;

		}
		
		
		for(int j=0; j<16; j++)
		{
			int g = gemischt[j];
			spielerStapel.push(karten[g]);
		}
		for(int j=16; j<=31; j++)
		{
			int g = gemischt[j];
			computerStapel.push(karten[g]);
		}
	}
	
	public void push(Karte element)
	{
		array[top++] = element;
	}
	public Karte pop()
	{
		return array[--top];
	}
	public boolean isEmpty()
	{
		if (top == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public boolean isFull()
	{
		if (top == array.length)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public void print()
	{
		System.out.println(spielerStapel.pop());
	}
		
} 






public class Spiel7
{
	
	public static void main(String[] args)
	{
		Spieler Spieler1 = new Spieler(); //anlegen des Benutzers als Spieler
		Spieler Computer = new Spieler(); //anlegen des COmputers als Gegner
		Stapel spielStapel;
		spielStapel = new Stapel();
		spielStapel.mischenUndAusteilen();
		Stapel spielerStapel = new Stapel(16);
		Stapel computerStapel = new Stapel(16);
		spielerStapel.print();
		
		
	}
}

Anscheinend wird das Stack gar nicht belegt... Ich hoffe auf Hilfe
 

Janus88

Mitglied
Soderle,
extra früh aufgestanden und über das Problem weiter nachgedacht. Es war wohl nicht sehr objektorientiert 3 Klassen für ein und dasselbe Problem zu erstellen. Ich hoffe ich habe mich gebessert und die Variablen alle richtig geschrieben usw. Ich kann es jetzt sogar compilieren, allerdings bekomme ich beim ausführen folgende Fehlermeldung:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 32
at Stapel.mischenUndAusteilen(Spiel7.java:81)
at Spiel7.main(Spiel7.java:162)

Code:
class Stapel
{
	private Karte [] karten = new Karte[32];
	private Karte[] array;
	private Stapel spielerStapel; // = new Stapel(16);
	private Stapel computerStapel; // = new Stapel(16);
	private int top = 0;
	public Stapel()					//Karten anlegen und auf einen Stapel legen
	{
		karten[0] = new Karte("Karo", "7", 1);
		karten[1] = new Karte("Herz", "7", 2);
		karten[2] = new Karte("Pik", "7",3);
		karten[3] = new Karte("Kreuz", "7", 4);
		karten[4] = new Karte("Karo", "8", 5);
		karten[5] = new Karte("Herz", "8", 6);
		karten[6] = new Karte("Pik", "8", 7);
		karten[7] = new Karte("Kreuz", "8",8);
		karten[8] = new Karte("Karo", "9", 9);
		karten[9] = new Karte("Herz", "9", 10);
		karten[10] = new Karte("Pik", "9", 11);
		karten[11] = new Karte("Kreuz", "9", 12);
		karten[12] = new Karte("Karo", "10", 13);
		karten[13] = new Karte("Herz", "10", 14);
		karten[14] = new Karte("Pik", "10", 15);
		karten[15] = new Karte("Kreuz", "10", 16);
		karten[16] = new Karte("Karo", "Bube", 17);
		karten[17] = new Karte("Herz", "Bube", 18);
		karten[18] = new Karte("Pik", "Bube", 19);
		karten[19] = new Karte("Kreuz", "Bube", 20);
		karten[20] = new Karte("Karo", "Dame", 21);
		karten[21] = new Karte("Herz", "Dame", 22);
		karten[22] = new Karte("Pik", "Dame", 23);
		karten[23] = new Karte("Kreuz", "Dame", 24);
		karten[24] = new Karte("Karo", "Koenig", 25);
		karten[25] = new Karte("Herz", "Koenig", 26);
		karten[26] = new Karte("Pik", "Koenig", 27);
		karten[27] = new Karte("Kreuz", "Koenig", 28);
		karten[28] = new Karte("Karo", "Ass", 29);
		karten[29] = new Karte("Herz", "Ass", 30);
		karten[30] = new Karte("Pik", "Ass", 31);
		karten[31] = new Karte("Kreuz", "Ass", 32);
	}
	public Stapel(int nr)				//Stack fuer Spieler/Computer Stapel
	{
		array = new Karte[nr];
	}
	
	public void mischenUndAusteilen()
	{
		Stapel spielerStapel = new Stapel(16);
		Stapel computerStapel = new Stapel(16);
		
		int zufallsZahlen [] = {32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
					 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
				 
		int [] gemischt = new int [32];
		
		int i;
		
		int h = 0;
			 
		for(int z = 31; z >= 0; z--)
		{		
			i = (int) (Math.random()*z);
			gemischt [h] = zufallsZahlen[i];
			zufallsZahlen[i] = 0;
			Bubblesort2.sort (zufallsZahlen);
			h++;

		}
		
		
		for(int j=0; j<16; j++)
		{
			int g = gemischt[j];
			spielerStapel.push(karten[g]);
		}
		for(int j=16; j<=31; j++)
		{
			int g = gemischt[j];
			computerStapel.push(karten[g]);
		}
	}
	
	public void push(Karte element)
	{
		array[top++] = element;
	}
	public Karte pop()
	{
		return array[--top];
	}
	public boolean isEmpty()
	{
		if (top == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public boolean isFull()
	{
		if (top == array.length)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public void print()
	{
		System.out.println(spielerStapel.pop());
	}
		
} 



class Karte
{
	private String farbe;
	private String zahl;
	private int wert;
	public Karte(String farbe, String zahl, int wert)
	{
		this.farbe= farbe;
		this.zahl= zahl;
		this.wert= wert;
	}
	public String getFarbe()
	{
		return farbe;
	}
	public String getZahl()
	{
		return zahl;
	}
	public int getWert()
	{
		return wert;
	}
	public void print()
	{
		System.out.println(farbe + zahl + wert);
	}
	
}


public class Spiel7
{
	
	public static void main(String[] args)
	{
		Stapel spielStapel;
		spielStapel = new Stapel();
		spielStapel.mischenUndAusteilen();
		Stapel spielerStapel = new Stapel(16);
		Stapel computerStapel = new Stapel(16);
		spielerStapel.print();
		
		
	}
}
Ich hoffe dass mir diesmal jemand helfen kann?
Grüße Helmut
 
S

SlaterB

Gast
ein Array oder eine Liste der Länge 32 unterstützlich nur die Indexe 0 bis 31,
darauf kann man nicht mit Index 32 zugreifen

> int g = gemischt[j];
> computerStapel.push(karten[g]);

g wird 32, karten[32] gibts nicht


----

spielerStapel in der print-Methode ist immer null,

in mischenUndAusteilen() wird zwar spielerStapel gesetzt, allerdings eine neue lokale Variable mit diesen Namen, nicht das Klassenattribut,

schreibe dort
spielerStapel = new Stapel(16);
statt
> Stapel spielerStapel = new Stapel(16);
 

Janus88

Mitglied
ES LÄUFT!!!! ;)

Code:
class Spieler
{
	private int punkte;
	public Spieler()  //anlegen von Spieler und Computer als Gegner
	{
		this.punkte = punkte;
	}
	
	
}

class Karte
{
	private String farbe;
	private String zahl;
	private int wert;
	public Karte(String farbe, String zahl, int wert)
	{
		this.farbe= farbe;
		this.zahl= zahl;
		this.wert= wert;
	}
	public String getFarbe()
	{
		return farbe;
	}
	public String getZahl()
	{
		return zahl;
	}
	public int getWert()
	{
		return wert;
	}
	public void print()
	{
		System.out.println(farbe +" "+ zahl);
	}
	
}

class Stapel
{
	private Karte [] karten = new Karte[32];
	private Karte[] array;
	private Stapel spielerStapel; // = new Stapel(16);
	private Stapel computerStapel; // = new Stapel(16);
	public int top = 0;
	public Stapel()					//Karten anlegen und auf einen Stapel legen
	{
		karten[0] = new Karte("Karo", "7", 1);
		karten[1] = new Karte("Herz", "7", 2);
		karten[2] = new Karte("Pik", "7",3);
		karten[3] = new Karte("Kreuz", "7", 4);
		karten[4] = new Karte("Karo", "8", 5);
		karten[5] = new Karte("Herz", "8", 6);
		karten[6] = new Karte("Pik", "8", 7);
		karten[7] = new Karte("Kreuz", "8",8);
		karten[8] = new Karte("Karo", "9", 9);
		karten[9] = new Karte("Herz", "9", 10);
		karten[10] = new Karte("Pik", "9", 11);
		karten[11] = new Karte("Kreuz", "9", 12);
		karten[12] = new Karte("Karo", "10", 13);
		karten[13] = new Karte("Herz", "10", 14);
		karten[14] = new Karte("Pik", "10", 15);
		karten[15] = new Karte("Kreuz", "10", 16);
		karten[16] = new Karte("Karo", "Bube", 17);
		karten[17] = new Karte("Herz", "Bube", 18);
		karten[18] = new Karte("Pik", "Bube", 19);
		karten[19] = new Karte("Kreuz", "Bube", 20);
		karten[20] = new Karte("Karo", "Dame", 21);
		karten[21] = new Karte("Herz", "Dame", 22);
		karten[22] = new Karte("Pik", "Dame", 23);
		karten[23] = new Karte("Kreuz", "Dame", 24);
		karten[24] = new Karte("Karo", "Koenig", 25);
		karten[25] = new Karte("Herz", "Koenig", 26);
		karten[26] = new Karte("Pik", "Koenig", 27);
		karten[27] = new Karte("Kreuz", "Koenig", 28);
		karten[28] = new Karte("Karo", "Ass", 29);
		karten[29] = new Karte("Herz", "Ass", 30);
		karten[30] = new Karte("Pik", "Ass", 31);
		karten[31] = new Karte("Kreuz", "Ass", 32);
	}
	public Stapel(int nr)				//Stack fuer Spieler/Computer Stapel
	{
		array = new Karte[nr];
	}
	
	public void mischenUndAusteilen(Stapel spielerStapel, Stapel computerStapel)
	{
		
		int zufallsZahlen [] = {31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
					 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
				 
		int [] gemischt = new int [32];
		
		int i;
		
		int h = 0;
			 
		for(int z = 31; z >= 0; z--)
		{		
			i = (int) (Math.random()*z);
			gemischt [h] = zufallsZahlen[i];
			zufallsZahlen[i] = 0;
			Bubblesort2.sort (zufallsZahlen);
			h++;

		}
		
		
		for(int j=0; j<16; j++)
		{
			int g = gemischt[j];
			spielerStapel.push(karten[g]);
		}
		
		for(int j=16; j<=31; j++)
		{
			int g = gemischt[j];
			computerStapel.push(karten[g]);
		}
		
	}
	
	public void push(Karte element)
	{
		array[top++] = element;
	}
	public Karte pop()
	{
		return array[--top];
	}
	public boolean isEmpty()
	{
		if (top == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	public boolean isFull()
	{
		if (top == array.length)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
		
} 

class Spiel
{
	public Spiel()
	{
		Spieler Spieler1 = new Spieler(); //anlegen des Benutzers als Spieler
		Spieler Computer = new Spieler(); //anlegen des COmputers als Gegner
		
	}
	
	
}




public class Spiel7
{
	
	public static void main(String[] args)
	{
		Spiel spiel1 = new Spiel();
		Stapel spielStapel;
		spielStapel = new Stapel();
		Stapel spielerStapel = new Stapel(16);
		Stapel computerStapel = new Stapel(16);
		Stapel spielerAblageStapel = new Stapel(32);
		Stapel computerAblageStapel = new Stapel(32);
		Stapel spielerAblageStapel2 = new Stapel(32);
		Stapel computerAblageStapel2 = new Stapel(32);
		Karte eins;
		Karte zwei;
		spielStapel.mischenUndAusteilen(spielerStapel, computerStapel);
		int spielerKarteWert;
		int computerKarteWert;
		int runde = 0;
		int rundenAnzahl;
		System.out.println("Bitte geben Sie die Anzahl der zu spielenden Runden ein oder druecken Sie Enter: ");
		rundenAnzahl = Read.getInt();
		
		while(!spielerStapel.isEmpty() && !computerStapel.isEmpty() && (runde<rundenAnzahl))
		{
			System.out.println();
			System.out.println("Enter druecken zum fortfahren");
			Read.getInt();
		
			Karte element = spielerStapel.pop();
			eins = element;
			System.out.println("Spielerkarte: ");
			element.print();
			
			spielerKarteWert = eins.getWert();
		
			Karte element2 = computerStapel.pop();
			zwei = element2;
			System.out.println("Computerkarte: ");
			element2.print();
			computerKarteWert = zwei.getWert();
		
			if(spielerKarteWert < computerKarteWert)
			{
				System.out.println("Der Computer hat die Runde gewonnen");
				computerAblageStapel.push(element);
				computerAblageStapel.push(element2);
			}
			else
			{
				System.out.println("Der Spieler hat die Runde gewonnen");
				spielerAblageStapel.push(element);
				spielerAblageStapel.push(element2);
			}
			runde++;
			
		}
		System.out.println();
		System.out.println("Die Spielstapel sind leer, es wird mit den Ablagestapeln, weitergespielt");
		System.out.println("Zwischenstand");
		System.out.println("Der Spieler hat " + spielerAblageStapel.top + " Karten");
		System.out.println("Der Computer hat " + computerAblageStapel.top + " Karten");
		while(!spielerAblageStapel.isEmpty() && !computerAblageStapel.isEmpty() && (runde<rundenAnzahl))
		{
			System.out.println();
			System.out.println("Enter druecken zum fortfahren");
			Read.getInt();
		
			Karte element = spielerAblageStapel.pop();
			eins = element;
			System.out.println("Spielerkarte: ");
			element.print();
			
			spielerKarteWert = eins.getWert();
		
			Karte element2 = computerAblageStapel.pop();
			zwei = element2;
			System.out.println("Computerkarte: ");
			element2.print();
			computerKarteWert = zwei.getWert();
		
			if(spielerKarteWert < computerKarteWert)
			{
				System.out.println("Der Computer hat die Runde gewonnen");
				computerAblageStapel2.push(element);
				computerAblageStapel2.push(element2);
			}
			else
			{
				System.out.println("Der Spieler hat die Runde gewonnen");
				spielerAblageStapel2.push(element);
				spielerAblageStapel2.push(element2);
			}
			runde++;
		}
		System.out.println();
		System.out.println("Spielergebniss");
		System.out.println("Der Spieler hat " + spielerAblageStapel.top + "Karten");
		System.out.println("Der Computer hat " + computerAblageStapel.top + "Karten");
		if(computerAblageStapel.top < spielerAblageStapel.top)
		{
			System.out.println("Somit hat der Spieler gewonnen");
		}
		else
		{
			System.out.println("Somit hat der Computer gewonnen");
		}
	}
}

Jetzt muss des was in der Main steht noch in Methoden formuliert werden und ich bin glücklich.

Grüße Helmut
 

Landei

Top Contributor
1) schmeiss die print-Methode aus Karte raus und nimm stattdessen
Code:
    public String toString() {
       return farbe + " " + zahl;
    }

Wenn du dann eine Karte hast, kannst du sie einfach mit System.out.println(karte) ausgeben

2) Das Feld füllst du am besten so:
Code:
  private final static String[] kartenFarbe = {"Karo","Herz","Pik","Kreuz"};
  private final static String[] kartenWert = {"7","8","9","10","Bube","Dame","Koenig","As"};
...
    for(int i = 0; i < 32; i++) {
      karten[i] = new Karte(kartenFarbe[i % 4], kartenWert[i / 4], i+1);
    }

3) überlege dir, ob du die Kartennummer wirklich brauchst. Und wenn ja, lass sie lieber von 0 bis 31 laufen: Dann kannst du auch Farbe und Wert in der Klasse weglassen und bei Bedarf aus statischen arrays (wie unter 2) berechnen lassen:

Code:
class Karte {
  private final static String[] kartenFarbe = {"Karo","Herz","Pik","Kreuz"};
  private final static String[] kartenWert = {"7","8","9","10","Bube","Dame","Koenig","As"};

   private int wert;
   public Karte(int wert) {
     this.wert = wert;
   }

   public String farbe() {
      return kartenFarbe[wert % 4];
   }

   public String wert() {
      return kartenWert[wert / 4]
   }

   //usw
}
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
M Cannot make a static reference to the non-static method Java Basics - Anfänger-Themen 10
W Compiler-Fehler "non-static method cannot be referenced"-Problem Java Basics - Anfänger-Themen 6
M Methoden "Non-static method xy cannot be referenced from a static context" Java Basics - Anfänger-Themen 20
H non-static method cannot be referenced from a static context Java Basics - Anfänger-Themen 2
L Cannot make a static reference to the non-static method Java Basics - Anfänger-Themen 6
F Mal wieder: Cannot make a static reference to the non-static method Java Basics - Anfänger-Themen 9
F Cannot make a static reference to the non-static method Java Basics - Anfänger-Themen 3
Q non-static method blub cannot be referenced from a static context Java Basics - Anfänger-Themen 6
G non static method scale(int,int) cannot be referenced from a static context Java Basics - Anfänger-Themen 16
R Cannot make a static reference to the non-static method Java Basics - Anfänger-Themen 5
frau-u Altes Problem: non-static method cannot be reference Java Basics - Anfänger-Themen 7
S Methoden 2 non-static Methoden, trotzdem Fehler "non static method can not be referenced from a static context" Java Basics - Anfänger-Themen 9
V the static method should be accessed is a static way Java Basics - Anfänger-Themen 6
N Erste Schritte "non-static method" oder "XYZ can not be resolved" Java Basics - Anfänger-Themen 21
E non-static method und static context Java Basics - Anfänger-Themen 15
M Problem mit Static Method Java Basics - Anfänger-Themen 8
A OOP Fehler non-static method can not be[...] Java Basics - Anfänger-Themen 2
N Reference to non-static method Java Basics - Anfänger-Themen 8
C Fehler: non-static method Java Basics - Anfänger-Themen 5
R non-static method execute Java Basics - Anfänger-Themen 3
V Non Static Method. Java Basics - Anfänger-Themen 2
G Problem (oder Verständnisporblem) bei einer static method Java Basics - Anfänger-Themen 9
A The method getClass() from the type saveLog is not static Java Basics - Anfänger-Themen 2
O Welcher Object-Lock-Pool bei static Variablen? Java Basics - Anfänger-Themen 3
A Instance methods should not write to "static" fields Java Basics - Anfänger-Themen 4
berserkerdq2 Habe eine Klasse, welche public ist, diese hat eine public Methode, die nicht static ist. Wenn ich nun versuche aufzurufen Probleme? Java Basics - Anfänger-Themen 8
viktor1 Methoden Methode schreiben static void readText (String filename) {...} zu WordHistogramSample.java Java Basics - Anfänger-Themen 13
M static ArrayList in non-static Java Basics - Anfänger-Themen 12
B Static vs non static und Probleme daraus Java Basics - Anfänger-Themen 13
R UML-Bild (Erkennung ob static o. nicht) Java Basics - Anfänger-Themen 18
R Schulaufgabe, Bruache Hilfe mit non-static Methoden Java Basics - Anfänger-Themen 2
B Static Attribute in einer Klasse, wie geht das? :O Java Basics - Anfänger-Themen 19
NaZuRe Geld(Wert) von der public static void main in die public static void Blackjack Java Basics - Anfänger-Themen 2
H Static Java Basics - Anfänger-Themen 5
K Ausgaben auf der Konsole (static Varible) Java Basics - Anfänger-Themen 9
S public static boolean Java Basics - Anfänger-Themen 4
Vamecruft Compiler-Fehler public static void zu static String ändern Java Basics - Anfänger-Themen 2
L non-static Fehler Java Basics - Anfänger-Themen 16
S Klassenmethode ohne static Java Basics - Anfänger-Themen 2
M (Sehr großes Problem) Listen als static in anderen Klassen verwendet Java Basics - Anfänger-Themen 12
J Fehlermeldung unklar. non-static variable player0 cannot be referenced from a static context Java Basics - Anfänger-Themen 4
D Methoden Scannervariablen in static Methoden Java Basics - Anfänger-Themen 5
P non-static variable cannot be referenced from a static context Java Basics - Anfänger-Themen 6
NormanPatrickBenner static non-static Java Basics - Anfänger-Themen 82
B Email versenden, muss Methode static sein? Java Basics - Anfänger-Themen 7
R static in der Methode Java Basics - Anfänger-Themen 2
E Problem mit static Methode Java Basics - Anfänger-Themen 4
H Vererbung Static Scanner Objekt verwenden - von StdIn in einer importierten Klasse lesen Java Basics - Anfänger-Themen 10
I Abstrakte Klasse - static Attribute deklarieren Java Basics - Anfänger-Themen 14
C Methoden Unterschied zwichen public int, public static int und public static void Java Basics - Anfänger-Themen 2
J Frage zu: public static void main (String[]args) Java Basics - Anfänger-Themen 1
T Datentypen enum static Chaos (blutiger anfänger) Java Basics - Anfänger-Themen 5
D Das leidige Thema static.... Java Basics - Anfänger-Themen 15
Aprendiendo Interpreter-Fehler "non-static variable this cannot be referenced from a static context" Java Basics - Anfänger-Themen 2
T Problem mit static Java Basics - Anfänger-Themen 6
T static String Variable wird nur beim ersten aufruf durch eine Funktion geändert. Java Basics - Anfänger-Themen 16
S Vererbung Zugriff auf Methode funktioniert nicht (static/non-static) Java Basics - Anfänger-Themen 3
snipesss Was kann 'static'? Java Basics - Anfänger-Themen 4
H Variablen error: non-static variable cannot be referenced from a static context Java Basics - Anfänger-Themen 4
M public static int in ActionListener Java Basics - Anfänger-Themen 6
J static verschachtelte Klassen und innere Klassen Java Basics - Anfänger-Themen 1
H Nicht Static Funktion ohne Objekt aufrufen? Java Basics - Anfänger-Themen 6
E Objekte und static Java Basics - Anfänger-Themen 2
K Methoden Methoden in Methoden -> static oder nicht? Java Basics - Anfänger-Themen 7
D Erklärung static boolean Java Basics - Anfänger-Themen 6
L Was genau macht "public static void" ? Java Basics - Anfänger-Themen 12
U Erste Schritte cannot be referenced from a static context Java Basics - Anfänger-Themen 1
B ja ja schon wieder einer mit einer public static void main(string[] args) Frage... Java Basics - Anfänger-Themen 8
J Java: static bei Vererbung Java Basics - Anfänger-Themen 5
O Zu viel static im Projekt Java Basics - Anfänger-Themen 9
F Static final Klasse Java Basics - Anfänger-Themen 0
N static und Objekt kombiniert?!? Java Basics - Anfänger-Themen 3
O Wann nutzt man static? Java Basics - Anfänger-Themen 19
B Klassen Eigene "non static" Klasse in Main verwenden! Java Basics - Anfänger-Themen 12
D neue public static class variablen in array speichern? Java Basics - Anfänger-Themen 6
A Static variablen --- Anwendungsbereich Java Basics - Anfänger-Themen 11
B Erste Schritte Wie komme ich aus Static raus?!! Java Basics - Anfänger-Themen 4
V Static Methods Java Basics - Anfänger-Themen 5
S OOP Klasse mit static-Eigenschaften - HashMap füllen Java Basics - Anfänger-Themen 6
3 OOP static class in einer Klasse Java Basics - Anfänger-Themen 6
B static individuell "vererben"? Java Basics - Anfänger-Themen 8
B Erkennen, wann static oder nicht? Java Basics - Anfänger-Themen 7
T Static Fehler Java Basics - Anfänger-Themen 1
R public static void Rückgabe Java Basics - Anfänger-Themen 5
P Compiler-Fehler public static void main, Grundloses Problem Java Basics - Anfänger-Themen 4
A Cannot make a static reference to the non-static field Java Basics - Anfänger-Themen 6
W Variablen Automatisch static? Java Basics - Anfänger-Themen 3
O Warum muss ich static? Java Basics - Anfänger-Themen 6
O Static Java Basics - Anfänger-Themen 15
B non static interface Methode Java Basics - Anfänger-Themen 16
J KeyListener,MouseListener,MouseMotionListener und static Java Basics - Anfänger-Themen 7
S Static void Methode Java Basics - Anfänger-Themen 12
Q Unterschied zwischen static und keinem Modifier Java Basics - Anfänger-Themen 15
O Main-Methode static modifier umgehen Java Basics - Anfänger-Themen 10
J Variablen non-static variable Java Basics - Anfänger-Themen 2
P Erste Schritte public oder static oder wie? Java Basics - Anfänger-Themen 7
J static - Methoden Java Basics - Anfänger-Themen 22
X Erste Schritte Methode ohne Static Java Basics - Anfänger-Themen 4
B Classpath static block - Verwirrung Java Basics - Anfänger-Themen 2
S Methoden Warum ist sleep static? Java Basics - Anfänger-Themen 9

Ähnliche Java Themen

Neue Themen


Oben