Java - Making a card game, have questions about classes

Learn java - making a card game, have questions about classes with practical examples, diagrams, and best practices. Covers java development techniques with visual explanations.
Tags:
Categories:

Designing a Java Card Game: Mastering Classes and Object-Oriented Principles

Hero image for Java - Making a card game, have questions about classes

Explore the fundamental concepts of object-oriented programming in Java to build a robust and scalable card game. Learn how to structure your game with classes for cards, decks, players, and game logic.

Developing a card game in Java is an excellent way to solidify your understanding of object-oriented programming (OOP) principles. The nature of card games—with distinct entities like cards, decks, and players, each having their own properties and behaviors—lends itself perfectly to class-based design. This article will guide you through the essential classes you'll need, how they interact, and best practices for structuring your Java card game.

Core Game Entities: Cards, Decks, and Players

At the heart of any card game are the cards themselves, the deck they come from, and the players who interact with them. Each of these can be represented by a distinct class, encapsulating their unique attributes and actions. Thinking about these as real-world objects helps in defining their responsibilities.

classDiagram
    class Card {
        -Suit suit
        -Rank rank
        +Card(Suit, Rank)
        +getSuit(): Suit
        +getRank(): Rank
        +toString(): String
    }
    class Deck {
        -List<Card> cards
        +Deck()
        +shuffle(): void
        +dealCard(): Card
        +isEmpty(): boolean
    }
    class Player {
        -String name
        -List<Card> hand
        +Player(String)
        +addCardToHand(Card): void
        +playCard(Card): Card
        +getHand(): List<Card>
        +getScore(): int
    }
    Card <|-- Suit
    Card <|-- Rank
    Deck "1" -- "*" Card : contains
    Player "1" -- "*" Card : holds

UML Class Diagram for basic card game entities

Let's break down the responsibilities of each core class:

The Card Class

The Card class is perhaps the most fundamental. Each card has a Suit (e.g., Hearts, Diamonds, Clubs, Spades) and a Rank (e.g., Ace, 2, 3, ..., King). These are best represented as enum types to ensure a fixed set of valid values and improve readability. The Card class should be immutable, meaning once a card is created, its suit and rank cannot change.

public enum Suit {
    HEARTS, DIAMONDS, CLUBS, SPADES
}

public enum Rank {
    TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE
}

public class Card {
    private final Suit suit;
    private final Rank rank;

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

    public Suit getSuit() {
        return suit;
    }

    public Rank getRank() {
        return rank;
    }

    @Override
    public String toString() {
        return rank + " of " + suit;
    }

    // Optional: Implement equals() and hashCode() for proper comparison
}

Basic Card class with Suit and Rank enums

The Deck Class

The Deck class manages a collection of Card objects. Its primary responsibilities include initializing a standard 52-card deck, shuffling the cards, and dealing cards one by one. A List<Card> is a suitable data structure to hold the cards, allowing for easy manipulation like shuffling and removal.

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

public class Deck {
    private List<Card> cards;

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

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

    public Card dealCard() {
        if (cards.isEmpty()) {
            return null; // Or throw an exception if deck is empty
        }
        return cards.remove(0);
    }

    public boolean isEmpty() {
        return cards.isEmpty();
    }

    public int size() {
        return cards.size();
    }
}

Implementation of the Deck class

The Player Class

The Player class represents an individual participant in the game. Each player will have a name and a hand of cards. Methods for adding cards to their hand, playing a card, and potentially calculating their score are essential. The Player class should manage its own hand, typically another List<Card>.

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

public class Player {
    private String name;
    private List<Card> hand;

    public Player(String name) {
        this.name = name;
        this.hand = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

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

    public Card playCard(Card cardToPlay) {
        if (hand.remove(cardToPlay)) {
            return cardToPlay;
        }
        return null; // Card not in hand
    }

    public List<Card> getHand() {
        return new ArrayList<>(hand); // Return a copy to prevent external modification
    }

    public int getHandSize() {
        return hand.size();
    }

    // Example: A simple scoring method (e.g., sum of ranks)
    public int getScore() {
        int score = 0;
        for (Card card : hand) {
            score += card.getRank().ordinal() + 2; // Assuming TWO is 0, THREE is 1, etc.
        }
        return score;
    }

    @Override
    public String toString() {
        return name + "'s hand: " + hand;
    }
}

Basic Player class with hand management

Putting It All Together: The Game Class

Finally, you'll need a Game class (e.g., CardGame, BlackjackGame, PokerGame) to orchestrate the entire game flow. This class will manage the Deck, the Players, and the overall game state. It will contain the main game loop, handle turns, determine winners, and enforce game rules.

flowchart TD
    A[Start Game] --> B{Initialize Deck & Players}
    B --> C[Shuffle Deck]
    C --> D[Deal Initial Cards]
    D --> E{Game Loop: Player Turns}
    E -- Player plays card --> F[Apply Game Rules]
    F -- Update game state --> G{Is Game Over?}
    G -- No --> E
    G -- Yes --> H[Determine Winner]
    H --> I[End Game]

High-level game flow for a typical card game

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

public class CardGame {
    private Deck deck;
    private List<Player> players;
    private int currentPlayerIndex;

    public CardGame(String... playerNames) {
        deck = new Deck();
        players = new ArrayList<>();
        for (String name : playerNames) {
            players.add(new Player(name));
        }
        currentPlayerIndex = 0;
    }

    public void setupGame(int initialCardsPerPlayer) {
        deck.shuffle();
        for (int i = 0; i < initialCardsPerPlayer; i++) {
            for (Player player : players) {
                if (!deck.isEmpty()) {
                    player.addCardToHand(deck.dealCard());
                }
            }
        }
    }

    public void startGame() {
        System.out.println("\n--- Game Start ---");
        // Example game loop (simplified)
        while (!isGameOver()) {
            Player currentPlayer = players.get(currentPlayerIndex);
            System.out.println("\n" + currentPlayer.getName() + "'s turn. Hand: " + currentPlayer.getHand());

            // Simplified: Player just plays the first card in their hand
            if (!currentPlayer.getHand().isEmpty()) {
                Card playedCard = currentPlayer.playCard(currentPlayer.getHand().get(0));
                System.out.println(currentPlayer.getName() + " played: " + playedCard);
                // Add game logic here to process the played card
            } else {
                System.out.println(currentPlayer.getName() + " has no cards left!");
            }

            // Move to next player
            currentPlayerIndex = (currentPlayerIndex + 1) % players.size();

            // A simple condition to end the game for demonstration
            if (deck.isEmpty() && players.stream().allMatch(p -> p.getHandSize() == 0)) {
                break;
            }
        }
        System.out.println("\n--- Game Over ---");
        determineWinner();
    }

    private boolean isGameOver() {
        // Define game over conditions (e.g., deck empty, one player out of cards)
        return false; // Placeholder
    }

    private void determineWinner() {
        System.out.println("Determining winner...");
        // Implement logic to find the winner based on game rules
        Player winner = players.get(0); // Simplified: first player wins
        System.out.println("The winner is: " + winner.getName() + " with score: " + winner.getScore());
    }

    public static void main(String[] args) {
        CardGame game = new CardGame("Alice", "Bob");
        game.setupGame(5); // Deal 5 cards to each player
        game.startGame();
    }
}

A simplified CardGame class demonstrating game flow