deck

public class Foothill
{
   public static void main(String[] args)
   {
      Deck deck1;

      deck1 = new Deck(1);

      System.out.println(deck1.toString());

   }
}

class Card
{
   public enum Suit
   {
      clubs, diamonds, hearts, spades
   }

   static char DEFAULT_VAL = 'A';
   static Suit DEFAULT_SUIT = Suit.spades;

   private char value;
   private Suit suit;
   private boolean errorFlag;

   public Card(char value, Suit suit)
   {
      set(value, suit);
   }

   public Card(char value)
   {
      this(value, Suit.spades);
   }

   public Card()
   {
      this(DEFAULT_VAL, DEFAULT_SUIT);
   }

   public Card(Card card)
   {
      this(card.value, card.suit);
   }

   public boolean set(char value, Suit suit)
   {
      char upVal;

      upVal = Character.toUpperCase(value);

      if ( !isValid(upVal, suit))
      {
         errorFlag = true;
         return false;
      }

      errorFlag = false;
      this.value = upVal;
      this.suit = suit;
      return true;
   }

   public char getVal()
   {
      return value;
   }

   public Suit getSuit()
   {
      return suit;
   }

   public boolean getErrorFlag()
   {
      return errorFlag;
   }

   private static boolean isValid(char value, Suit suit)
   {
      char upVal;
      String legalVals = "23456789TJQKA";

      upVal = Character.toUpperCase(value);

      if ( legalVals.indexOf(upVal) >= 0 )
         return true;
      else
         return false;
   }

   public boolean equals(Card card)
   {
      if (this.value != card.value)
         return false;
      if (this.suit != card.suit)
         return false;
      if (this.errorFlag != card.errorFlag)
         return false;
      return true;
   }

   public String toString()
   {
      String retVal;

      if (errorFlag)
         return "Invalid";

      retVal =  String.valueOf(value);
      retVal += " of ";
      retVal += String.valueOf(suit);

      return retVal;
   }
}

class Hand
{
   public static final int MAX_CARDS = 30;

   private Card[] myCards;
   private int numCards;

   public Hand()
   {
      myCards = new Card[MAX_CARDS];
      resetHand();
   }

   public void resetHand()
   {
      numCards = 0;
   }

   public boolean takeCard(Card card)
   {
      if (numCards >= MAX_CARDS)
         return false;

      if (myCards[numCards] == null)
         myCards[numCards] = new Card();

      myCards[numCards++].set(card.getVal(), card.getSuit());
      return true;
   }

   public Card playCard()
   {
      Card errorReturn = new Card('E', Card.Suit.spades);

      if (numCards == 0)
         return errorReturn;
      else
         return myCards[--numCards];
   }

   Card inspectCard(int k)
   {
      Card errorReturn = new Card('E', Card.Suit.spades);

      if (k < 0 || k >= numCards)
         return errorReturn;
      else
         return new Card (myCards[k]);
   }

   public String toString()
   {
      int k;
      String retVal = "Hand =  ( ";

      for (k = 0; k < numCards; k++)
      {
         retVal += myCards[k].toString();
         if (k < numCards - 1)
            retVal += ", ";
      }
      retVal += " )";
      return retVal;
   }

   int getNumCards()
   {
      return numCards;
   }
}

class Deck
{
   private static final int MAX_PACKS = 6;
   private static final int NUM_CARDS_PER_PACK = 52;
   private static final int MAX_CARDS_PER_DECK = MAX_PACKS * NUM_CARDS_PER_PACK;
   private static Card[] masterPack;

   private Card[] cards;
   private int topCard;
   private int numPacks;

   public Deck(int numPacks)
   {
      this.numPacks = numPacks;

      allocateMasterPack();
      init(numPacks);
   }

   public Deck()
   {
      this(1);
   }
   public boolean init(int numPacks)
   {
      int deckNum = NUM_CARDS_PER_PACK*numPacks;

      cards = new Card[deckNum];

      if ( numPacks <= MAX_PACKS )
      {
          for (int i = 0; i < deckNum; i++ )
              cards[i] = masterPack[i % NUM_CARDS_PER_PACK];
         return true;
      }
      else
         return false;
   }

   private static void allocateMasterPack()
   {
      masterPack = new Card[NUM_CARDS_PER_PACK];
      int k, j;
      Card.Suit st;
      char val;

      if (masterPack[0] == null)
      {
         for (k = 0; k < masterPack.length; k++)
            masterPack[k] = new Card();

         for (k = 0; k<4; k++)
         {
            switch(k)
            {
            case 0:
               st = Card.Suit.clubs; break;
            case 1:
               st = Card.Suit.diamonds; break;
            case 2:
               st = Card.Suit.hearts; break;
            case 3:
               st = Card.Suit.spades; break;
            default:
               st = Card.Suit.spades; break;
            }

            masterPack[13*k].set('A', st);
            for (val='2', j = 1; val<='9'; val++, j++)
               masterPack[13*k + j].set(val, st);
            masterPack[13*k+9].set('T', st);
            masterPack[13*k+10].set('J', st);
            masterPack[13*k+11].set('Q', st);
            masterPack[13*k+12].set('K', st);
      }

      for (k = 0; k < 52; k++)
         System.out.println(masterPack[k].toString());
      System.out.println();
      }
   }

   public void shuffle()
   {
      for ( int i = cards.length-1; i > 0; i-- )
      {
         int rand = (int)(Math.random()*(i+1));
         Card temp = cards[i];
         cards[i] = cards[rand];
         cards[rand] = temp;
      }
      topCard = 0;
   }
}