Im having trouble converting the r[rank] to String. Eclipse keeps saying it needs to be resolved to an array. Also having trouble with Cards[13*i + j] = new Card(i, j); it just keeps saying cannot be resolved to a variable. Heres my code...
public class Card {
private String suit;
private String rank;
private static String[] s = { "hearts", "spades", "diamonds", "clubs" };
private static String[] r = { "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King" };
public Card(int suit, int deck){
for(int i = 0; i < 4; i++) {
for(int j = 0; j < 13; j++){
Cards[13*i + j] = new Card(i, j);
}
}
}
public Card(String r, String s, String suit){
for(int rank = 0; rank < r.length(); rank+=1){
if( rank.equals(r[rank]) ){
this.rank = r+1;
}
}
this.suit = suit;
}
public String getSuit(){
return suit;
}
public void setSuit(String a, String suit) {
this.suit = suit;
}
public String getRank(){
return rank;
}
public void setRank( String s, String rank){
this.rank= rank;
}
public String toString(){
return String.valueOf(this.getRank()) + String.valueOf(this.getSuit().charAt(0));
}
}
public class Deck {
private Card[] deck;
private int inDeck;
private final int SIZE_OF_DECK = 52;
private int currentCard;
public Deck(){
deck = new Card[deck];
}
private void init(){
}
public void shuffle(int num){
int i,j,k;
for (k = 0; k < num; k++)
{
i = (int) (SIZE_OF_DECK * Math.random()*100);
j = (int) (SIZE_OF_DECK * Math.random()*100);
Card tmp = deck[i];
deck[i] = deck[j];
deck[j] = tmp;
}
currentCard = 0;
}
public Card getCard(){
if (currentCard<SIZE_OF_DECK)
{
return deck[currentCard++];
}
else
{
System.out.print("out of cards error");
return null;
}
}
public int totalCards(){
return SIZE_OF_DECK ;}
}
You never initialize your card array... try something along the lines of this before you create each individual object with your loops.
Card[] cards = new Card[52];
Related
So I am building up to a card game but, but I am having some trouble building the deck of cards and OOP in general so I was wondering if I could get some help. This is what I have so far.
public class Card {
String[] rank = {"Ace", "2", "3", "4", "5", "6",
"7", "8", "9", "10", "Jack", "Queen", "King"};
String suit;
int value;
String color;
public Card(String suit, int value) {
this.suit = suit;
this.value = value;
if (suit.equals("Hearts") || suit.equals("Diamonds")) {
color = "red";
} else {
color = "black";
}
}
public int getValue() {
return value;
}
public String getColor() {
return color;
}
public String getSuit() {
return suit;
}
public String getName() {
name = rank[(value - 1)];
return name;
}
public String toString() {
return name + " of " + suit;
}
}
The class for my deck of cards (so far) is as follows:
public class Deck {
String[] suits = {"Hearts", "Diamonds", "Clubs", "Spades"};
static String[] cards = new String[52];
public Deck() {
int index = 0;
for (int i = 0; i < 4; i++) {
// For each value of card with this suit.
for (int j = 1; j <= 13; j++) {
Card card = new Card(suits[i], j);
cards[index] += card;
index += 1;
}
}
}
public static void all() {
for (int i = 0; i < cards.length; i++) {
System.out.println(cards[i]);
}
}
}
So my question was when I print out the cards, I get something like
nullnull of Hearts
nullnull of Hearts
nullnull of Hearts
nullnull of Hearts....
nullnull of Diamonds
nullnull of Diamonds
nullnull of Diamonds
nullnull of Diamonds
nullnull of Diamonds... etc.
Why am I getting these nulls? What am I doing wrong? Also, any other tips to improve my code would be greatly appreciated.
Your problem is the following line of code from the constructor of class Deck.
cards[index] += card;
You need to remove the +.
An array of objects in java is always initialized such that every element is null. Hence you are appending a card to null.
If you would step through your code with a debugger, you would have discovered that. All good IDEs have a debugger. You should learn to use it.
Note that the code in your question does not compile but I figured out how to fix it since the problems are minor.
For the sake of completeness. Here is your code with my fixes. Compare it to your code.
Class Card
public class Card {
String[] rank = {"Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"};
String suit;
int value;
String color;
public Card(String suit, int value) {
this.suit = suit;
this.value = value;
if (suit.equals("Hearts") || suit.equals("Diamonds")) {
color = "red";
}
else {
color = "black";
}
}
public int getValue() {
return value;
}
public String getColor() {
return color;
}
public String getSuit() {
return suit;
}
public String getName() {
String name = rank[(value - 1)];
return name;
}
public String toString() {
return getName() + " of " + suit;
}
}
Class Deck
(Note that I added a main() method just for testing purposes.)
public class Deck {
String[] suits = {"Hearts", "Diamonds", "Clubs", "Spades"};
Card[] cards = new Card[52];
public Deck() {
int index = 0;
for (int i = 0; i < 4; i++) {
// For each value of card with this suit.
for (int j = 1; j <= 13; j++) {
Card card = new Card(suits[i], j);
cards[index] = card;
index += 1;
}
}
}
public void all() {
for(int i = 0; i < cards.length; i++) {
System.out.println(cards[i]);
}
}
public static void main(String[] args) {
new Deck().all();
}
}
Your example does not look complete, as I don't see name field in Card class defined. But what I see is that name is initialized in getName methods. I guess you don't initialize it.
Either use getName in toString:
public String toString(){
return getName() + " of " + suit;
}
or initialize name in the constructor: name = rank[(value - 1)]
Prefer initialization in the constructor, otherwise if you refer to name in some other place you can get the same issue.
I am trying to create mutliple methods which all use data from the same array. The method createDeck works fine. But for the other two methods, they just return null. Is there a way to fix this?
class Deck
{
private static String[] suit = {"Spades", "Diamonds", "Clubs", "Hearts"};
private static String[] rank = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen",
"King", "Ace"};
private static String[] deck = new String[52];
// create deck
static void createDeck()
{
for (int i = 0; i < deck.length; i++)
{
deck[i] = rank[i % 13] + " of " + suit[i / 13];
System.out.println(deck[i]);
}
}
// shuffle deck
static void shuffleDeck()
{
// shuffle the deck
for (int i = 0; i < deck.length; i++)
{
int index = (int) (Math.random() * deck.length);
String temp = deck[i];
deck[i] = deck[index];
deck[index] = temp;
}
// print the shuffled deck
for (String u : deck)
{
System.out.println(u);
}
}
static void findTop()
{
System.out.println(deck[0]);
}
}
One way to solve this is to directly fill the array using a static initalizer which gets called automatically.
Just add this code block after the decalration of the array at the beginning of the class
private static String[] deck = new String[52];
static {
for (int i = 0; i < deck.length; i++)
{
deck[i] = rank[i % 13] + " of " + suit[i / 13];
System.out.println(deck[i]);
}
}
And of course remove the method createDeck since it is no longer needed. The following code will now be executed correctly and printing values from the array
public static void main(String[] args) {
Deck.findTop();
Deck.shuffleDeck();
}
See this question for more info on static initializer
If it is used in your object, you can put the Array inside the constructor of an object.
public class Deck {
String[] deck;
public Deck(){
this.deck = new String[52];
}
}
I have a card class that looks like this:
public class Card
{
//instance variables
private String faceValue; //the face value of the card
private String suit; //the suit of the card
String[] ranks = {"Ace", "2", "3", "4", "5", "6","7", "8", "9", "10", "Jack", "Queen", "King"};
String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"};
/**
* Constructor
*/
public Card()
{
for (int i = 0; i < 13; i++)
{
for (int j = 0; j < 4; j++)
{
faceValue = ranks[i];
suit = suits[j];
}
}
}
//getters
/**
* Getter for faceValue.
*/
public String getFaceValue()
{
return faceValue;
}
/**
* Getter for suit.
*/
public String getSuit()
{
return suit;
}
//end of getters
//methods
/**
* This method returns a String representation of a Card object.
*
* #param none
* #return String
*/
public String toString()
{
return "Dealed a card: " + faceValue + " of " + suit;
}
}
And another Deck class that uses the Card class to create an array:
public class Deck
{
//instance variables
private Card[] deck;
/**
* Constructor for objects of class Deck
*/
public Deck()
{
deck = new Card[52];
}
/**
* String representation.
*/
public String toString()
{
return "Dealed a card: " + deck.getFaceValue() + " of " + deck.getSuit();
}
}
My toString method is giving me the error "cannot find symbol - method getFaceValue()". Same for getSuit(). Any ideas why?
deck is an array of Card[] deck. Hence, you can't call the method getFaceValue() nor getSuit() on it, because those 2 methods are part of the Card class and NOT of the array of Cards.
here some possible solutions to your problem as suggested:
public String toString()
{
return Arrays.toString(deck);
}
or for loop through the entire deck
public String toString()
{
String deckInStringForm = "[ ";
for(int indexOfCard = 0; indexOfCard < deck.length; indexOfCard++)
{
deckInStringForm += deck[indexOfCard] + " ";
}
deckInStringForm += "]";
return deckInStringForm;
}
or change/add a function to take an index like so
public String toString(int index)
{
return "Card " + index + ": " + deck[index].toString();
}
I am attempting to create a deck and apply a suite to each one, for example:
cardValue[0][1] and convert it into cardValue[Spade][1]
but I don't understand how to convert it. What I have currently:
int cardValues[][];
for(int a = 0; a <= 3; a++)
{
for(int b = 0; b <= 12; b++)
{
cardValues[][] += cardValues[a][b];
if(cardValues[a][b] == cardValues[a][0])
{
cardValues[a][b] = 5;
}
else if(cardValues[a][b] > cardValues[a][0] || cardValues[a][b] < cardValues[a][10])
{
cardValues[a][b] = 1;
}
else if(cardValues[a][b] == cardValues[a][10])
{
cardValues[a][b] = 2;
}
else if(cardValues[a][b] == cardValues[a][11])
{
cardValues[a][b] = 3;
}
else if(cardValues[a][b] == cardValues[a][12])
{
cardValues[a][b] = 4;
}
}
}
I don't understand how to convert the 0, 1, 2, and 3 into spades, diamonds, clubs, hearts.
I would do something like that:
Suit.java
public enum Suit {
SPADES, DIAMONDS, CLUBS, HEARTS
}
Card.java
public class Card {
private Suit suit;
private String value;
public Card(Suit suit, String value) {
this.suit = suit;
this.value = value;
}
public Suit getSuit() {
return suit;
}
public void setSuit(Suit suit) {
this.suit = suit;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
Main.java
public class Main {
public static void main(String[] args) {
String[] values = new String[]{"K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2", "A"};
Card[] deck = new Card[52];
int i = 0;
for (Suit suit : Suit.values()) {
for (String value : values) {
deck[i++] = new Card(suit, value);
}
}
for (Card card : deck) {
System.out.println(card.getValue() + " of " + card.getSuit());
}
}
}
I have to develop a class called Pack and it needs to be able to generate a pack of 52 playing cards sorted by Suit and Rank. It also needs to be able to shuffle that pack of cards with another method. Finally, it has to return the String repesentation of that pack of cards.
This is the catch though, I have to somehow use another class I have done, PlayingCard, with this Pack class. And this is when I run into dead ends, I can't figure out a way of shuffling the cards in the arrays I use, and I can't use PlayingCard due to incompatability issues.
This is the current Pack Class:
import java.util.Random;
public class Pack {
int[] cards = new int[52];
public Pack() {
// Setting up array
String[] suits = {"SPADES", "CLUBS", "HEARTS", "DIAMONDS"};
String[] ranks = {"TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING", "ACE"};
// Intialising array
{
for (int i = 0; i < cards.length; i++) {
cards[i] = i;
}
}
}
public void shuffle() {
for (int i = 0; i < 52; i++) {
Random random = new Random();
int rand = random.nextInt(50)+1;
cards[i] = rand;
}
}
#Override
public String toString() {
return getClass().getName() + "[suit[]= " + suit[] + "rank[]= " + rank[] + "]";
}
}
This is the another Pack Class based of advice, note the lack of toString():
import java.util.Random;
public class Pack {
PlayingCard[] cards = new PlayingCard[52];
public Pack() {
// Setting up array
String[] suits = {"SPADES", "CLUBS", "HEARTS", "DIAMONDS"};
String[] ranks = {"TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING", "ACE"};
// Initialising array
for (int i = 0; i < cards.length; i++) {
cards[i] = i;
}
}
public void shuffle() {
for (int i = 0; i < 52; i++) {
Random random = new Random();
int rand = random.nextInt(50) + 1;
cards[i] = rand; // Error 3
}
}
#Override
public String toString() {
This is the template I have been using for all the good it has done:
Using the class PlayingCard develop another class called Pack.
An outline for this class is provided below:
public class Pack
{
PlayingCard[] cards = new PlayingCard[];
/**
* Constructs a pack of 52 cards.
* Sorted by suit Clubs, Diamonds, Hearts, Spades.
* Sorted ascending.
*/
public Pack()
{
}
/**
* Shuffles cards in pack.
*/
public void shuffle()
{
}
/**
* #return string representation of 52 card pack.
*/
public String toString()
{
}
}
And finally, here is the PlayingCard class that Pack must somehow use.
import java.util.Objects;
public class PlayingCard {
private Rank rank;
private Suit suit;
public PlayingCard(Rank rank, Suit suit) {
this.rank = rank;
this.suit = suit;
}
public Rank getRank() {
System.out.println(rank);
return rank;
}
public Suit getSuit() {
System.out.println(suit);
return suit;
}
public String toString() {
return getClass().getName() + "[rank= " + rank + "suit= " + suit + "]";
}
public void format() {
System.out.format(rank + " OF " + suit);
System.out.println();
}
#Override
public boolean equals(Object otherObject) {
if (otherObject == null) {
return false;
}
if (!(otherObject instanceof PlayingCard)) {
return false;
}
if (this == otherObject) {
return true;
}
PlayingCard other = (PlayingCard) otherObject;
return suit.equals(other.suit) && rank == other.rank;
}
#Override
public int hashCode() {
return Objects.hash(suit, rank);
}
}
So, how can I use the PlayingCard class with Pack, and how can I get the shuffle class in Pack to function with my arrays etc as all it is going to achieve at the moment is putting in random numbers into the cards array.
If more infomation is needed, tell me, and I will add it.
EDIT 1:
In response to the first answer, here is the enum of suit just for showing a potential problem, and the current version of Pack that I did before the answer. How does it hold out?
Enum:
public enum Suit
{
SPADES(-2), CLUBS(-1), HEARTS(0), DIAMONDS(1);
private int value;
private Suit(int value)
{
this.value = value;
}
public int getValue()
{
return value;
}
}
Updated Pack:
import java.util.Random;
public class Pack
{
int[] cards = new int[52];
public void Deck()
{
// Setting up array
String[] suits = {"SPADES", "CLUBS", "HEARTS", "DIAMONDS"};
String[] ranks = {"TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
"EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING", "ACE"};
// Intialising array
{
for (int i = 0; i < cards.length; i++)
{
cards[i] = i;
}
}
}
public void shuffle()
{
for (int i = 0; i < 52; i++)
{
Random random = new Random();
int rand = random.nextInt(50)+1;
int temp = cards[i];
cards[i] = cards[rand];
cards[rand] = temp;
}
}
#Override
public String toString()
{
return
}
}
Notice Rank and Suit in the PlayingCard class. It's hint to define 2 enum classes (show only Suit class) :
public enum Suit {
SPADE("Spade"),
HEART("Heart"),
DIAMOND("Diamond"),
CLUB("Club");
private String name;
private Suit(String name) { this.name = name; }
public String toString() {return name;}
}
You can declare these 2 enums as public static enum {...} into the Pack class. The reason to use enums in this case is we know in advance all the cards and this is safer to handle strongly type objects than just Integers or String for ranks and suits.
You can then initialise the Pack of cards with a double loop on Suit and Rank values, e.g.
public Pack() {
int i = 0;
for (Rank r : Rank.values()) {
for (Suit s : Suit.values()) {
cards[i] = new PlayingCard(r, s);
i++;
}
}
}
For shuffling the pack, just use Collections.shuffle(), e.g.
public void shuffle() {
List<Card> newDeck = Arrays.asList(cards);
Collections.shuffle(newDeck);
}
The List<Card> is backed by the array ; the shuffling is then propagated to the array of cards.