1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

non static method referenced from static context

Dieses Thema im Forum "Web-Programmierung" wurde erstellt von Janus88, 14.12.08.

  1. Janus88

    Janus88 Jonagold

    Dabei seit:
    28.09.07
    Beiträge:
    18
    Hallo,
    ich muss für die Schule ein Kartenspiel programmieren. Dabei geht es im groben darum 32 Karten zu mischen auf 2 Stapel zu verteilen und von den beiden Stapel die jeweils oberste zu vergleichen und die höhere Sticht und kommt dann auf einen Ablagestapel, wenn der gemischte Stapel leer ist wird vom Ablagestapel aus weitergespielt. Ich bin jetzt soweit, dass ich mische und auf die beiden Stapel austeile. Allerdings kommt beim compilieren die Meldung:


    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
     
    #1 Janus88, 14.12.08
    Zuletzt bearbeitet: 14.12.08
  2. onemws

    onemws Roter Delicious

    Dabei seit:
    11.10.08
    Beiträge:
    90
    Du darfst aus einem "static" Kontext nicht nicht-static Methoden aufrufen.

    Hintergrund ist, dass Methoden, die nicht-static sind, immer an ein Objekt der entsprechenden Klasse gebunden sind.

    D.h. du musst deinen SpielerStapel erst instanziieren, z.B.:
    SpielerStapel stapel = new SpielerStapel(10);

    Dann kannst du an diesem Objekt die Methoden aufrufen, z.B.:
    stapel.pop();

    Und bitte gewöhne dir schnellstens an, die Variablen-Namen mit einem kleinen Buchstaben zu beginnen.

    Ausserdem macht es keinen Sinn, zwei einzelne Klassen für den SpielerStapel und den ComputerStapel zu schreiben.
    Da reicht eine Klasse, du erzeugst dann daraus 2 separate Objekte, z.B.:
    public class Stapel
    {
    ...
    }

    Und dann später:
    Stapel spielerStapel = new Stapel();
    Stapel computerStapel = new Stapel();


    Frag mal euren Lehrer, ob er euch die Objektorientierung erklären kann...

    Gruß
     
  3. bezierkurve

    bezierkurve Danziger Kant

    Dabei seit:
    12.06.05
    Beiträge:
    3.861
    … und noch ein Tipp: Die Forensoftware hat Code-Tags, die steigern die Übersichtlichkeit ungemein, da auch (hoffentlich vorhandene :D ) Einrückungen erhalten bleiben.
     
  4. Janus88

    Janus88 Jonagold

    Dabei seit:
    28.09.07
    Beiträge:
    18
    Ja das kann er sogar sehr gut, aber ich hab da als Anfänger noch Probleme es ab und zu anzuwenden. Ich mach das ganze ja erst seit ein paar Wochen und ich habe es gar nicht gemerkt, die Variable groß geschrieben zu haben.

    Sorry bin halt noch nicht fortgeschritten sondern noch blutiger Anfänger.

    Grüße Helmut
     
  5. onemws

    onemws Roter Delicious

    Dabei seit:
    11.10.08
    Beiträge:
    90
    Ok, wichtig ist, dass du dir als erstes überlegst, was du überhaupt an Klassen brauchst.

    Meiner Meinung brauchst du nur eine Klasse Stapel und eine Klasse Karte.
    Da baust du alle Methoden rein, die die jeweiligen Klasse haben soll.

    Du solltest einen Vergleich mit Realität anstellen, dann wird's einfacher, Beispiel:
    Wenn du das Spiel real spielst, hast du zwar drei Stapel, aber alle 3 sind gleich. Du kannst sie zum Spielen untereinander austauschen und es geht immer noch.
    -> Stapel ist nur eine Klasse
     
  6. Janus88

    Janus88 Jonagold

    Dabei seit:
    28.09.07
    Beiträge:
    18
    So ich hoffe ich habe es jetzt etwas besser gemacht. Auch wenn ich immernoch die Klassen Stapel und Stapel2 hab. Für mich ist es so einfacher zu überblicken, auch wenn es nicht ganz objektorientiert ist. Allerdings bekomme ich folgende Fehlermeldung: (Hatte ich glaube ich heute schonmal daher hab ich das ganze mit den 3 Klassen überhaupt angefangen)


    Spiel7.java:157: cannot find symbol
    symbol : variable spielerStapel
    location: class Stapel2
    if(!Stapel2.spielerStapel.isEmpty())
    ^
    Spiel7.java:159: cannot find symbol
    symbol : variable spielerStapel
    location: class Stapel2
    Karte element = Stapel2.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++;
    
    		}
    		Stapel2 spielerStapel = new Stapel2(16);
    		Stapel2 computerStapel = new Stapel2(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 Stapel2
    {
    	private Karte[] array;
    	private int top = 0;
    	public Stapel2(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();
    		
    		if(!spielerStapel.isEmpty())
    		{
    			Karte element = spielerStapel.pop();
    			System.out.println("Spielerkarte :");
    			element.print();
    		}
    	}
    }
    
     
  7. onemws

    onemws Roter Delicious

    Dabei seit:
    11.10.08
    Beiträge:
    90
    Dein Stapel2 hat keinen Member (Variable) spielerStapel.
     
  8. Janus88

    Janus88 Jonagold

    Dabei seit:
    28.09.07
    Beiträge:
    18
    Aber die habe ich doch in der Methode mischen angelegt?
     
  9. onemws

    onemws Roter Delicious

    Dabei seit:
    11.10.08
    Beiträge:
    90
    Nein, alles was innerhalb der Klammern einer Methode an Variablen definiert wird, ist auch nur in dieser Methode bekannt.

    Ganz ehrlich, versuche erstmal etwas die Objektorientierung zu verstehen. Wenn du sowas als Hausaufgabe abgibst, bekommst du eh 'ne 6.
     
  10. Janus88

    Janus88 Jonagold

    Dabei seit:
    28.09.07
    Beiträge:
    18
    Hallo,
    6 gibts bei uns nich, geht nur bis 5 ;).

    Liegt evtl dran dass ich im Moment nicht nur mit Programmieren zu tun hab. Ist nur ein Fach von vielen. Und da ich noch am Anfang stehe, denke ich sind solche Fehler vielleicht vermeidbar, aber manchmal denkt man einfach nicht daran als Anfänger.

    Und wenn ich am Freitag das Programm laufend abgeb und es halbwegs erklären kannn bekomme ich ein bestanden und fertig.

    Grüße Helmut
     
  11. Janus88

    Janus88 Jonagold

    Dabei seit:
    28.09.07
    Beiträge:
    18
    Soderle,
    extra früh aufgestanden, nachdem ich die ganze Nacht vor mich hin überlegt habe. Jetzt is folgendes dabei rausgekommen. 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");
    		}
    	}
    }
    
    Ist es jetzt etwas Objektorientierter geworden?

    Ich will jetzt nur noch die Sachen aus der Main in Methoden packen und es so lösen dass an der Stelle wo die zweite while-Schleife aufgerufen wird, der Ablage Stapel zum Spiel Stapel wird und es keine zweite Schleife mehr benötigt.

    Grüße Helmut
     
    #11 Janus88, 15.12.08
    Zuletzt bearbeitet: 15.12.08

Diese Seite empfehlen