public enum Suit
{
CLUBS,
HEARTS,
SPADES,
DIAMONDS
}
public enum Value
{
TWO,
THREE,
FOUR,
FIVE,
SIX,
SEVEN,
EIGHT,
NINE,
TEN,
JACK,
QUEEN,
KING,
ACE
}
Card.java
public class Card {
private Suit suit;
private Value value;
public Card(Suit theSuit, Value theValue)
{
suit = theSuit;
value = theValue;
}
public String toString()
{
return value + " of " + suit;
}
public Value getValue()
{
return value;
}
public Suit getSuit()
{
return suit;
}
public boolean equals(Card other)
{
if (value.ordinal() == other.value.ordinal()
|| suit.ordinal() == other.suit.ordinal())
{
return true;
}
else {
return false;
}
}
}
CardPile.java
public class CardPile
{
public Card[] cards;
private int numCards;
public CardPile()
{
this.cards = new Card[52];
this.numCards = 0;
// The problem is here, when I try to iterate through the enums and the
// array to populate my cards[] of 52 objects Card it populates it with
// 52 Card which are all ACE of DIAMONDS, it looks like the triple loops
// populates 52 times the two last elements of my enum, but I can't
// figure out how to fix that! Thanks in advance!
for (Suit s : Suit.values())
{
for (Value v : Value.values())
{
for (int π = 0; π < cards.length; π++)
{
cards[π] = new Card(s, v);
}
}
}
}
public boolean isEmpty()
{
for (int i = 0; i < cards.length; i++)
{
if (cards[i] != null)
{
return false;
}
}
return true;
}
public int getNumCards()
{
return numCards;
}
}
The problem is here:
for (int π = 0; π < cards.length; π++) {
cards[π] = new Card(s, v);
}
You're using the same s and v variables to create your Card instance and assign it to all the elements in the cards array, replacing every value on every (s, v) pair combination.
Change the code in order to fill it using just the first 2 for-loops:
int count = 0;
for (Suit s : Suit.values()) {
for (Value v : Value.values()) {
if (count < cards.length) {
cards[count++] = new Card(s, v);
}
}
}
By the way, you should not use names as π for variables and make sure to indent your code.
For every suite and value you iterate over all the 52 cards and set them to be that suit and value. As the last suit/value pair is DIAMOND and ACE, that's what all the cards end up as in the end.
If you get rid of the loop using π, and instead just do:
int counter = 0;
for (Suit s : Suit.values())
{
for (Value v : Value.values())
{
cards[counter++] = new Card(s, v);
}
}
Then I think that should work.
Related
I am currently working on a CS project that classifies player's hands. I solved the first half of the project to print out the deck, shuffled deck and the hands of player1, player2 and remaining deck. The problem comes up when I have to evaluate the hands. My code has to somehow evaluate which classification the hands are, and print out whether player1 or player2 wins. I have three classes so far:
public class Card {
static String[] card_suit = {"hearts", "diamonds", "clubs", "spades"};
static int[] card_rank = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};// 11 is Jack, 12 is Queen, 13 is King and 14 is Ace
public int[] getRank() {
return card_rank;
}
public String[] getSuit() {
return card_suit;
}
}
public class Driver {
public static void main(String[] args) {
Card card = new Card();
Deck deck = new Deck();
deck.getDeck();
System.out.print("ORIGINAL DECK: ");
deck.printDeck();
deck.shuffleDeck();
System.out.print("SHUFFLED DECK: ");
deck.printDeck();
System.out.println();
System.out.print("PLAYER ONE: ");
System.out.println(java.util.Arrays.toString(deck.playerOneHands()));
System.out.print("PLAYER TWO: ");
System.out.println(java.util.Arrays.toString(deck.playerTwoHands()));
System.out.print("REMAINING DECK: ");
System.out.println(java.util.Arrays.toString(deck.remainingDeckCards()));
}
}
import java.util.Arrays;
import java.util.Collections;
public class Deck extends Card {
Card card = new Card();
private String[] deck_card = new String[52];
public String[] getDeck() {
int i = 0;
for(int s = 0; s < 4; s++) {
for(int r = 0; r < 13; r++) {
deck_card[i]=(card_suit[s] + " of " + card_rank[r]);
i++;
}
}
return deck_card;
}
public void printDeck() {
System.out.println (java.util.Arrays.toString (deck_card));
}
public void shuffleDeck() {
Collections.shuffle(Arrays.asList(deck_card));
}
public String[] playerOneHands() {
String [] firsthand = new String[5];
for(int a = 0; a < 5; a++) {
firsthand[a] = deck_card[a];
}
return firsthand;
}
public String[] playerTwoHands() {
String[] secondhand = new String[5];
for(int a = 0; a < 5; a++) {
secondhand[a] = deck_card[a+5];
}
return secondhand;
}
public String[] remainingDeckCards() {
String[] remainDeck = new String[42];
for(int a = 0; a < 42; a++){
remainDeck[a] = deck_card[a+10];
}
return remainDeck;
}
}
What I thought it would work is because the Deck class extends from the Card class, I can use the getRank method to compare each hand, but I am not sure how to construct the conditionals.
Any help is greatly appreciated. Thanks.
For modelling the game, first identify entities like Card, Deck etc. (which mostly you have done). I would add few more like Player, Evaluator(explained below) etc.
Rank and Suit are NOT string/ int but they are predefined (not going to change in life time of game) possible variations in Cards. Always use domain vocabulary for best model. Each Card belongs to one Suit and one Rank. (think of making Rank and Suit as enums, this will avoid unknown values breaking the code at run time.
Not giving set method for suite and rank in Card is essential (they form an identity of Card in combination)
Full Deck (at initialization) is formed by cross product of Suit and Rank. Meaning Deck has (contains) multiple cards. Remember Card can be alive outside of Deck (when in players hand) as well, hence its not composition. Inheriting Deck from Card is absolutely wrong. It translates to statement Deck is a kind of Card, which is not correct. Deck will have collection of Cards. Using inheritance, will lead to violation of Liskov's Substitution Principle (One of the SOLID).
To model Deck, consider the fact that Deck does not contain duplicate cards, Deck does not change its order once formed (unless shuffled). This being tricky selection between Set and List, I would go for List with added programmatic constraint for avoiding duplicates (needs to be done only when initialization).
But instead of Modelling Deck as java collection, it will be best to let class Deck contain java collection of suitable choice and Deck class work as wrapper by defining required API (from domain perspective) like shuffle, getTopCard() etc. This is called as Object Adapter design pattern. This makes our design platform (implementation) independent.
You need to model few more classes like Player holds CardInHand etc.
About evaluating Cards in hand, its better to model it as separate class as its different concern and rules can change independent of other classes.
Poker game is best assignment to learn Object Oriented Programming.
Without wanting to do your homework for you...
This is a problem:
class Deck extends Card
A deck isn’t a subtype of a card. A deck has cards, so:
class Deck {
List<Card> cards;
}
is a better choice.
Also, the following code does nothing to the deck:
public void shuffleDeck() {
Collections.shuffle(Arrays.asList(deck_card));
}
It shuffles a copy of the deck, leaving the deck untouched.
Also, you shouldn’t be building strings in a loop. Instead, implement (override) a toString() method on Card and Deck.
Also, make suit an enum.
Also, delete card_rank entirely - it serves no purpose. Instead, add a int rank; field to Card, or better make rank an enum.
Fix these things first, then re-attack the problem by writing a method that is passed a Hand (a new class) that has a List and a method that returns a HandType (another enum) by evaluating if the hand is a straight flush, else four of a kind, else ... all the way down to high card - highest to lowest.
It seems that you class Card only has static fields; I would change it so that an instance of Card would represent a single card from a Deck. I would also make the suites an enum type. You can also add integer constants for the figures and aces. The class can implement Comparable<Card>:
public class Card implements Comparable<Card> {
public enum Suite {CLUBS, DIAMONDS, HEARTS, SPADES};
public static final int JACK = 11;
public static final int QUEEN = 12;
public static final int KING = 13;
public static final int ACE = 14;
public final Suite suite;
public final int rank;
public Card(Suite suite, int rank) {
if (suite == null) {
throw new IllegalArgumentException("Suite cannot be null");
}
if (rank < 2 || rank > 14) {
throw new IllegalArgumentException(
"Value must be between 2 and 14");
}
this.suite = suite;
this.rank = rank;
}
public Suite getSuite() {
return suite;
}
public int getRank() {
return rank;
}
#Override
public String toString() {
StringBuilder buf = new StringBuilder();
if (rank >= 2 && rank <= 10) {
buf.append(rank);
} else {
switch (rank) {
case JACK:
buf.append("jack");
break;
case QUEEN:
buf.append("queen");
break;
case KING:
buf.append("king");
break;
case ACE:
buf.append("ace");
break;
}
}
buf.append(" of ");
buf.append(suite.toString().toLowerCase());
return buf.toString();
}
#Override
public int compareTo(Card other) {
if (rank > other.rank) {
return 1;
} else if (rank < other.rank) {
return -1;
} else {
return suite.compareTo(other.suite);
}
}
}
Note that you could also have two subclasses of Card: one for the numbers and one for the figures.
The Deck is a collection of 52 cards. It is initialised by adding each card to a list. One can shuffle a deck, or take a card from the deck:
public class Deck {
private final List<Card> cards = new ArrayList<>();
public Deck() {
for (Card.Suite suite: Card.Suite.values()) {
for (int i = 2; i <= 14; ++i) {
cards.add(new Card(suite,i));
}
}
}
public void shuffle() {
Collections.shuffle(cards);
}
public boolean isEmpty() {
return cards.isEmpty();
}
public Card take() {
if (cards.isEmpty()) {
throw new IllegalStateException("Deck is empty");
}
return cards.remove(0);
}
}
You can take shuffle and take 5 cards from the deck like this:
Deck deck = new Deck();
deck.shuffle();
for (int i = 0; i < 5; ++i) {
Card card = deck.take();
System.out.println(card);
}
Now a Hand is a set of five cards taken from a Deck. We can declare Hand as implementing Comparable<Hand> so that we can know which of two hands have the highest value:
public class Hand implements Comparable<Hand> {
private final Card[] cards = new Card[5];
public Hand(Deck deck) {
for (int i = 0; i < 5; ++i) {
cards[i] = deck.take();
}
Arrays.sort(cards);
}
#Override
public int compareTo(Hand other) {
...
}
}
Now here comes the fun part: you must identify the hand type as one of the following (enum type):
public enum HandType {
SINGLE, PAIR, TWO_PAIRS, THREE, STRAIGHT, FLUSH, FULL_HOUSE, FOUR,
STRAIGHT_FLUSH, ROYAL_FLUSH;
}
Note that the constants are arranged from the lowest to the highest. In addition, the cards must be arranges so that in case of a tie, you can compare the cards to identify the winner.
I would suggest you make groups of cards of same rank; in the case where you have five different groups, it still can be a flush or a straight.
Another approach would consist in declaring a subclass of Hand for each HandType, but I don't think you would gain much by doing this.
public class Hand implements Comparable<Hand> {
public enum HandType {
SINGLE, PAIR, TWO_PAIRS, THREE, STRAIGHT, FLUSH, FULL_HOUSE, FOUR,
STRAIGHT_FLUSH, ROYAL_FLUSH;
}
private final Card[] cards = new Card[5];
private final int[] groupSize;
private final HandType type;
public Hand(Deck deck) {
for (int i = 0; i < 5; ++i) {
cards[i] = deck.take();
}
groupSize = group(cards);
type = identifyType(groupSize, cards);
}
#Override
public int compareTo(Hand other) {
int r = type.compareTo(other.type);
if (r != 0) {
return r;
}
for (int i = cards.length; --i >= 0; ) {
int r1 = cards[i].getRank();
int r2 = other.cards[i].getRank();
if (r1 < r2) {
return -1;
} else if (r1 > r2) {
return 1;
}
}
return 0;
}
#Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(type);
buf.append(": ");
buf.append(cards[0]);
for (int i = 1; i < 5; ++i) {
buf.append(", ");
buf.append(cards[i]);
}
return buf.toString();
}
private static int[] group(Card[] cards) {
Arrays.sort(cards);
List<List<Card>> groups = new ArrayList<>();
int val = -1; // invalid rank
List<Card> currentGroup = null;
for (Card card: cards) {
if (val == card.getRank()) {
currentGroup.add(card);
} else {
if (currentGroup != null) {
groups.add(currentGroup);
}
currentGroup = new ArrayList<>();
currentGroup.add(card);
val = card.getRank();
}
}
if (currentGroup != null) {
groups.add(currentGroup);
}
// identify groups of cards of same value
// sort groups by size and highest card
Collections.sort(groups, (List<Card> group1, List<Card> group2) -> {
int s1 = group1.size();
int s2 = group2.size();
if (s1 < s2) {
return -1;
} else if (s1 > s2) {
return 1;
} else {
return group1.get(s1-1).compareTo(group2.get(s2-1));
}
});
int[] groupSize = new int[groups.size()];
int g = 0;
int i = 0;
for (List<Card> group: groups) {
groupSize[g++] = group.size();
for (Card card: group) {
cards[i++] = card;
}
}
assert sum(groupSize) == 5;
return groupSize;
}
private static HandType identifyType(int[] groupSize, Card[] cards) {
switch (groupSize.length) {
case 2:
// can be a full house or four cards
if (groupSize[0] == 1) {
return HandType.FOUR;
} else if (groupSize[0] == 2) {
return HandType.FULL_HOUSE;
} else {
assert false;
return null;
}
case 3:
if (groupSize[0] == 1) {
// three cards or double pair
if (groupSize[1] == 1) {
return HandType.THREE;
} else {
assert groupSize[1] == 2 && groupSize[2] == 2;
return HandType.TWO_PAIRS;
}
} else {
assert false;
return null;
}
case 4:
// one pair
return HandType.PAIR;
case 5:
// all different values: check for flush
Card prev = cards[0];
boolean sameSuite = true;
boolean straight = true;
for (int i = 1; i < 5; ++i) {
Card card = cards[i];
straight &= card.getRank() == prev.getRank()+1;
sameSuite &= card.getSuite() == prev.getSuite();
}
if (sameSuite) {
if (straight) {
if (cards[4].getRank() == Card.ACE) {
return HandType.ROYAL_FLUSH;
}
return HandType.STRAIGHT_FLUSH;
} else {
return HandType.FLUSH;
}
} else {
if (straight) {
return HandType.STRAIGHT;
} else {
return HandType.SINGLE;
}
}
default:
assert false;
return null;
}
}
private static int sum(int[] groupSize) {
int sum = 0;
for (int s: groupSize) {
sum += s;
}
return sum;
}
}
This question already has answers here:
What is a NullPointerException, and how do I fix it?
(12 answers)
Closed 4 years ago.
I have to create 3 class (Card, Deck and Tester) to play a game of card. The rules are easy, just compare two cards randomly from the deck and whichever one is higher is the winner. It runs for the entire deck.
Here's my card class (I exclude my comments)
public class Card {
private int value;
private String suit;
public Card(){
value =1;
suit = "clubs";
}
public Card(int n, String s) {
n = value;
s = suit;
}
public int getValue() {
return value;
}
public void setValue(int n) {
if ((n >0) && (n<14)) {
n = value;
}
else {
return;
}
}
public String getSuit() {
return suit; // return the string
}
public void setSuit(String s) {
if ((s.equals("clubs") || (s.equals("hearts") || (s.equals("diamonds") || (s.equals("spades")))))){
s = suit;
}
else {
return;
}
}
public int rank() {
int rank=0;
int suitVal=0;
if (suit.equals("clubs")) {
suitVal =1;
}
else if(suit.equals("diamonds")) {
suitVal =2;
}
else if(suit.equals("hearts")) {
suitVal =3;
}
else if(suit.equals("spades")) {
suitVal =4;
}
rank= (4*(value-1)) + suitVal;
return rank;
}
}
Deck class:
import java.util.ArrayList;
public class Deck {
int[] value= {1,2,3,4,5,6,7,8,9,10,11,12,13};
String[] suit= {"clubs", "diamonds", "hearts", "spades"};
public ArrayList<Card> card = new ArrayList<Card>();
public Deck() { // make default constructor
for (int a=0; a< value.length; a++) {
for (int b=0; b< suit.length ; b++){
card.add(new Card(value[a], suit[b]));
}
}
}
public Card drawCard() {
int number = (int) Math.random()* (card.size());
Card temp = card.get(number);
card.remove(number);
return temp;
}
Tester:
public class Tester {
public static void main(String[] args) {
Deck deck1 = new Deck();
Card x = deck1.drawCard();
Card y = deck1.drawCard();
int point1=0;
int point2=0;
int player=x.rank();
int comp=y.rank();
for (int i=0; i<52; i++) {
if (player > comp) {
point1++;
}
else {
point2++;
}
}
if (point1 > point2) {
System.out.println("Player is the winner");
}
if (point1 < point2) {
System.out.println("Computer is the winner");
}
}
When I run it it says "Null pointer Exception" and point at line 42 of Card class and line 14 of Tester class. Please help
In the card class,the assignment in parmeterized constructor is wrong, you have the parameters as n and s and this value you should assign to value and suit. But you are doing other way,
public Card(int n, String s) {
n = value;
s = suit;
}
Instead of that, you should assign the values of the parameter to value and suit, something like this.
public Card(int n, String s) {
value = n;
suit = s;
}
This is the reason the value and suit is default all the time, you never changed it.
hello and welcome to SO #Elvin.
As mentioned in the comments the NPE is telling you where the problem occurs.
Your "suits" in if (suit.equals("clubs")) is null.
The problem is in your card constructor method:
public Card(int n, String s) {
n = value;
s = suit;
}
you have it the oposite way, it should be because your attributes are value and suit, so you should "store" the new values in them:
public Card(int n, String s) {
value = n;
suit = s;
}
You seem to be new, try to understand always the message of the error and of course, debug ;)
I am trying to make a basic outline for a card game, I have the deck created, a method created for dealing a random card but I am having difficulty for adding the card into the actual hand. The issue is in the Game class with the getCard() method. I do not know the correct way to do this, since my idea did not work.
Class to create the deck:
import java.util.Random;
public class Deck<E> {
//create a new linked list for Deck
LinkedPositionalList deck = new LinkedPositionalList();
public Deck(){
for (int i = 0; i < 4; i++){
for(int j = 2; j< 14; j++){
Card card = new Card(i,j);
deck.addLast(card); //add to linked list
}
}
}
public Card card(){
Random rand = new Random();
int position = rand.nextInt(52);//create random number 0-52
int counter = 0;
Iterator<Card> iter = this.deck.iterator();
while(counter <= position){
Card card = iter.next();
if(counter == position){
iter.remove();
return card;
}
counter++;
}
return null;
}
}
Class to create the card:
public class Card<E> {
public final static int CLUBS = 0,
SPADES = 1,
DIAMONDS = 2,
HEARTS = 3;
private final static String [] suitNames = {"CLUBS", "SPADES", "DIAMONDS", "HEARTS"};
// Special cards
private int JACK_VALUE = 11;
private int QUEEN_VALUE = 12;
private int KING_VALUE = 13;
private int ACE_VALUE = 14;
// The card
private int suit = 0; // Suit of the card
private int value = 2; // Value of the card
public int getSuit() {
return this.suit;
}
public int getValue() {
return this.value;
}
public Card(int suit, int value ){
this.suit = suit;
this.value = value;
}
public String suitToString() {
return suitNames[ suit ];
}
public String valueToString() {
if (value == ACE_VALUE) {
return "ACE";
} else if (value == JACK_VALUE) {
return "JACK";
} else if (value == QUEEN_VALUE) {
return "QUEEN";
} else if (value == KING_VALUE) {
return "KING";
} else if ( value > 0 ) {
return String.valueOf(value);
}
return "";
}
public String shortValueToString() {
if (value == ACE_VALUE) {
return " A";
} else if (value == JACK_VALUE) {
return " J";
} else if (value == QUEEN_VALUE) {
return " Q";
} else if (value == KING_VALUE) {
return " K";
} else if ( value > 0 ) {
return String.format("%2d",value);
}
return "";
}
public String toString() {
return valueToString() + " of " + suitToString();
}
public String toShortString() {
return shortValueToString() + suitToString().substring(0,1);
}
public boolean equalTo(Card c ) {
if ( c.getSuit() != this.getSuit()) return false;
if ( c.getValue() != this.getValue()) return false;
return true;
}
}
Class to create the hand:
public class CardHand<E> {
LinkedPositionalList<E> hand = new LinkedPositionalList();
//TODO: create method to order hand
}
Class to initialize the game:
public class Game{
int players;
int maxCardsInHand;
int decks;
CardHand[] hand;
Card card;
Deck deck;
//constructor
public Game(int player, int max, int numDecks){
players = player;
maxCardsInHand = max;
decks = numDecks;
this.hand = new CardHand[player];
for(int index = 0; index < hand.length; index++){
this.hand[index] = new CardHand();
}
}
public void getCard(){
System.out.println("You got this far...");
card = deck.card();
for(int index = 0; index < hand.length; index++){ //to add to each players hands
hand[index] = card; //issues with this part
}
//TODO: ordered correctly by suit AND value
}
Given that the call iter.remove(); works, your deck gets smaller and smaller each time you call the card() method. Yet you assume you can iterate thru a full deck:
rand.nextInt(52);
Instead, iterate only over the cards you have left:
rand.nextInt(this.deck.size());
If there is no size() or length() method for the list object, decrease a counter each time card() is called:
rand.nextInt(cardsInDeck++);
i seem to be having a problem with my deck class iterating through the Suits array.
Card class:
//David Diienno
//Lab 01
import java.util.Arrays;
public class Card {
private String m_rank; // card rank: a number between 2 and 10, or Jack, Queen, King or Ace
private char m_suit; // card suit: S, C, H, or D (spades, clubs, hearts, or diamonds)
// Helpful supporting structures
private static String [] Ranks = {"2","3","4","5","6","7","8","9","10", "Jack", "Queen", "King", "Ace"};
private static char [] Suits = {'C','H','D','S'};
// Default constructor: sets card rank to 2 and card suit to H
public Card(){
//setting default card to a 2 of hearts
m_rank = Ranks[0];
m_suit = Suits[1];
}
// Accessors and Mutators
public Card(String Rank, char suit){
if(isValidRank(Rank) == true){
m_rank = Rank;
}
if(isValidSuit(suit) == true){
m_suit = suit;
}
}
public String getRank() {
System.out.println(m_rank);
return m_rank;
}
public char getSuit() {
System.out.println(this.suitToString());
return m_suit;
}
public void setRank(String rank) {
// Make sure to validate provided input
if (isValidRank(rank) == true){
m_rank = rank;
}
else{
System.out.println("The rank you entered is invalid");
}
}
public void setSuit(char suit) {
// Make sure to validate provided input
if(isValidSuit(suit) == true){
m_suit = suit;
}
else{
System.out.println("The suit you entered is invalid");
}
}
// Method toString – returns string representation of the card that looks as follows:
// 2 of Hearts, 3 of Spades, Jack of Diamonds, etc.
// Requirement: you must use switch statement to convert character to string.
//
// Hint: card’s rank is already a string. Therefore you only need to convert card suit into
// a string that reads “Clubs”, “Spades”, “Hearts” or “Diamond s”
public String suitToString(){
switch(m_suit){
case 'c': return "Clubs";
case 'h': return "Hearts";
case 'd': return "Diamonds";
case 's': return "Spades";
default: return "Hearts";
}
}
public String toString() {
String data = "You have a " + m_rank + " of " + this.suitToString();
return data;
}
// Supporting static methods
// Returns an array of possible card ranks
public static String [ ] getPossibleRanks() {
//System.out.println(Arrays.toString(Ranks));
for(int i = 0; i < Card.Ranks.length; i ++){
System.out.println(Ranks[i]);
}
return Ranks;
}
// Returns an array of possible card suits
public static char [ ] getPossibleSuits() {
for(int i = 0; i < Card.Suits.length;i++){
System.out.println(Suits[i]);
}
return Suits;
}
public boolean isValidRank (String r){
for(int i = 0; i < Card.Ranks.length; i++ ){
if(Card.Ranks[i].equals( r)){
return true;
}
}
return false;
}
public boolean isValidSuit (char s){
for (int i = 0; i < Card.Suits.length; i++){
if(Card.Suits[i] == s){
return true ;
}
}
return false;
}
}
Deck class :
import java.util.*;
public class DeckOfCards extends Card {
private ArrayList <Card> deck;
private Card card;
private String [] Ranks = super.getPossibleRanks();
private char [] Suits = super.getPossibleSuits();
// public void resetDeckOfCards() {
public DeckOfCards()
deck = new ArrayList<Card>();
for(int s = 0; s < Suits.length; s++)
{
for(int r = 0; r < Ranks.length; r++){
card = new Card(Ranks[r],Suits[s]);
deck.add(card);
}
}
}
public void display(){
System.out.println(deck);
}
//public Card getCard() { /* ... */ }
//Remove a random card from the Array List of cards and return its value from this method Notes:
//1. Ensure that there is at least one card in the ArrayList of Cards
//2. If there are no more cards left in the ArrayList of Cards, reset the Deck of Cards
//3. Use class Random to create a random number which will be an index into ArrayList of Cards
//4. Remove and return card stored in the ArrayList of Cards in the randomly created index
// Return an ArrayList of specified size (i.e. returned cards are being removed from the deck). //
// Notes:
// 1. Use method getCard() to retrieve a single card
// 2. Validate the value of size passed into this method and return null if size is invalid
//public ArrayList<Card> getHand(int size) { /* ... */ }
}
Why when i display my array list it doesn't iterate through the suits but it does through the ranks, i still get 52 cards but all with same suit.
So the problem appears to be that your Suits array has capital letters, but your suitToString method is using a switch statement where lower case letters are used. Since the default case is Hearts, I bet all your cards are hearts.
I'm working on a video poker assignment in java. We are given class templates that we are supposed to use in our program. I'm confused as to what Card c represents. Like in the method addCard(Card c), does that just mean it will be executed on the Card object that's currently in use? Here are the class files I've been working on so far. They are far from finished.
Player Class:
import java.util.ArrayList;
public class Player {
private ArrayList<Card> hand; // the player's cards
// you will likely need more instance variables
public Player(){
ArrayList<Card> hand = new ArrayList;
}
public void addCard(Card c){
// add the card c to the player's hand
}
public void removeCard(Card c){
// remove the card c from the player's hand
}
// you will likely need more methods here
}
Deck class:
import java.util.Random
public class Deck {
private Card[] theDeck;
private int top;
// add more instance variables if needed
public Deck(){
top = 0
Card[] theDeck = new Card[52];
for(int s = 1; s <= 4; s++)
{
for (int v = 1; v <= 13; v++)
{
for (int i = 0; i < theDeck.length; i++)
theDeck[i] = new Card(s,v);
}
public void shuffle()
{
// shuffle the deck here
Random generator = new Random();
int i;
int j;
int temp = i;
int i = generator.nextInt(51) + 1;
int j = generator.nextInt(51) + 1;
for(int k = 1; k <100; k++)
{
theDeck[i] = theDeck[j];
theDeck[j] = temp;
}
top = 0;
}
public Card deal(){
// deal the top card in the deck
if (top < 40)
{
theDeck.shuffle;
}
return theDeck[top];
top++;
} //this method should add cards to array hand? no addCard will do that.
// add more methods here if needed
//DB getter methods here?
}
Card Class:
public class Card implements Comparable<Card>{
private int suit;
private int value;
public Card(int s, int v){ //constructor of an object Card
s = suit;
v = value;
//make a card with suit s and value v
}
public int compareTo(Card c){
// use this method to compare cards so they
// may be easily sorted
}
public String toString() //to tell the user what card/s they have
{
myCard.getSuit();
myCard.getValue();
if(s == 1)
{
if(v == 11)
{
return "Jack of Clubs";
}
if(v == 12)
{
return "Queen of Clubs";
}
if(v == 13)
{
return "King of Clubs";
}
if(v == 1)
{
return "Ace of Clubs";
}
else{
return v + " of Clubs";
}
}
if(s == 2)
{
return v + "Diamonds";
}
if(s == 3)
}
return v + "Hearts";
}
if(s == 4)
}
return v + "Spades";
}
//DB method to set 1, 2, 3, and 4 to card suits
//now here create string representation for the Card
// use this method to easily print a Card object
public int getSuit()
{
return s;
}
public int getValue()
{
return v;
}
//DB right now have cards in theDeck like Card(2, 10), need Card(d, 10)
//need to convert that to a String d10
}
// add some more methods here if needed
}
In public void addCard(Card c), c is a parameter.
This means that within the body of the function addCard, you can refer to the value passed to the function by the name c. You call the function addCard with some value (e.g., theDeck[0]), and that value will be used in addCard().