Decoupling in action: Changing the implementation of the `Card` object

Previously discussed: decoupling

Information stored in a Card object can be obtained directly:

Explanation:

The Card object stores 2 pieces of information:
If the instance variables suit and rank had public access qualification, we could access them directly using the expression:

Information stored in a Card object can also be obtained indirectly:

Explanation:

The Card object stores 2 pieces of information:
Both variables have private access qualifiers
All program to want to access the information stored in the Card object must do so indirectly using the methods:

This approach was called decoupling the implementation and the functionality

(It has many fancy terminology to describe it.. like data abstraction, information hiding, etc., etc.).

Decoupling in action: accomplishing the same fuctionality with a different implementation

Suppose we encode a playing card as follows:

Currently used encoding New encoding ------------------------------------ -------------------------------- byte cardSuit = 1, 2, 3, 4 int cardValue = 10*rank + suit byte cardRank = 2, 3, ..., 13, 14

Example: old and new encoding

Ace of Spade:

Old representation: cardSuit = 4 (SPADE) cardRank = 14 New representation: cardValue = 14*10 + 4 = 144

4 of Diamond:

Old representation: cardSuit = 1 (DIAMOND) cardRank = 9 New representation: cardValue = 9*10 + 1 = 91

Why we may want to use the new representation:

The new encoding provides a ranking of the suits of playing cards of the same rank
Ranking suits is found in some card games
Example: bridge
The new encoding imposes a unique ranking on the cards in a deck:
You may want to use the new encoding to allow easy comparision between 2 playing card (to see which card is higher in value)

Implementing the Card class using the new card encoding:

public class Card { public static final int SPADE = 4; public static final int HEART = 3; public static final int CLUB = 2; public static final int DIAMOND = 1; private static final String[] Suit = { "*", "d", "c", "h", "s"}; private static final String[] Rank = { "*", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"}; private int cardValue; public Card( int suit, int rank ) { if ( rank == 1 ) cardValue = 14*10 + suit; // Give Ace the rank 14 else cardValue = rank*10 + suit; } public int suit() { return ( cardValue % 10 ); // Decode the suit... } public String suitStr() { return( Suit[ cardValue % 10 ] ); } public int rank() { return ( cardValue / 10 ); // Decode the rank } public String rankStr() { return ( Rank[ cardValue / 10 ] ); } public String toString() { return ( Rank[ cardValue / 10 ] + Suit[ cardValue % 10 ] ); } }

Notice that:

We have provided the same functionality:

But, we did this using a different implementation

The new implementation does not use the 2 instance variables cardSuit and cardRank
Instead, it use one single integer value
(We have argued that this representation can have an advantage because it impose a ranking on the cards).

Here is the big deal about decoupling functionality and implementation:

Suppose we did not use decoupling, our programs would have access the information stored inside a Card object directly:
When we switch over to use the new representation, all programs will not work properly:
Because:

You can see the advantage of decoupling in the following illustration:

Because we have used the decoupling tchnique:
All program access the stored information through the methods suit(), suitStr(), rank(), rankStr() and toString()
When we switch over to use the new representation, all programs will STILL work properly:

Example Program: (Demo above code)

Here is the new Card.java Prog file: click here
Here is the old DeckOfCards.java Prog file: click here
Here is the old TestDeck.java Prog file: click here

How to run the program:

Right click on links and save in a scratch directory
To compile: javac TestDeck.java
To run: java TestDeck

Notice that:

The DeckOfCrads.java program file is completely unchanged
And yet, it will work with the new representation used in Card.java

Decoupling in action: Changing the implementation of the Card object

Decoupling in action: Changing the implementation of the `Card` object