CS2514

Introduction to Java

Dr Derek Bridge

School of Computer Science & Information Technology

University College Cork

`Card.java`

class Card {

    int rank;
    String suit;
    
    public Card(int r, String s) {
        rank = r;
        suit = s;
    }
    
    public boolean higher(Card c) {
        return rank > c.rank;
    }
    
    public boolean lower(Card c) {
        return rank < c.rank;
    }
    
    public String toString() {
        return rank + " of " + suit;
    }
    
}

`Deck.java` (Version A)

import java.util.Random;

class Deck {

    Card[] cards;
    
    public Deck() {
        String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"};
        cards = new Card[52];
        int indexOfNextCard = 0;
        for (int i = 0; i < suits.length; i = i + 1) {
            for (int j = 1; j < 14; j = j + 1) {
                cards[indexOfNextCard] = new Card(j, suits[i]);
                indexOfNextCard = indexOfNextCard + 1;
            }
        }
    }
    
    public void shuffle() {
        Random randy = new Random();
        for (int i = 0; i < cards.length; i = i + 1) {
            int j = randy.nextInt(cards.length);
            Card temp = cards[i];
            cards[i] = cards[j];
            cards[j] = temp;
        }
    }
    
    public Card deal() {
        Card c = cards[cards.length - 1];
        Card[] all_but_last = new Card[cards.length - 1];
        for (int i = 0; i < all_but_last.length; i= i + 1) {
            all_but_last[i] = cards[i];
        }
        cards = all_but_last;
        return c;
    }
}

Changing the implementation of `Deck`

There is another way of implementing the Deck that gives a much more efficient implementation of the deal method
- Two instance variables, instead of just one:
  - the array of cards
  - an integer that is an index to the last card that is still in the deck
- Then deal does little more than subtract 1 from the index
- We have small changes to make to the constructor and to shuffle

`Deck.java` (Version C)

import java.util.Random;
class Deck {

    Card[] cards;
    int indexOfLastCard;
    
    public Deck() {
        String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"};
        cards = new Card[52];
        int indexOfNextCard = 0;
        for (int i = 0; i < suits.length; i = i + 1) {
            for (int j = 1; j < 14; j = j + 1) {
                cards[indexOfNextCard] = new Card(j, suits[i]);
                indexOfNextCard = indexOfNextCard + 1;
            }
        }
        indexOfLastCard = 51;
    }
    
    public void shuffle() {
        Random randy = new Random();
        for (int i = 0; i < indexOfLastCard + 1; i = i + 1) {
            int j = randy.nextInt(indexOfLastCard + 1);
            Card temp = cards[i];
            cards[i] = cards[j];
            cards[j] = temp;
        }
    }
    
    public Card deal() {
        Card c = cards[indexOfLastCard];
        indexOfLastCard = indexOfLastCard - 1;
        return c;
    }
}

Encapsulation

The nice thing is that 'clients' of the Deck class (e.g. Game) do not need to be changed
- the implementation of Deck has changed
- but its public interface remains the same: constructor, shuffle and deal
This illustrates an important principle of object-oriented programming: encapsulation
- 'hiding' the implementation behind the interface
- the implementation comprises the instance variables and the method bodies
- the interface comprises the signatures of the public methods

`Game.java`

import java.util.Scanner;
class Game {

    public void play() {
        Scanner sc = new Scanner(System.in);
        int score = 0;
        Deck d = new Deck();
        d.shuffle();
        Card currentCard = d.deal();
        for (int i = 0; i < 4; i = i + 1) {
            System.out.print("Will the next card be higher (H) or lower (L) than a " + currentCard + "? ");
            String guess = sc.nextLine();
            Card nextCard = d.deal();
            System.out.print("It's a " + nextCard + ". ");
            if ((guess.equals("L") && nextCard.lower(currentCard)) || (guess.equals("H") && nextCard.higher(currentCard))) {
                System.out.println("Yes!");
                score = score + 1;
            } else {
                System.out.println("Bad luck!");
            }
            currentCard = nextCard;
        }
        System.out.println("You scored " + score + " out of 4.");
    }
}

But we're not hiding enough!

In fact, we haven't yet done enough to 'hide' the implementation

Suppose we use the new version of Deck in the 'client' code on the right:

class Deck {
                    
    Card[] cards;
    int indexOfLastCard;
    
    public Deck() {
    
    // etc.
   
}

class DeckTester {

    public static void main(String[] args) {
        Deck d = new Deck();
        for (int i = 0; i < d.indexOfLastCard; i = i + 1) {
            System.out.println(d.cards[i]);
        }
    }
    
}

But then suppose we decide to revert to our previous implementation! The 'client' code will also need to be changed. Q: Why?

class Deck {
                    
    Card[] cards;
    
    public Deck() {
    
    // etc.
     
}

class DeckTester {

    public static void main(String[] args) {
        Deck d = new Deck();
        for (int i = 0; i < d.cards.length; i = i + 1) {
            System.out.println(d.cards[i]);
        }
    }
    
}

This is exactly what we don't want!
- When we change the implementation of a class, we don't want 'knock-on' effects in 'clients' of the class

Instance variables should be `private`

To 'hide' the implementation, the instance variables should be private

class Deck {
                   
    private Card[] cards;
    private int indexOfLastCard;
    
    public Deck() {
    
    // etc.
    
}

Only the constructors and methods in the interface should be public

Instance variables: visibility

We can decide which parts of a program can access an instance variable
This is determined by the visibility modifier: public, private, protected or default (blank):
- If public, the variable is visible to the whole program – this is totally unacceptable practice!
- If private, the variable is visible only within its class definition – this is the only good practice!
- If protected, the variable is visible within this class definition, within its subclasses (see class hierarchies, later) and (advanced) in every class definition in the same package – this is sometimes acceptable
- (Advanced:) If default (blank), the variable is visible to every class definition in the same package – this is pretty much unacceptable
This is not a security or privacy issue: it is about defining classes that are not unnecessarily inter-dependent

Visibility: summary

Visibility modifiers determine where variables can be accessed from

(From Coad, P., Mayfield, M. and Kern, J.: Java Design: Building Better Apps & Applets (2nd edn.), Yourdon Press, 1999)

What about instance methods?

We can use the same four visibility modifiers for methods
Methods that are part of the interface will be public
Helper methods are typically private
- methods that help other methods get their work done

Example without a helper method

class ATM {

    private String currency;
    private int[] denominations;
    private int[] contents;
    
    public ATM(String s, int[] denoms) {
        currency = s;
        denominations = denoms;
        contents = new int[denominations.length];
    }
    
    public String getCurrency() {
        return currency;
    }

    public int getTotal() {
        int total = 0;
        for (int i = 0; i < denominations.length; i++) {
            total = total + denominations[i] * contents[i];
        }
        return total;
    }
    
    public int getQty(int denom) {
        for (int i = 0; i < denominations.length; i++) {
            if (denominations[i] == denom) {
                return contents[i];
            }
        }
        return 0;
    }

    public String toString() {
        String s = "";
        for (int i = 0; i < denominations.length; i++) {
            s = s + contents[i] + " x " + currency + denominations[i] + "; " ;
        }
        return s;
    }

    public void load(int qty, int denom) {
        for (int i = 0; i < denominations.length; i++) {
            if (denominations[i] == denom) {
                contents[i] += qty;
                return;
            }
        }
    }

    public void dispense(int qty, int denom) {
        for (int i = 0; i < denominations.length; i++) {
            if (denominations[i] == denom && contents[i] >= qty) {
                contents[i] -= qty;
                return;
            }
        }
    }

}

Example with a helper method

class ATM {

    private String currency;
    private int[] denominations;
    private int[] contents;
    
    public ATM(String s, int[] denoms) {
        currency = s;
        denominations = denoms;
        contents = new int[denominations.length];
    }
    
    public String getCurrency() {
        return currency;
    }

    public int getTotal() {
        int total = 0;
        for (int i = 0; i < denominations.length; i++) {
            total = total + denominations[i] * contents[i];
        }
        return total;
    }
    
    public int getQty(int denom) {
        int posn = indexOf(denom);
        if (posn != -1) {
            return contents[posn];
        } else {
            return 0;
        }
    }

    public String toString() {
        String s = "";
        for (int i = 0; i < denominations.length; i++) {
            s = s + contents[i] + " x " + currency + denominations[i] + "; " ;
        }
        return s;
    }

    public void load(int qty, int denom) {
        int posn = indexOf(denom);
        if (posn != -1) {
            contents[posn] += qty;
        }
        // else no update
    }

    public void dispense(int qty, int denom) {
        int posn = indexOf(denom);
        if (posn != -1 && contents[posn] >= qty) {
            contents[posn] -= qty;
        }
        // else no update
    }

    private int indexOf(int denom) { 
        for (int i = 0; i < denominations.length; i++) {
            if (denominations[i] == denom) {
                return i;
            }
        }
        return -1;
    }
    
}

Design

Software design is all about data abstraction and procedural abstraction
Data abstraction
- organising access to a program's data (e.g. arranging variable declarations and methods for accessing data into class definitions)
Procedural abstraction
- organising a program's computation (e.g. arranging the statements into methods)