Blackjack project / app

[Paul D Pearson]

Trying to use what I've learned so far in terms of OOP in Java to build a fairly simple Blackjack game.  Please keep in mind this is v1 and I will expand into more classes after I have stood this one up.  

Right now I'm focused on my Card class and the setValue() and getValue() methods and how the interact with my Rank enum.  The Client class is merely for testing my current setup.  

I can instantiate a deck, shuffle, and deal a card.  My hand constructor works but right now I can't get the value of the hand once dealt.  Once I'm good with the Card, Rank and value methods I'd like to do the same with my Suit enum so when I deal it shows the symbol rather than HEARTS, SPADES, DIAMONDS, CLUBS.

https://github.com/pauldpearson/Blackjack

package blackjack;

public class Card {
	private Suit suit;
	private Rank rank;
	private int value;


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

	public int getValue() {
		return value;
	}

	public void setValue(Rank rank) {
		value = rank.getCardValue();
	}

	public String toString() {
		return String.format("%s of %s", rank, suit);
	}
}

package blackjack;

import java.util.*;

public class Deck {
	/*
	 * A Deck Collection of our Card class
	 */
	private ArrayList<Card> deck;
	// private Iterator<Card> iterator;

	/*
	 * Constructor to create the deck of cards Generate the cards using enhanced
	 * for loops .values refers to the values of Enum deck.add adds new Card to
	 * the deck using ArrayList method
	 */
	public Deck() {
		deck = new ArrayList<Card>();
		for (Suit s : Suit.values()) {
			for (Rank r : Rank.values()) {
				deck.add(new Card(r, s));
			}
		}
	}

	/*
	 * getDeck method to return our deck
	 */
	public ArrayList<Card> getDeck() {
		return deck;
	}

	/*
	 * Shuffle method using Collections class method
	 */
	public void shuffle() {
		Collections.shuffle(deck);
	}

	/*
	 * Deals the card from the deck then removes that card from the deck
	 */
	public Card dealCard() {
		deck.get(0);
		return deck.remove(0);
	}

	/*
	 * Gives us the Deck size to test the dealCard() method
	 */
	public void deckSize() {
		System.out.println("Deck size: " + deck.size());

	}

	public String toString() {
		return String.format("%s \n", deck);
	}

}

package blackjack;

import java.util.*;

public class Hand {

	private int handValue;
	private ArrayList<Card> hand;
	// private int aceCounter;

	public Hand(Deck deck) {
		hand = new ArrayList<Card>();
		for (int i = 0; i < 2; i++) {
			hand.add(deck.dealCard());
		}
		for (Card card : hand) {
			handValue += card.getValue();
		}
	}

	// not sure if this method is needed, wouldn't hitCard() replace this or
	// accomplish the same thing
	// public void addCard(Card card) {
	// this.hand.add(card);
	// }

	public int getHandValue() {
		return handValue;
	}

	// public int handSize() {
	// return hand.size();
	// }

	public boolean isBlackjack() {
		if (handValue == 21) {
			System.out.println("Blackjack!");
			return true;
		}
		return false;
	}

	// not sure if I want this as a boolean or not...
	public boolean isBusted() {
		if (handValue > 21) {
			return true;
		}
		return false;
	}

	public String toString() {
		return "Hand shows: " + hand + " \nHand value: " + handValue;
	}

}

package blackjack;

public enum Rank {

	// TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING,
	// ACE;

	TWO(2), THREE(3), FOUR(4), FIVE(5), SIX(6), SEVEN(7), EIGHT(8), NINE(9), TEN(10), JACK(10), QUEEN(10), KING(
			10), ACE(11);

	private int cardValue;

	private Rank(int value) {
		this.cardValue = value;
	}

	public int getCardValue() {
		return cardValue;
	}

}

package blackjack;
/*
Enum represents the Suit as a constant and has methods we can call on it
@author Paul Pearson
*/

public enum Suit {
	SPADES("\u2660"), HEARTS("\u2665"), DIAMONDS("\u2666"), CLUBS("\u2663");

	private String icon;

	private Suit(String icon) {
		this.icon = icon;
	}

	public String getIcon() {
		return icon;
	}
}

package blackjack;

public class BlackjackClient {

	public static void main(String[] args) {

		Deck deck3 = new Deck();
		deck3.shuffle();
		Hand hand = new Hand(deck3);
		Hand hand2 = new Hand(deck3);
		System.out.println(hand);
		System.out.println(hand2);
		

	}
}

[Norm Radder]

I can't get the value of the hand once dealt.  

Can you post the print out that shows what you are talking  about?  Add some comments that describe what is wrong and show what you want it to be.

[Fred Kleinschmidt]

Here are a couple of thoughts about your Card class.

Why do you have variables rank and value? They are not independent. A single variable (rank) should be sufficient.

I would not have included a setValue() method. The rank (and therefore value) is fixed at construction time, and should be invariant after that.

You should priobably have a getRank() method.

The getValue() method should return rank.getCardValue(), since the value parameter is extraneous.
And you don't really need a getValue() method, since you could use something like
int value = card.getRank().getValue();

[Junilu Lacar]

Also,  an Ace can take on two values in BlackJack: 1 or 11.  How are you going to represent that logic in your program?

[Junilu Lacar]

A card's value is really more dependent on / dictated by the rules of the particular card game you are playing.  In BlackJack, 10, J, Q, K have the same value but in Poker, they don't. The "value" of a card can also be relative to other cards in a hand. As I already pointed out, an Ace in BlackJack can be either a 1 or 11, depending on what other cards you have.  In Poker, you have a whole bunch of rules for giving a value of a card based on the hand that you have.  An Ace can be a throwaway card, for example, or it could be what gives you a royal flush or a full house.

Remember, an object doesn't have to be a physical thing from the real world, it can also be an abstract idea / collection of related responsibilities such as assigning values to cards in a particular game, like BlackJack or Poker.

[Paul D Pearson]

Here is my print out

Hand shows: [JACK of CLUBS, NINE of SPADES]
Hand value: 0
Hand shows: [KING of SPADES, THREE of HEARTS]
Hand value: 0

[Paul D Pearson]

Norm Radder wrote:

I can't get the value of the hand once dealt.  

Can you post the print out that shows what you are talking  about?  Add some comments that describe what is wrong and show what you want it to be.

I just posted it right about this.  Still learning how to use the Saloon.

[Paul D Pearson]

Junilu Lacar wrote:Also,  an Ace can take on two values in BlackJack: 1 or 11.  How are you going to represent that logic in your program?

I meant to put that in my original post.  For v1 I'm designating an Ace to only represent 11.  I will eventually have AceClass extend Card.

[Paul D Pearson]

Fred Kleinschmidt wrote:Here are a couple of thoughts about your Card class.

Why do you have variables rank and value? They are not independent. A single variable (rank) should be sufficient.

I would not have included a setValue() method. The rank (and therefore value) is fixed at construction time, and should be invariant after that.

You should priobably have a getRank() method.

The getValue() method should return rank.getCardValue(), since the value parameter is extraneous.
And you don't really need a getValue() method, since you could use something like
int value = card.getRank().getValue();

re: single variable (rank)  noted and I have removed
re: setValue()  I removed and that seems to make sense
re: getRank()  I have added that

re: getValue()  you give me the return and say don't really need it?  That causes some confusion, can you elaborate please?
re: int value = ...   Where would that go?

It seems I don't need that variable as...IT IS NOW WORKING!!!  

public class Card {
	private Suit suit;
	private Rank rank;
	//int value;

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

	public int getValue() {
		return rank.getCardValue();
	}

//	public void setValue(Rank rank) {
//		value = rank.getCardValue();
//	}

	public String toString() {
		return String.format("%s of %s", rank, suit);
	}
}

Hand shows: [THREE of HEARTS, KING of DIAMONDS]
Hand value: 13
Hand shows: [SEVEN of HEARTS, EIGHT of SPADES]
Hand value: 15

[Junilu Lacar]

Paul D Pearson wrote:For v1 I'm designating an Ace to only represent 11.  I will eventually have AceClass extend Card.

That's not a good design. Object-orientation is about behaviors and responsibility. IMO, inheritance is not the proper mechanism to use to represent the logic/responsibility of determining the variable value of an Ace.

[Junilu Lacar]

The General Responsibility Assignment Software Principles/Patterns (GRASP) will come into play here, in particular, Information Expert. Which class would have all the context/information needed to determine when an Ace should be valued as 1 or 11? That's where you should assign the responsibility.  In your proposed design where a AceCard extends Card, an AceCard object still would not (and should not) have the context it needs to determine whether it should have a 1 or 11 value. If you had a "Hand" class, however, specifically a "BlackJackHand", then it would have all the information it needs to determine what the value of an Ace should be, given that it knows what the other cards are in the hand.

[Paul D Pearson]

Junilu Lacar wrote:The General Responsibility Assignment Software Principles/Patterns (GRASP) will come into play here, in particular, Information Expert. Which class would have all the context/information needed to determine when an Ace should be valued as 1 or 11? That's where you should assign the responsibility.  In your proposed design where a AceCard extends Card, an AceCard object still would not (and should not) have the context it needs to determine whether it should have a 1 or 11 value. If you had a "Hand" class, however, specifically a "BlackJackHand", then it would have all the information it needs to determine what the value of an Ace should be, given that it knows what the other cards are in the hand.

That makes sense and I like that better than the AceCard class extending Card.  I do have a Hand class currently and will eventually modify it to hold the hard and soft value of an Ace.  
Thanks for the help and suggestions!