Salut Lo Jeu De Cartes En Java

Je dois donc coder un programme de jeu de cartes HiLo en java et voici les instructions sur son fonctionnement:

Il y a deux classes de cartes et de Deck

La classe Card contient 2 variables privées int suit et int faceValue Un Constructeur qui prend les 2 variables comme paramètres comme ceci:

• Carte (int suit, int faceValue)
• Getters - > getSuit: int et getFaceValue: int
• A compareTo(carte carte): méthode int
• A toString():Chaîne méthode

La classe Deck contient une variable aléatoire privée de type aléatoire privé aléatoire : Aléatoire A plate forme de constructeur sans paramètre() Une méthode de transaction qui ne prend aucun paramètre et de type carte

La classe Card a une couleur qui est un chiffre de 0 à 3 qui représente la couleur d'une carte: - 0 représente Spades (qui est le costume le mieux classé) - 1 représente les cœurs (le deuxième costume le plus élevé) - 2 représente des diamants (le troisième costume le plus élevé) - 3 représente les clubs (le combinaison la plus faible)

Le faceValue est une valeur comprise entre 1 et 13; 1 représente l'As, 11 est le Valet, 12 est la Reine et 13 est le Roi.

La méthode compareTo compare l'instance actuelle (c'est-à-dire this) avec la carte de paramètres. Si les deux objets ont les mêmes suit et faceValue, la méthode renvoie 0. Si l'instance actuelle est plus élevée (valeur plus élevée, ou si elles ont la même valeur, couleur plus élevée), la méthode renvoie une valeur positive (elle peut être +1 ou toute autre valeur positive depuis la magnitude n'est pas important, seulement le signe). Si l'instance en cours est inférieure, renvoyez une valeur négative.

La méthode toString renvoie une représentation en chaîne de la carte (par exemple, "As de Pique", "2 de Cœur")

La classe Deck a une instance de type Random qu'elle utilise lorsque instancier et distribuer une nouvelle carte.

Coder maintenant une classe d'application appelée HiLoApp qui: - instancier un objet Deck - traiter et afficher la première carte - demander à l'utilisateur de choisir -1 si ils pensez que la carte suivante sera plus basse, +1 si la carte suivante sera plus haute, ou 0 pour quitter le jeu o distribuez et affichez la carte suivante o indiquer si l'utilisateur a choisi correctement o compter le nombre de tentatives et corriger les suppositions

La méthode principale consiste à effectuer ces étapes en continu jusqu'à ce que l'utilisateur entre 0 pour quitter le jeu. À ce stade, affichez le nombre total de tentatives et de suppositions correctes faites par l'utilisateur.

Classe de carte:

public class Card
{
    private int suit;
    private int faceValue;

    //Constructor 
    public Card(int suit, int faceValue)
    {
        this.suit = suits; 
        this.faceValue = faceValue;

        card = deal(); //???

    }
    public int getSuit()
    {   
        return suit;
    }
    public int getFaceValue()
    {
        return faceValue;
    }
    public int compareTo(Card card)
    {

    }
    public String toString 
    {
        String cardName = null;

        switch (faceValue)
        {
            case 2:
            cardName = "Two";
            break;

            case 3:
            cardName = "Three";
            break; 

            case 4:
            cardName = "Four";
            break;

            case 5:
            cardName = "Five";
            break;

            case 6:
            cardName = "Six";
            break;

            case 7:
            cardName = "Seven";
            break;

            case 8:
            cardName = "Eight";
            break;

            case 9:
            cardName = "Nine";
            break; 

            case 10: 
            cardName = "Ten";
            break;

            case 1: 
            cardName = "Ace";
            break; 

            case 11: 
            cardName = "Jack";
            break;

            case 12:
            cardName = "Queen";
            break; 

            case 13: 
            cardName = "King";
            break; 

        }
        switch (suit)
        { 

            case 0:
            cardName += "Of Spades";
            break; 

            case 1: 
            cardName += "Of Hearts";
            break; 

            case 2:
            cardName += "Of Diamonds";
            break;

            case 3:
            cardName += "Of Clubs";
            break; 
        }

        return cardName;
    }
}

Le Pont Classe:

import java.util.Random;

public class Deck 
{
    private Random random;

    public Deck()
    {
        random = 0;
    }
    public Card deal()
    {
        while (num != 0)
        {
            random = new Random();

            suit = random.nextInt(3);
            faceValue = random.nextInt(13) + 1;

        }

        return //how to return suit and faceValue at the same time?

    }
}

Classe d'application:

import java.util.Random;
import java.util.Scanner; 

public class HiLo
{
    public static void main(String [] args)
    {
        //to quit the game 
        int num;

        //getting input from user
        Scanner keyboard = new Scanner(System.in);

        Deck deck1 = new Deck();

        = deck1.deal()
    }
}

Mes questions sont: Je ne comprends pas d'où vient le paramètre card dans la méthode compareTo. Aussi la raison pour laquelle je ne suis pas en mesure de coder complètement le programme est parce que je ne comprends pas comment cela fonctionne exactement. Où se passe la distribution initiale de la première carte? La classe card a-t-elle accès à la classe Deck afin d'utiliser la méthode deal? Je vois que la méthode deal renvoie un type de classe Card mais comment puis je retourner le costume et le facevaluer en même temps?