[Java] Uso del tipo Enum

[zanardi84]

Mi sto cimentando con il java, ma non capisco come usare il tipo enumerativo.
In particolare ho trovato un esercizio che dice di creare un tipo enum le cui costanti rappresentano i semi di un mazzo di carte, un secondo enumerativo le cui costanti rappresentano i valori delle carte. Devo poi creare una classe che rappresenta una carta da gioco e infine un mazzo di carte con un array.

Ho scritto questo codice, per definire i due tipi enumerativi. Il problema è che non so come rappresentare la carta da gioco.

public enum Seme
{
// COSTANTI
QUADRI("Quadri"), CUORI("Cuori"), FIORI("Fiori"), PICCHE("Picche");

// Variabili di istanza
private String nome;
// COSTRUTTORE (Dichiarato privato perchè può essere usato solo ed esclusivamente dalla JVM)
private Seme(String nome)
{
this.nome = nome;
}

// Ridefinisco il metodo toString
public String toString()
{
return nome;
}
}

public enum ValoriCarte
{
// COSTANTI ENUMERATIVE
DUE("Due", 2), TRE("Tre", 3), QUATTRO("Quattro", 4), CINQUE("Cinque", 5),
SEI("Sei", 6), SETTE("Sette", 7), OTTO("Otto", 8), NOVE("Nove", 9), DIECI("Dieci", 10),
FANTE("Fante", 11), DONNA("Donna", 12), RE("Re", 13), ASSO("Asso", 14);

// Variabili di istanza
private String nome;
private int valore;

// COSTRUTTORE PRIVATO AD USO ESCLUSIVO DELLA JVM
private ValoriCarte(String nome, int valore)
{
this.nome = nome;
this.valore = valore;
}

// METODO ToString RIDEFINITO
public String toString()
{
return nome;
}

public ValoriCarte successiva()
{
return ValoriCarte.values()[this.ordinal()+1%13];
}

public ValoriCarte precedente()
{
return ValoriCarte.values()[this.ordinal()-1%13];
}

// Atri metodi

public int Valore()
{
return valore;
}
}


La carta deve prendere uno dei valori prescritti dai tipi enumerativi... ma come? E' quì che mi blocco.

[banryu79]

...
La carta deve prendere uno dei valori prescritti dai tipi enumerativi... ma come? E' quì che mi blocco.
Non ho capito, non puoi fare così?

class Carta {
final seme Seme;
final valore ValoriCarte;

public Carta(ValoriCarte v, Seme s) {
valore = v;
seme = s;
}

...
}

// la ragazza mi ha mollato
Carta fregato = new Carta(DUE, PICCHE);
...


Edit: ecco un link a un recente thread circa le enumerazioni in Java
http://www.hwupgrade.it/forum/showthread.php?t=2440398

[zanardi84]

Se devo chiamare il costruttore, per esempio nella creazione del mazzo, come gli passo esattamente quei valori e non un 104 di bastoni?
E il for each a cosa lo applico?

[banryu79]

Se devo chiamare il costruttore, per esempio nella creazione del mazzo, come gli passo esattamente quei valori e non un 104 di bastoni?
E il for each a cosa lo applico?
Ti ho preparato un esempio volante, guarda il costruttore di Mazzo:

package enums;

import java.util.Collections;
import java.util.LinkedList;

public class EnumExample {
public static void main(String[] args) {
example02();
}

static void example01() {
Mazzo mazzo = Mazzo.nuovo();
System.out.println(mazzo);
mazzo.mescola();
System.out.println(mazzo);
}

static void example02() {
Mazzo mazzo = Mazzo.nuovo();
mazzo.mescola();
Carta c1 = mazzo.pesca();
Carta c2 = mazzo.pesca();
System.out.println("Giocatore1 ha pescato " + c1);
System.out.println("Giocatore2 ha pescato " + c2);
String vincitore = (c1.gt(c2)) ? "Giocatore1" : "Giocatore2";
System.out.println(vincitore + " ha vinto!");

}
}

enum Seme {
PICCHE(1, "Pic"),
FIORI(10, "Fio"),
QUADRI(100, "Qua"),
CUORI(1000, "Cuo");

final String nome;
final int valore;

private Seme(int v, String n) {
nome = n;
valore = v;
}
}

enum Figura {
DUE(2, "02"),
TRE(3, "03"),
QUATTRO(4, "04"),
CINQUE(5, "05"),
SEI(6, "06"),
SETTE(7, "07"),
OTTO(8, "08"),
NOVE(9, "09"),
DIECI(10, "10"),
FANTE( 11,"fante"),
DONNA(12, "donna"),
RE(13, "re"),
ASSO(14, "asso");

final String nome;
final int valore;

private Figura(int v, String n) {
nome = n;
valore = v;
}

Figura successiva() {
return Figura.values()[this.ordinal()+1%13];
}

Figura precedente() {
return Figura.values()[this.ordinal()-1%13];
}
}


class Carta implements Comparable<Carta> {
final Seme seme;
final Figura figura;

public Carta(Figura f, Seme s) {
figura = f;
seme = s;
}

@Override
public String toString() {
return String.format("%s[%s]", seme.nome, figura.nome);
}

@Override
public int compareTo(Carta other) {
// "natural order" is ascendent by value
int diff = seme.valore - other.seme.valore;
if (diff != 0) return diff;
return figura.valore - other.figura.valore;
}

public boolean gt(Carta other) {
return this.compareTo(other) >= 1;
}
}

class Mazzo {
static Mazzo nuovo() {
return new Mazzo();
}

private LinkedList<Carta> carte;

private Mazzo() {
carte = new LinkedList<>();
for (Seme s: Seme.values())
for (Figura f: Figura.values())
carte.add(new Carta(f, s));
}

void mescola() {
Collections.shuffle(carte);
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder()
.append("Mazzo di ").append(carte.size()).append(" carte:\n");
for (Carta c : carte) sb.append(c).append("\n");
return sb.toString();
}

public Carta pesca() {
if (carte.isEmpty())
throw new IllegalStateException("Mazzo vuoto");
return carte.removeFirst();
}

public Carta[] pesca(int n) {
if (n > carte.size()) {
String msg = String.format("Chieste %d carte da un mazzo di %d", n, carte.size());
throw new IllegalArgumentException(msg);
}
Carta[] arr = new Carta[n];
for (int i=0; i<n; i++) arr[i] = carte.removeFirst();
return arr;
}
}