OOP Durch ein Enum iterieren...

[Saliver]

Moin Männer,

ich habe in meinem Code Konstanten die ich gerne in einer Enum-Klasse hinterlegen möchte.
Anschließend soll durch dieses Enum z.b. in einer For-Schleife iteriert werden.

Leider habe ich absolut keine Ahnung wie ich an diese Sache rangehen sollte.

Mein bisherige For-Schleife
[Java] String[] farbe =
{ "Pik", "Kreuz", "Karo", "Herz" };
String[] name =
{ "As", "Bube", "Dame", "Koenig", "7", "8", "9", "10" };
int[] werte =
{ 1, 2, 3, 4, 7, 8, 9, 10 };

for (int i = 0; i <= 3; i++)
{
for (int j = 0; j <= 7; j++)
{
stapel.add(new Karte(name[j], farbe, werte[j]));
}
}[/code]


Vielen Dank und Gruß,
Saliver

 

[Michael...]

Vorweg: Ich hab keine Ahnung von Enums!!

Aber man könnte es so machen:

	public enum Weekday {
		MON, TUE, WEN, THU, FRI, SAT, SUN;
	}
		
	public void iterate() {
		for (int i=0; i<Weekday.values().length; i++)
			System.out.println(Weekday.values()[i]);
	}

 

[function]

du erstellst dir 2 enums

public enum Farbe {
  PIK, KREUZ, HERZ, KARO
}
public enum Name {
  AS, KOENIG, DAMEN, BUBE, ZEHN, NEUN, ACHT, SIEBEN
}

und dann kannst du sie durchlaufen:

for(Farbe f: Farbe.values()) {
  for(Name n : Name.values())
    System.out.println(f + " - " + n);
}

 

[Suinos]

Enums hatten wir doch schon mal: Hier
Oder was verstehst du noch nicht? Erstellung? Verwendung?
Hast du es schon mal versucht zu schreiben?


Zum Iterieren:

// Mit index
Suit[] suits = Suit.values();

for (int i = 0; i < suits.length; i++)
{
	Suit suit = suits[i];
}

// Ohne index
for (Suit suit : Suit.values())
{
	
}

Ach, verflucht, sogar von 2 Leuten geschlagen

 

[Saliver]

Danke für die Antworten.
Ich verstehe nur noch nicht wie ich diesen Enums nun die Werte von 1-10 zuweise...

 

[function]

du kannst keine zahlen als enum benutzen... man könnte sich ja aber was ausdenken, wie man die worte in entsprechende zahlen umwandelt

 

[Saliver]

Ich könnte es mit einer for-Schleife machen, aber ich weiß nicht wie ich diese umsetzen soll...

 

[Gastredner]

Du kannst den enums Werte zuweisen:

public enum SomeEnum {
	FOO(0), BAR(1);
	
	private int value;
	
	private SomeEnum(int value) {
		this.value = value;
	}

	public int getValue() {
		return this.value;
	}
}

// Benutzung:
public vois example(SomeEnum se) {
	System.out.println(se.getValue());
}

 

[Suinos]

Enums können auch komplexer sein:

public enum Digit
{
	ZERO(0),
	ONE(1);
	
	private final int number;
	
	private Digit(int number)
	{
		this.number = number;
	}
	
	public int getNumber()
	{
		return number;
	}
}

 

[function]

String str;
switch(n) {
  case AS:
    str = "As";
    break;
  //...
  case ZEHN:
    str = "10";
    break;
}

das könnte man ja in die forschleifen einbauen, oder man ändert das enum

public enum Name {
  AS("As"), KOENIG("Koenig"),...,ZEHN("10"),...;
  
  private String relName;
  Name(String relName) {
    this.relName = relName;
  }

  private String getRelName() {return relName;}

 

[AlexSpritze]

Wenn es wirklich so wie in deinem Beispiel Spielkarten sein sollen, dann würde sich eine Klasse Card gut machen:

public class Card {
 private Suit suit = null;
 private Rank rank = null;
 
 public Card(Suit suit, Rank rank){
  // werte setzen
 }
 // getter Funktionen
}

Und dann könntest du per For-Schleife:

List<Card> cards = ...
for(Rank rank : Rank.values()) {
 for(Suit suit : Suit.values()) {
  cards.add(new Card(rank, suit));
 }
}

 

[Saliver]

Wenn es wirklich so wie in deinem Beispiel Spielkarten sein sollen, dann würde sich eine Klasse Card gut machen:

public class Card {
 private Suit suit = null;
 private Rank rank = null;
 
 public Card(Suit suit, Rank rank){
  // werte setzen
 }
 // getter Funktionen
}

Und dann könntest du per For-Schleife:

List<Card> cards = ...
for(Rank rank : Rank.values()) {
 for(Suit suit : Suit.values()) {
  cards.add(new Card(rank, suit));
 }
}

Ja, aber das sind doch keine Enums.

 

[function]

doch das können auch enums sein

 

[AlexSpritze]

Ja, aber das sind doch keine Enums.

Nein, Spielkarten gibt es beliebig viele, aber Wert und Farbe sind abzählbar endlich.
Aber wenn du willst kannst du die Enums Rank und Suit zu einem neuen Enum Card schachteln,
aber dann geht das mit der Schleife nicht mehr. Da müsstest du explizit jede Karte angeben ...

 

[Saliver]

Mein Problem ist, dass ich noch anfänger bin und mir erstmal code anschauen muss um ihn Schritt für Schritt verstehen zu können.

Ich möchte gerne meinen Enums "Name" und "Farbe" jetzt die unterschiedlichen Werte in einer for-Schleife von 1-10 zuweisen können. Leider weiß ich nicht wie dies geht und daher wäre ich euch selbst verbunden, wenn mir jemand zeigt wie er das gemacht hätte.

 

[function]

du nimmst eine Klasse Karte

public class Karte {
  private Farbe f;
  private Name n;

  public Karte(Farbe f, Name n) {
    this.f = f;
    this.n = n;
  }
}

in deinem Programm mit forschleifen:

for(Farbe f: Farbe.values()) {
  for(Name n: Name.values())
    stabel.add(new Karte(f, n));
}

aus freier hand kann noch nen fehler drin sein...

 

[Der Müde Joe]

http://www.java-forum.org/java-basi...302-kartenspiel-programmieren.html#post526369

 

[AlexSpritze]

Ich möchte gerne meinen Enums "Name" und "Farbe" jetzt die unterschiedlichen Werte in einer for-Schleife von 1-10 zuweisen können. Leider weiß ich nicht wie dies geht und daher wäre ich euch selbst verbunden, wenn mir jemand zeigt wie er das gemacht hätte.

Ah okeh, ich versuche es nochmal
Also Enums stehen für eine abgeschlossene Menge von Werten. Das heißt dein Enum Name wird im Quelltext schon mit diesen Werten Ass König .. Zwei erstellt. Das heißt du legst von vornherein fest, welche Werte es gibt. Du bräuchtest als meinem Verständnis nach keine Wertzuweisung in einer For-Schleife, oder keine Enums.

Auf der Seite der Java Tutorials gibt es die Problematik mit Enums und Spielkarten auch nochmal. Sogar mit Quellcode. Vielleicht hilft dir das weiter? Ansonsten frage ruhig nochmal.

 

[Saliver]

Bei mir steht nun:

    public void eSortieren(Rank rank, Suit suit) {
        this.kartenWert = rank;
        this.kartenFarbe = suit;
    }
	    public Suit getSuit() {
	        return kartenFarbe;
	    }

	    public Rank getRank() {
	        return kartenWert;
	    }

	    public String toString() {
	        return kartenWert + " of " + kartenFarbe;
	    }
	
	    
	    public enum Suit { 
		   DIAMONDS, 
		   CLUBS, 
		   HEARTS, 
		   SPADES 
		}
	    
	    
	    public enum Rank { 
		   DEUCE, THREE, FOUR, FIVE, SIX, SEVEN,
		   EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE 
		}

Leider weiß ich nicht weiter wie ich dies für meine ArrayList mit 32 Karten verwende.

 

[AlexSpritze]

Naja, prinzipiell so ähnlich wie in Deck3.java:

public class Deck3 {
    private static Card3[] cards = new Card3[52];
    public Deck3() {
        int i = 0;
        for (Suit suit : Suit.values()) {
            for (Rank rank : Rank.values()) {
                cards[i++] = new Card3(rank, suit);
            }
        }
    }
}

Bzw. mit ArrayList:

public class Deck3 {
    private List<Card3> cards = new ArrayList<Card3>();
    public Deck3() {
        for (Suit suit : Suit.values()) {
            for (Rank rank : Rank.values()) {
                cards.add(new Card3(rank, suit));
            }
        }
    }
  public Card3 getRandomCard()
  {return cards.get((int)(Math.random()*cards.size()));}
}

Also die Klasse Deck3 fungiert dabei als Kartenstapel, den du mit entsprechenden Methoden manipulieren kannst, wie ich mit getRandomCard().

 

[Saliver]

Hallo Männer,

danke erstmal für alle die vielen Antworten. Doch leider habe ich auch über Ostern es nicht geschafft meinen Kartenstapel über eine Enumklasse erstellen zu lassen.


Entweder bin ich zu schusselig es selber zu tun, oder ich schaffe es nicht das Heu im Heuhaufen zu finden...
Könnt ihr sie mir eine solche Enumklasse runterschreiben?

Um diese Karten im Kartnspiel 17+4 zu erstellen habe ich folgende Methode:

public void stapelEinfuegen()
    {

	String[] farbe =
	{ "Pik", "Kreuz", "Karo", "Herz" };
	String[] name =
	{ "As", "Bube", "Dame", "Koenig", "7", "8", "9", "10" };
	int[] werte =
	{ 1, 2, 3, 4, 7, 8, 9, 10 };

	for (int i = 0; i <= 3; i++)
	{
	    for (int j = 0; j <= 7; j++)
	    {
		stapel.add(new Karte(name[j], farbe[i], werte[j])); // stapel ist eine ArrayList vom Objekt Karte
	    }
	}
    }

Weil mir im letzten Thread gesagt wurde, dass es deutlich schöner ist diese Konstanten in eine Enumklasse zu verstauen und dann über eine for-Schleife zu iterieren, habe ich diesen Thread erstellt.
Ich hoffe ich finde hier einen hilfbereiten Helfer.

Danke und Gruß aus Hamburg,
Saliver

 

[Saliver]

Ich möchte ungern auf die Nerven gehen, aber mir ist es wichtig sowas zu lernen.
Fühlt sich keiner angesprochen?

 

[SlaterB]

was ist denn mit Seite 1 mit den 10 Antworten dort, diverse Enum-Vorschläge zu Faben und Karten,
was funktioniert daran nicht?

z.B. dein Posting von 30.03.2010, 18:06, da hast du doch schon einiges mehr als die simplen String-Arrays,
diese Enums kannst du genausogut mit einer doppelten Schleife durchlaufen und dann die richtigen 32 Enum-Kombinationen in neuen Karten-Objekten ablegen
(siehe Antwort von AlexSpritze direkt danach)

 

[Der Müde Joe]

ach....mein link nehmen..alles kopieren... ein if einbauen...

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;


public class Card implements Comparable<Card> {

	private final Suit suit;

	private final Rank rank;

	public enum Suit {
		HEART, DIAMOND, CLUB, SPADE;
	}

	public enum Rank {
		TWO(2), THREE(3), FOUR(4), FIVE(5), SIX(6), SEVEN(7), EIGHT(8), NINE(9), TEN(10), JACK(11),
		QUEEN(12), KING(13), ACE(14);

		private int rank;

		private Rank(int rank) {
			this.rank = rank;
		}

		public int rank() {
			return this.rank;
		}
	}

	public Card(Rank rank, Suit suit) {
		this.rank = rank;
		this.suit = suit;
	}

	public int compareTo(Card card) {
		return (this.rank.rank() > card.rank.rank()) ? 1 : -1;
	}

	public Rank getRank() {
		return rank;
	}

	public Suit getSuit() {
		return suit;
	}

	public String toString() {
		return "" + rank + " " + suit;
	}
	
	/**
	 * Deck with card from seven to ace
	 * 
	 * @author Der Müde Joe
	 *
	 */
	public static class Deck32 {

		private final int DECK_SIZE = 32;

		private final List<Card> cards;

		public Deck32() {
			cards = new ArrayList<Card>(DECK_SIZE);
			for (Card.Suit suit : Card.Suit.values()) {
				for (Card.Rank rank : Card.Rank.values()) {
					if (rank.rank() > 6) {
						cards.add(new Card(rank, suit));
					}
				}
			}
		}

		public void shuffleDeck() {
			Collections.shuffle(cards);
		}

		public Card deal() {
			return cards.remove(0);
		}

		public void burn() {
			cards.remove(0);
		}
		
		public int size() {
			return cards.size();
		}
	}

	public static void main(String[] args) {
		Deck32 d = new Deck32();
		d.shuffleDeck();
		System.out.println(d.size());
		System.out.println(d.deal());
		System.out.println(d.size());
	}
}

 

[Saliver]

Vielleicht stelle ich mich einfach nur zu blöd an, aber mein Code der Spielsteuerung sieht bisher so aus:

package de.nak;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Random;

public class Einundzwanzig
{

    private ArrayList<Karte> stapel = new ArrayList<Karte>();

    public static Einundzwanzig einundzwanzig = new Einundzwanzig();
    public Menschlicherspieler menschlicherspieler = new Menschlicherspieler();
    public Computerspieler computerspieler = new Computerspieler();
    private File f = new File("C:\\test.txt");
//    private Rank kartenWert;
//    private Suit kartenFarbe;
//
//    
//    
//    public void eSortieren(Rank rank, Suit suit) {
//        this.kartenWert = rank;
//        this.kartenFarbe = suit;
//    }
//        public Suit getSuit() {
//            return kartenFarbe;
//        }
// 
//        public Rank getRank() {
//            return kartenWert;
//        }
// 
//        public String toString() {
//            return kartenWert + " - " + kartenFarbe;
//        }
//    
//        
//        public enum Suit { 
//           PIK, KARO, KREUZ, HERZ
//        }
//        
//        
//        public enum Rank { 
//           AS, BUBE, DAME, KOENIG, SECHS, SIEBEN, ACHT, NEUN, ZEHN
//        }
//    
//            public void Deck3(){
//                for (Suit suit : Suit.values()) {
//                    for (Rank rank : Rank.values()) {
//                        stapel.add(new stapel(rank, suit));
//                    }
//                }
//            }
//          public Card3 getRandomCard()
//          {return cards.get((int)(Math.random()*cards.size()));}
//        }
//        
//}


    
    public static int[] spielstand =
    { 0, 0 };
    public static int[] spielstandsicherung =
    { 0, 0 };

    public static int[] getSpielstandsicherung()
    {
	return spielstandsicherung;
    }

    public static void setSpielstandsicherung(int[] spielstandsicherung)
    {
	Einundzwanzig.spielstandsicherung = spielstandsicherung;
    }

  
    
    
    
    
    public static void main(String[] args)
    {

	einundzwanzig.wilkommen();

	einundzwanzig.start();

    }

    public void wilkommen()
    {
	System.out.println(         
	   "\n##   #          #    ##         #     "   +       
	   "\n# #  #   ## ### # #   #  ## ### # #    "  +   
	   "\n##   #  # # #   ##    # # # #   ##       "  +     
           "\n# #  ## ### ### # # # # ### ### # #      "  +  
           "\n##                   #                     "
           +"\n "
           +"\n "
);
    }

    public void start()
    {

	einundzwanzig.stapelErstellen();
	einundzwanzig.spielStarten();
	einundzwanzig.spielfeldAusgabe();
	einundzwanzig.spielrunde();

    }

    public void stapelErstellen()
    {
	stapelEinfuegen();
	stapelMischen();
    }

    public void stapelEinfuegen()
    {

	String[] farbe =
	{ "Pik", "Kreuz", "Karo", "Herz" };
	String[] name =
	{ "As", "Bube", "Dame", "Koenig", "7", "8", "9", "10" };
	int[] werte =
	{ 1, 2, 3, 4, 7, 8, 9, 10 };

	for (int i = 0; i <= 3; i++)
	{
	    for (int j = 0; j <= 7; j++)
	    {
		stapel.add(new Karte(name[j], farbe[i], werte[j]));
	    }
	}
    }

    
    
    
    /////////


    public void stapelMischen()
    {

	Karte aktuelleKarte;
	int stapelGrenze;
	Random r = new Random();

	for (int i = 0; i < stapel.size(); i++)
	{
	    stapelGrenze = r.nextInt(stapel.size());
	    aktuelleKarte = stapel.get(i);
	    stapel.set(i, stapel.get(stapelGrenze));
	    stapel.set(stapelGrenze, aktuelleKarte);
	}
    }

    public void spielStarten()
    {
	gebeKarteMenschlicherspieler();
	gebeKarteMenschlicherspieler();
	gebeKarteComputerspieler();
	gebeKarteComputerspieler();
    }

    public void stapelLoeschen()
    {
	stapel.clear();
    }

    public void gebeKarteMenschlicherspieler()
    {
	menschlicherspieler.erhalteKarte(stapel.get(0));
	stapel.remove(0);

    }

    public void gebeKarteComputerspieler()
    {
	computerspieler.erhalteKarte(stapel.get(0));
	stapel.remove(0);
    }

    public void spielrunde()
    {

	while (Computerspieler.getComputerHandWert() <= 21
		&& Menschlicherspieler.getMenschHandWert() <= 21)
	{
	    if ((Computerspieler.getComputerHandWert() < 21 && Menschlicherspieler
		    .getMenschHandWert() < 21))
	    {
		dialogSpieler();

		if (Menschlicherspieler.getMenschHandWert() > 21)
		{
		    zwischenstandComputerGewonnen();
		    break;

		}

		dialogComputer();

	    }

	    if (Menschlicherspieler.getMenschHandWert() == Computerspieler
		    .getComputerHandWert())
	    {

		System.out.println("Unentschieden!");
		System.out.println("Spielstand: Du: " + spielstand[0]
			+ " Computer: " + spielstand[1]);
		break;

	    }

	    if (Menschlicherspieler.getMenschHandWert() > 21)
	    {
		zwischenstandComputerGewonnen();
		break;

	    }

	    if (Menschlicherspieler.getMenschHandWert() == 21
		    && Computerspieler.getComputerHandWert() < 21)
	    {
		zwischenstandSpielerGewonnen();
		break;
	    }

	    if (Computerspieler.getComputerHandWert() == 21)
	    {
		zwischenstandComputerGewonnen();
		break;

	    }
	    if (Computerspieler.getComputerHandWert() > 21)
	    {
		zwischenstandSpielerGewonnen();
		break;
	    }

	}
	hauptmenuAuswertung(hauptMenu());
    }

    private void zwischenstandSpielerGewonnen()
    {
	System.out.println("Du hast gewonnen");
	spielstand[0] = spielstand[0] + 1;
	System.out.println("Spielstand: Du: " + spielstand[0] + " Computer: "
		+ spielstand[1]);
    }

    private void zwischenstandComputerGewonnen()
    {
	System.out.println("Computer hat gewonnen");
	spielstand[1] = spielstand[1] + 1;
	System.out.println("Spielstand: Du: " + spielstand[0] + " Computer: "
		+ spielstand[1]);
    }

    public void spielfeldAusgabe()
    {
	for (int i = 0; i < computerspieler.getHandComputer().size(); i++)
	{
	    System.out.println(computerspieler.getHandComputer().get(i)
		    .toString());
	}

	System.out.println("*Computer hat Gesamtpunktzahl: "
		+ Computerspieler.getComputerHandWert() + "*");

	for (int i = 0; i < menschlicherspieler.getHandSpieler().size(); i++)
	{
	    System.out.println(menschlicherspieler.getHandSpieler().get(i)
		    .toString());
	}
	System.out.println("*Spieler hat Gesamtpunktzahl: "
		+ Menschlicherspieler.getMenschHandWert() + "*");

    }

    public void dialogSpieler()
    {
	System.out.println("");
	System.out.println("~Spieler ist dran~");
	System.out.println("Weitere Karte [(1) ja (2) nein]?");
	int eingabe = Eingabe.leseInt();

	if (eingabe == 1 && Menschlicherspieler.getMenschHandWert() < 21)
	{
	    gebeKarteMenschlicherspieler();
	    int k=1;
	    for (int i = 0; i<1;i++)
	    { k+=1;
	    };
	    System.out.print(menschlicherspieler.getHandSpieler().get(k)
		    .toString());
	    System.out.println("");
	    System.out.println("*Spieler hat Gesamtpunktzahl: "
		    + Menschlicherspieler.getMenschHandWert() + "*");
	}
    }

    public void dialogComputer()
    {
	System.out.println("Computer ist dran");
	computerAnfrageWeitereKarte();
	if (computerAnfrageWeitereKarte() == 2)
	{
	    System.out.println("-Computer passt-");

	} else
	{
	    gebeKarteComputerspieler();
	    int k=1;
	    for (int i = 0; i<1;i++)
	    { k+=1;
	    };
	    System.out.print(computerspieler.getHandComputer().get(k)
		    .toString());
	    System.out.println("*Computer hat Gesamtpunktzahl: "
		    + Computerspieler.getComputerHandWert() + "*");
	}
    }

    public int computerAnfrageWeitereKarte()
    {
	if (Computerspieler.getComputerHandWert() < Menschlicherspieler
		.getMenschHandWert())
	{
	    int i = 1;
	    return i;
	} else if (Computerspieler.getComputerHandWert() > Menschlicherspieler
		.getMenschHandWert()
		&& Menschlicherspieler.getMenschHandWert() != 21)
	{
	    int i = 2;
	    return i;

	} else if (Computerspieler.getComputerHandWert() == Menschlicherspieler
		.getMenschHandWert()
		&& Computerspieler.getComputerHandWert() < 20)
	{

	    System.out.println("Computer behält Karten");
	    int i = 3;
	    return i;
	} else
	{
	    int i = 1;
	    return i;
	}
    }

    public int hauptMenu()
    {
	System.out.println("\n--------------------" + "\n Wähle weise!"
		+ "\n (1) weiteres Spiel" + "\n (2) Spiel beenden"
		+ "\n (3) Spielstand speichern" + "\n (4) Spielstand laden"
		+ "\n (5) aktuellen Punktestand anzeigen");
	return Eingabe.leseInt();
    }

    public void spielSpeichern()
    {
	spielstandsicherung[0] = spielstand[0];
	spielstandsicherung[1] = spielstand[1];
	listInDatei();
	System.out.println("Spielstand wurde gespeichert!");
    }

    public void spielLaden()
    {
	listVonDatei();
	spielstand[0] = spielstandsicherung[0];
	spielstand[1] = spielstandsicherung[1];

	System.out.println("Spielstand geladen" + "\n Du: " + spielstand[0]
		+ " - Computer: " + spielstand[1]);
    }

    public void hauptmenuAuswertung(int x)
    {

	if (x < 1 || x > 5)
	{
	    System.out
		    .println("Bitte gültigen Wert (1,2,3,4 oder 5) eingeben!");
	    hauptmenuAuswertung(hauptMenu());
	}
	switch (x)
	{
	case 1:
	    System.out.println("Neues Spiel wird gestartet...");
	    Menschlicherspieler.setMenschHandWert(0);
	    Computerspieler.setComputerHandWert(0);
	    einundzwanzig.stapelLoeschen();
	    computerspieler.neueHand();
	    menschlicherspieler.neueHand();
	    Menschlicherspieler.setMenschHandWert(0);
	    Computerspieler.setComputerHandWert(0);
	    Einundzwanzig.main(new String[]
	    { "1", "2", });
	    break;

	case 2:
	    System.out.println("Das Spiel wurde beendet");
	    System.exit(1);
	    break;

	case 3:
	    spielSpeichern();
	    hauptmenuAuswertung(Eingabe.leseInt());
	    break;
	case 4:
	    spielLaden();
	    hauptmenuAuswertung(Eingabe.leseInt());
	    break;
	case 5:
	    spielstandAusgabe();
	    hauptmenuAuswertung(Eingabe.leseInt());
	    break;

	}

    }

    private void spielstandAusgabe()
    {
	System.out
		.println("Spielstand: " + spielstand[0] + ":" + spielstand[1]);
    }

    private void listInDatei()
    {
	StringBuilder sb = new StringBuilder();

	try
	{
	    f.createNewFile();
	    PrintWriter printWriter = new PrintWriter(new FileWriter(f));
	    for (int i = 0; i < spielstandsicherung.length; i++)
	    {
		sb.append(spielstandsicherung[i]);
		if (!(i + 1 == spielstandsicherung.length))
		{
		    sb.append(":");

		}

	    }

	    printWriter.println(sb.toString());

	    printWriter.close();
	} catch (IOException e)
	{
	    e.printStackTrace();

	}

    }

    public void listVonDatei()
    {

	FileReader fr;
	try
	{

	    fr = new FileReader(f);

	    BufferedReader br = new BufferedReader(fr);
	    String line;
	    String[] sArr = null;
	    while ((line = br.readLine()) != null)
	    {
		sArr = line.split(":");

	    }
	    int[] neuerSpielstand = new int[sArr.length];

	    for (int i = 0; i < sArr.length; i++)
	    {
		neuerSpielstand[i] = Integer.parseInt(sArr[i]);

	    }

	    setSpielstandsicherung(neuerSpielstand);

	} catch (FileNotFoundException e)
	{
	    // TODO Auto-generated catch block
	    e.printStackTrace();

	} catch (IOException e)
	{
	    e.printStackTrace();
	}

    }

}

Ich weiß nicht was ich genau kopieren muss damit eure Vorschläge funktionieren. Ich habe einige Enum-Vorschläge in die Spielsteuerung kopiert und leicht angepasst.
Leider habe ich einen Haufen an Fehlern gekriegt.

 

[SlaterB]

der bei dir auskommentierte Code oder allgemein alles besprochenene, z.B. das von Der Müde Joe zuletzt,
gehört eher in die Klasse Karte als in Einundzwanzig,

ansonsten musst du schon deine konkreten Einbauversuche zeigen und die Fehlermeldungen
und es kann nicht sein dass stattdessen immer noch eine Methode wie
> public void stapelEinfuegen()
vorhanden ist,
solange du die unverändert behälst bewegst du dich ja offensichtlich überhaupt nicht auf die Enums zu,
dann ist es wirklich berechtigt, einfach gar nix zu versuchen und nur nach fertigen Code (genau passend in dein Programm hinein) zu fragen,
aber ob das jemand macht?

 

[Saliver]

Ich habe es ja versucht so gut wie möglich umzusetzen, aber anschließend hat das ganze Programm nicht mehr funktioniert, aus welchem Grund ich natürlich zur letzten laufenden Version zurückgesprungen bin.

Ich habe jetzt eine Klasse Deck3 erstellt in der folgender Inhalt zu finden ist:

package de.nak;

import java.util.ArrayList;

import de.nak.Einundzwanzig.Rank;
import de.nak.Einundzwanzig.Suit;

public class Deck3 {
    private ArrayList<Karte> cards = new ArrayList<Karte>();
    public Deck3() {
        for (Suit suit : Suit.values()) {
            for (Rank rank : Rank.values()) {
                cards.add(new Karte(rank, suit));
            }
        }
    }
  public Karte getRandomCard()
  {return cards.get((int)(Math.random()*cards.size()));}
}

In der Zeile (13) "cards.add[...]" kommt die Fehlermeldung "The contructor Karte(Einundzwanzig.Rank, Einundzwanzig.Suit)is undefined "
Ich weiß nicht wo das Problem liegt bzw. wie ich es beheben kann.

 

[SlaterB]

bisher hattest du
> stapel.add(new Karte(name[j], farbe, werte[j]));

in der hier unbekannten Klasse Karte (genial die nicht zu posten wenn damit ein Problem besteht)
hast du also anscheinend einen Konstruktor mit String-Parametern,

wenn du nun zwei Enums übergeben willst, dann muss der Konstruktor angepasst werden, andere Parameter nämlich von den Enum-Typen,
schau dir das Beispiel von De Müde Joe an:

    public Card(Rank rank, Suit suit) {
        this.rank = rank;
        this.suit = suit;
    }

dann natürlich auch andere Klassenattribute, andere getter usw., das zieht sich durch das ganze Programm

 

[Saliver]

Sorry, die Klasse Karte habe ich völlig vergessen.

Sie sieht so aus:

package de.nak;

import de.nak.Einundzwanzig.Rank;
import de.nak.Einundzwanzig.Suit;

public class Karte
{

    private String name;
    private String farbe;
    private int wert;
    
//    public Karte(String name, String farbe, int wert)
//    {
//	this.name = name;
//	this.farbe = farbe;
//	this.wert = wert;
//	}

    
    public Karte(Rank rank, Suit suit)
    {
	    }
   


    public String toString(){
	return new String(	
		  " ____________"
	       +"\n|"+farbe
	       +"\n|"+" *"+name
	       +"\n|            |"
	       +"\n|            |"
	       +"\n|____________|"
	       +"\n"
	);
		
		
	
	};
    
    
    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String getFarbe()
    {
        return farbe;
    }

    public void setFarbe(String farbe)
    {
        this.farbe = farbe;
    }

    public int getWert()
    {
        return wert;
    }

    public void setWert(int wert)
    {
        this.wert = wert;
    }
    

   }

Nun habe ich den Konstruktor so gut wie möglich bearbeitet, es werden auch keine Fehler angezeigt. Jedoch weiß ich jetzt nicht was der nächste logische Schritt wäre um das Programm zum Laufen zu kriegen.


Ich muss ja nun auf die Klasse Deck3 zugreifen und mir die Karten generieren lassen.
Wie schreibe ich denn eine Methode in die Spielsteuerungsklasse, um dieses zu erreichen?

 

[SlaterB]

schau dir die Klasse Card von Der Müde Joe an,
kopiere sie vielleicht vollständig,

 

[Der Müde Joe]

>kopiere sie vielleicht vollständig,

Dann sollte man aber das compareTo noch flicken zu:

public int compareTo(Card card) {
	int thisRank = this.rank.rank();
	int otherRank = card.rank.rank();
	return (thisRank > otherRank) ? 1 : (thisRank < otherRank ? -1 : 0);
}

 

[Saliver]

Okay, was ich jedoch nicht verstehe ist, wieso für solch eine belanglose "verschönerung meines Programmierstils" so viel Aufwand erfordert.
Ist das grundsätzlich immer so?

 

[Der Müde Joe]

>Ist das grundsätzlich immer so?

Die Schönheit liegt im Auge des Betrachters. ;-)

Es geht nicht immer um die Schönheit des codes, aber
Code soll Verständlich und einfach lesbar sein --> Wartbar
Code soll robust sein --> weniger fehleranfällig

 

[SlaterB]

immer wenn man eine belanglos die Breite einer Autostraße halbiert, wirkt sich das auf alle Autos in Deutschland aus,
ähnlich komisch klingen deine Fragen,

wenn du statt einen String einen Enum-Wert verwendest, der durch das halbe Programm reicht,
so müssen natürlich auch die Parameter von Methoden, die Typen von Klassenattributen usw. geändert werden,
das ist doch so klar wie Kloßbrühe

 

[Saliver]

Ich kann verstehen, dass es schwierig ist sich als Nestor in einem Fachgebiet in die Lage von Neuankömmlingen hineinzuversetzen.
Sorry, wenn mein Wissensstand euren Erwartungen nicht entspricht, aber ich kann mir beim besten Willen nicht vorstellen, wie ich den Code von "der müde joe" für meine Programm verwenden kann, ohne dass es total zerstört wird.

 

[Der Müde Joe]

Das hat refactoring so an sich. Vor allem bei so einem grossen.

Zuerst muss das ganze stapel zeugs weg: Das Deck kann dir Karten geben.

//erstelle ein neues Deck mit 32 Karten
Deck32 deck = new Deck32();
// es soll ja auch gemischt werden
deck.shuffleDeck();
// jetzt geben wird Karten
Card card = deck.deal();
// irgendwer bekommt diese

Dann muss halt die ganze Logik abgepasst werden

ein Spieler bekommt eine Karte...
Hmmm...Klasse spieler mit x Karten

class Player {
List<Card> hand = new ArrayList<Card>();

public void add(Card card) { hand.add(card);}

ein spieler hat auch eine Anzahl in seiner Hand...oh neue Methode in Spieler

public int countHand() {
int count = 0;
for(Card card : hand) {
count += card.getRank().rank();
}
return count;

So baut sich dann ein Stein auf dem anderen auf.
Und am Schluss kommt nocht die Spiellogik dazu.

 

[Saliver]

Ich habe jetzt meinen Code auf Ausgangsgrundlage gebracht und versucht sauber Schritt für Schritt neu anzufangen.

So habe ich zwei Enum-Klasse erstellt:
[Java]
public enum EKartenFarben
{
PIK, KREUZ, HERZ, KARO
}
[/code]

und

public enum EKartenWerte
{
	  AS, BUBE, DAME, KOENIG, SIEBEN, ACHT, NEUN, ZEHN    
}

Eine neue Methode für die Enums in der Spielsteuerungsklasse geschriebene:

    public void eStapeleinfügen(){

	    int[] werte = { 1, 2, 3, 4, 7, 8, 9, 10 };
	
		for (int i = 0; i <= 3; i++)
		{
		    for (int j = 0; j <= 7; j++)
		    {
			stapel.add(new Karte(EKartenWerte.values()[j], EKartenFarben.values()[i], werte[j]));
		    }
		
		
	  }
    }

und anschließend in der Klasse Karte die Parameter bearbeitet:

public class Karte
{

    private EKartenWerte name;
    private EKartenFarben farbe;
    private int wert;
    
    public Karte(EKartenWerte eKartenWerte, EKartenFarben eKartenFarben, int wert)
    {
	this.name = eKartenWerte;
	this.farbe = eKartenFarben;
	this.wert = wert;
	}

Habe ich die Aufgabe damit gelöst?

 

[SlaterB]

die Aufgabe kennt hier niemand, wird ohne ein ausführbares Programm aber wohl nicht gelöst sein

 

[Saliver]

Es ging doch darum, dass ihr mir quasi die Aufgabe gegeben habt meinen Code zu verschönern bzw. etwas für meinen eigenen Programmierstil beizutragen, indem ich für meine Konstanten Enum-Klassen verwende.

Dies habe ich ja nun so gut es geht getan - das Spiel funktioniert wunderbar.
Die Frage ist nur, ob ihr genau das sehen wolltet.
Oder gibt es eine bessere Möglichkeit Enums zu erstellen und durch sie, anders als ich es gemacht habe, zu iterieren?

 

[function]

ich würde dieses werte array weg lassen und in das EKartenWerte Enum verlagern, so das jeder KartenWert ("Kartenname") im enum einem Wert zugeordnet ist

 

[Saliver]

Wie ordne ich den Kartennamen einen Wert zu? so-> Koenig(4) ?

 

[function]

public enum EKartenWert {
  KOENIG(4),
  //...

  private final int wert;
  EKartenWert(int wert) {
    this.wert = wert;
  }
  int getWert() {return wert;}
}

 

[Saliver]

Dann mäckert er mit "The constructor EKartenWerte() is undefined"

Das Elend sieht so aus:

package de.nak;

public enum EKartenWerte
{
	  AS, BUBE, DAME, KOENIG, SIEBEN, ACHT, NEUN, ZEHN;

	  private final int wert;
	  EKartenWerte(int wert) {
	    this.wert = wert;
	  }
	  int getWert() {return wert;}
	}

 

[function]

es muss dann auch heißen:
AS(1), BUBE(2), DAME(3),...

 

[Saliver]

Hat super funktioniert, vielen Dank.
Das letzte Problem liegt nur darin, dass die Variable "wert" in einer anderen Klasse gebraucht wurde um den Wert der Karten in der Spielerhand zu berechnen. Wie kann ich nun diesen SpielerHandWert mit den Werten aus den Enums verknüpfen?

z.B in der Klasse Computerspieler:

    public void erhalteKarte(Karte k){
	      handComputer.add(k);
	       computerHandWert += k.getWert();      
    }

 

[function]

ich nehme deine Karten klasse:

public class Karte
{
 
    private EKartenWerte name;
    private EKartenFarben farbe;
    private int wert;
    
    public Karte(EKartenWerte eKartenWerte, EKartenFarben eKartenFarben)
    {
    this.name = eKartenWerte;
    this.farbe = eKartenFarben;
    this.wert = eKartenWerte.getWert();// einfach so ändern
    }
}

das ganze vereinfacht es halt nur wenn du nochmal die werte ändern möchtest, weil du dann nicht erst irgend wo das array mit den werten suchen musst, sondern du änderst nur die werte im enum und fertig

 

[Saliver]

Tatsächlich...und ich werkel hier und dort und komme zu immer mehr Fehlern...dabei ist es doch so einfach.

Vielen herzlichen Dank.

Das Spiel funktioniert nun perfekt, ich bin glücklich ;-)

 

[Saliver]

Hier das Spiel, falls jemand kurzfristig in den großen Weiten des World Wide Webs eine ähnliche Aufgabe programmieren muss:

Anhang anzeigen blackjack.zip