Anatomia di una classe

[Jamie04]

Proseguo nel mio trial, arrivo a questo esercizio:
Write a class whose instances represent a single playing card from a deck of cards. Playing cards have two distinguishing properties: rank and suit

Ci provo. Tutto quello che mi viene in mente è fare una classe che permetta di creare un oggetto "carta" che ha un seme e un numero. Insomma, lì parla di "singola carta da gioco".
Faccio 10 righe e penso di esserci almeno andata vicino.
Poi vado a controllare la soluzione e beh...resto un po' male!
Mi sa che non sono in grado di capire cosa si richiede o il testo dell'esercizio è troppo poco spiegato.
A voi cosa sarebbe venuto in mente di fare con una richiesta come sopra?

Ma ecco la soluzione proposta:

public class Card {
    private final int rank;
    private final int suit;

    // Kinds of suits
    public final static int DIAMONDS = 1;
    public final static int CLUBS    = 2;
    public final static int HEARTS   = 3;
    public final static int SPADES   = 4;

    // Kinds of ranks
    public final static int ACE   = 1;
    public final static int DEUCE = 2;
    public final static int THREE = 3;
    public final static int FOUR  = 4;
    public final static int FIVE  = 5;
    public final static int SIX   = 6;
    public final static int SEVEN = 7;
    public final static int EIGHT = 8;
    public final static int NINE  = 9;
    public final static int TEN   = 10;
    public final static int JACK  = 11;
    public final static int QUEEN = 12;
    public final static int KING  = 13;

    public Card(int rank, int suit) {
        assert isValidRank(rank);
        assert isValidSuit(suit);
        this.rank = rank;
        this.suit = suit;
    }

    public int getSuit() {
        return suit;
    }

    public int getRank() {
        return rank;
    }

    public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

    public static String rankToString(int rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }
    
    public static String suitToString(int suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

    public static void main(String[] args) {
    	
    	// must run program with -ea flag (java -ea ..) to
    	// use assert statements
        assert rankToString(ACE) == "Ace";
        assert rankToString(DEUCE) == "Deuce";
        assert rankToString(THREE) == "Three";
        assert rankToString(FOUR) == "Four";
        assert rankToString(FIVE) == "Five";
        assert rankToString(SIX) == "Six";
        assert rankToString(SEVEN) == "Seven";
        assert rankToString(EIGHT) == "Eight";
        assert rankToString(NINE) == "Nine";
        assert rankToString(TEN) == "Ten";
        assert rankToString(JACK) == "Jack";
        assert rankToString(QUEEN) == "Queen";
        assert rankToString(KING) == "King";

        assert suitToString(DIAMONDS) == "Diamonds";
        assert suitToString(CLUBS) == "Clubs";
        assert suitToString(HEARTS) == "Hearts";
        assert suitToString(SPADES) == "Spades";

    }
}

Non la capisco questa classe.
Per me creare una classe che rappresenti una carta da gioco significava definire essenzialmente uno "stampo" che permettesse di creare un oggetto carta assegnandogli un seme e un valore, sotto forma di stringhe e numeri. E basta...
Sono depressa. Di questo passo non imparerò mai...
Forse il trial di Oracle è meno utile di quanto pensassi, perché alcune cose non son spiegate quasi per niente...

[Kaamos]

Originariamente inviato da Jamie04
Proseguo nel mio trial, arrivo a questo esercizio:
Write a class whose instances represent a single playing card from a deck of cards. Playing cards have two distinguishing properties: rank and suit

Ci provo. Tutto quello che mi viene in mente è fare una classe che permetta di creare un oggetto "carta" che ha un seme e un numero. Insomma, lì parla di "singola carta da gioco".
Faccio 10 righe e penso di esserci almeno andata vicino.
Poi vado a controllare la soluzione e beh...resto un po' male!
Mi sa che non sono in grado di capire cosa si richiede o il testo dell'esercizio è troppo poco spiegato.
A voi cosa sarebbe venuto in mente di fare con una richiesta come sopra?

Ma ecco la soluzione proposta:

public class Card {
    private final int rank;
    private final int suit;

    // Kinds of suits
    public final static int DIAMONDS = 1;
    public final static int CLUBS    = 2;
    public final static int HEARTS   = 3;
    public final static int SPADES   = 4;

    // Kinds of ranks
    public final static int ACE   = 1;
    public final static int DEUCE = 2;
    public final static int THREE = 3;
    public final static int FOUR  = 4;
    public final static int FIVE  = 5;
    public final static int SIX   = 6;
    public final static int SEVEN = 7;
    public final static int EIGHT = 8;
    public final static int NINE  = 9;
    public final static int TEN   = 10;
    public final static int JACK  = 11;
    public final static int QUEEN = 12;
    public final static int KING  = 13;

    public Card(int rank, int suit) {
        assert isValidRank(rank);
        assert isValidSuit(suit);
        this.rank = rank;
        this.suit = suit;
    }

    public int getSuit() {
        return suit;
    }

    public int getRank() {
        return rank;
    }

    public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

    public static String rankToString(int rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }
    
    public static String suitToString(int suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

    public static void main(String[] args) {
    	
    	// must run program with -ea flag (java -ea ..) to
    	// use assert statements
        assert rankToString(ACE) == "Ace";
        assert rankToString(DEUCE) == "Deuce";
        assert rankToString(THREE) == "Three";
        assert rankToString(FOUR) == "Four";
        assert rankToString(FIVE) == "Five";
        assert rankToString(SIX) == "Six";
        assert rankToString(SEVEN) == "Seven";
        assert rankToString(EIGHT) == "Eight";
        assert rankToString(NINE) == "Nine";
        assert rankToString(TEN) == "Ten";
        assert rankToString(JACK) == "Jack";
        assert rankToString(QUEEN) == "Queen";
        assert rankToString(KING) == "King";

        assert suitToString(DIAMONDS) == "Diamonds";
        assert suitToString(CLUBS) == "Clubs";
        assert suitToString(HEARTS) == "Hearts";
        assert suitToString(SPADES) == "Spades";

    }
}

Non la capisco questa classe.
Per me creare una classe che rappresenti una carta da gioco significava definire essenzialmente uno "stampo" che permettesse di creare un oggetto carta assegnandogli un seme e un valore, sotto forma di stringhe e numeri. E basta...
Sono depressa. Di questo passo non imparerò mai...
Forse il trial di Oracle è meno utile di quanto pensassi, perché alcune cose non son spiegate quasi per niente...

Anche quello della soluzione ovviamente è uno "stampo", come praticamente ogni classe, cosa non ti è chiaro?

L'idea proposta nella soluzione è quella di usare un insieme predefinito di costanti per quegli attributi della classe che non possono assumere un valore "qualsiasi", ma solo uno compreso in quell'insieme.

Come si può intuire da quel che c'è scritto sopra la soluzione, essa è in un certo senso un'introduzione ad un argomento successivo, gli enum, che rafforzano questo concetto di "insiemi di costanti", in modo un po' raffinato della brutale definizione di una serie di int.

[Jamie04]

sì sì la storia degli enum l'ho letta, non ci sono ancora arrivata cmq. dimenticali per un attimo

per esempio a che serve questo pezzo di codice?

    public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

e questo è il costruttore che prende 2 interi come argomenti e li assegna ai campi rank e suit, ma l'assert a che serve?

public Card(int rank, int suit) {
        assert isValidRank(rank);
        assert isValidSuit(suit);
        this.rank = rank;
        this.suit = suit;
    }

infine questo non l'ho proprio capito:

    public static String rankToString(int rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }
    
    public static String suitToString(int suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

se il costruttore mi permette di creare un oggetto carta con parametri solo due interi quella roba lì a che serve?

Lo so che stai pensando...datte all'ippica e lo vorrei fare, davvero... se ti può consolare non miro a diventare programmatrice ma devo per forza superare questo esame sennò non posso andare avanti con la mia carriera universitaria

[Kaamos]

Originariamente inviato da Jamie04
sì sì la storia degli enum l'ho letta, non ci sono ancora arrivata cmq. dimenticali per un attimo

per esempio a che serve questo pezzo di codice?

    public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

Beh, ci sono scritte tante cose lì, dovresti essere un po' più specifica... quali parti del codice non ti tornano?
Sono due metodi pubblici di classe (static) che verificano la validità del "numero" della carta nel primo caso e del suo seme nel secondo. Lo scopo è quello di controllare che ai due valori corrispondano effettivamente un numero ed un seme, ed evitare di ritrovarsi con un attributo "seme" pari a 42 che ovviamente non significherebbe nulla.

(fra l'altro, lo scopo principale degli enum è proprio quello di evitare queste svizzerate ed avere un preciso insieme di valori senza dover fare ogni volta controlli e preoccuparsi della validità dei valori)

Originariamente inviato da Jamie04
e questo è il costruttore che prende 2 interi come argomenti e li assegna ai campi rank e suit, ma l'assert a che serve?

public Card(int rank, int suit) {
        assert isValidRank(rank);
        assert isValidSuit(suit);
        this.rank = rank;
        this.suit = suit;
    }

E' scritto nel testo dell'esercizio a cosa servono le asserzioni.

Originariamente inviato da Jamie04
infine questo non l'ho proprio capito:

    public static String rankToString(int rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }
    
    public static String suitToString(int suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

se il costruttore mi permette di creare un oggetto carta con parametri solo due interi quella roba lì a che serve?

Anche qui, cosa non ti è chiaro? Sono due metodi che dato un valori int restituiscono il corrispondente numero (nel primo caso) e seme (nel secondo) sotto forma di stringa, usando il costrutto switch-case, che dovresti già conoscere in quanto già spiegato precedentemente nel tutorial: http://docs.oracle.com/javase/tutori...ts/switch.html

Originariamente inviato da Jamie04
Lo so che stai pensando...datte all'ippica e lo vorrei fare, davvero... se ti può consolare non miro a diventare programmatrice ma devo per forza superare questo esame sennò non posso andare avanti con la mia carriera universitaria

Nessuno è nato imparato.
Basta avere pazienza e metodo di studio... oh, sia chiaro, non è che i tutorial Oracle debbano piacerti per forza, ognuno si trova meglio con diversi tipi di risorse; se vedi che quel metodo non funziona, puoi sempre utilizzare un buon libro.

[Jamie04]

Originariamente inviato da Kaamos
Beh, ci sono scritte tante cose lì, dovresti essere un po' più specifica... quali parti del codice non ti tornano?
Sono due metodi pubblici di classe (static) che verificano la validità del "numero" della carta nel primo caso e del suo seme nel secondo. Lo scopo è quello di controllare che ai due valori corrispondano effettivamente un numero ed un seme, ed evitare di ritrovarsi con un attributo "seme" pari a 42 che ovviamente non significherebbe nulla.

ok, ho fatto la prova ed effettivamente se metto questa:
Card myCard=new Card(88,99);
e abilito gli assert con -ea mi dà un'eccezione.

E' scritto nel testo dell'esercizio a cosa servono le asserzioni.

adesso ho fatto un po' di prove va meglio.
ma ancora non capisco bene questi metodi

 
public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

il return in particolare.

Anche qui, cosa non ti è chiaro? Sono due metodi che dato un valori int restituiscono il corrispondente numero (nel primo caso) e seme (nel secondo) sotto forma di stringa, usando il costrutto switch-case, che dovresti già conoscere in quanto già spiegato precedentemente nel tutorial: http://docs.oracle.com/javase/tutori...ts/switch.html

si conosco switch-case, non mi è chiaro a che serva questa cosa in questo particolare caso.
dato il testo dell'esercizio ritengo si potesse anche omettere...

Nessuno è nato imparato.
Basta avere pazienza e metodo di studio... oh, sia chiaro, non è che i tutorial Oracle debbano piacerti per forza, ognuno si trova meglio con diversi tipi di risorse; se vedi che quel metodo non funziona, puoi sempre utilizzare un buon libro.

Java non mi entra proprio in testa, mi sto deprimendo.
Sono approdata al trial di oracle dopo aver provato a studiare sul mio libro universitario (Programmazione in Java, Bruni Gervasi Corradini) e averlo trovato eccessivamente complicato.

[Kaamos]

Originariamente inviato da Jamie04
ma ancora non capisco bene questi metodi

 
public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

il return in particolare.

E' solo una forma un po' contratta, è equivalente a questo:

if (ACE <= rank && rank <= KING)
    return true;
else
    return false;

che come puoi vedere tu stessa è abbastanza ridondante. Non ha molto senso dire "se quest'espressione risulta vera ritorna vero, se risulta falsa ritorna falso", tanto vale dire "ritorna il valore di quest'espressione".

Originariamente inviato da Jamie04
si conosco switch-case, non mi è chiaro a che serva questa cosa in questo particolare caso.
dato il testo dell'esercizio ritengo si potesse anche omettere...

Beh di certo non è un metodo essenziale per il funzionamento della classe...
Se invece il tuo dubbio è riguardo all'uso del costrutto switch-case beh, l'alternativa sarebbe stata una lunga serie di if-else-if... ma un costrutto del genere è più conciso. O hai idee migliori?

Originariamente inviato da Jamie04
Java non mi entra proprio in testa, mi sto deprimendo.
Sono approdata al trial di oracle dopo aver provato a studiare sul mio libro universitario (Programmazione in Java, Bruni Gervasi Corradini) e averlo trovato eccessivamente complicato.

E' il tuo primo linguaggio di programmazione? Se può consolarti, personalmente non l'ho mai trovato adatto per chi inizia... ed è stato uno dei primi anche per me.

I libri d'informatica cercali in inglese, in generale trovi materiale più valido e senza errori di traduzione.

[Jamie04]

Originariamente inviato da Kaamos
Beh di certo non è un metodo essenziale per il funzionamento della classe...
Se invece il tuo dubbio è riguardo all'uso del costrutto switch-case beh, l'alternativa sarebbe stata una lunga serie di if-else-if... ma un costrutto del genere è più conciso. O hai idee migliori?

proprio no....
ma sì il mio dubbio derivava dal fatto che mi sembrava un'aggiunta abbastanza ridondante.
a volte vado in loop per delle vere stronzate. mi fisso con un'idea e non vedo le altre possibilità...che a volte sono piu' semplici di quanto io riesco a immaginare. invece vado sempre cercando significati nascosti che a volte non ci sono

E' il tuo primo linguaggio di programmazione? Se può consolarti, personalmente non l'ho mai trovato adatto per chi inizia... ed è stato uno dei primi anche per me.

Diciamo che ho avuto un'esperienza del tutto scolastica tipo 15 anni fa con il cobol...quindi in un certo senso è il mio primo linguaggio di programmazione. Ciò che mi deprime tanto è che dimentico facilmente le varie regole. Per esempio avrei un gran bisogno

I libri d'informatica cercali in inglese, in generale trovi materiale più valido e senza errori di traduzione.

Hai qualche titolo da consigliare? Anche se non credo di volerci investire altri soldi, cerco di cavarmela col trial.
Devo fare un progetto per l'esame, una specie di software di gestionale ultra semplificato per una pizzeria, e non so da che parte cominciare...
Non devo fare tutto da sola ma occuparmi di una parte delle classi.

[Kaamos]

Originariamente inviato da Jamie04
Hai qualche titolo da consigliare? Anche se non credo di volerci investire altri soldi, cerco di cavarmela col trial.
Devo fare un progetto per l'esame, una specie di software di gestionale ultra semplificato per una pizzeria, e non so da che parte cominciare...
Non devo fare tutto da sola ma occuparmi di una parte delle classi.

Volendo c'è Thinking in Java di Bruce Eckel, la terza e penultima edizione è disponibile gratuitamente on-line.