13 Feb 2012 [ 201 week6 ]

This week we'll go over more examples of class design, with a focus on expanding our view of what we can represent with a class.

Up to now, we've seen examples of modeling real life (more or less) objects in code, like Robot or Human or Timer. The real power of object-oriented programming (and some of the biggest conceptual differences from the more straightforward procedural paradigm) comes in modeling more abstract concepts like rules, strategies, and procedures.

Helpful organizational tools: packages and enums

A couple of new details we'll start to use in class:

Packages are the way to organize groups of classes in Java. Package structure reflects the file system hierarchy: package x.y.z lies in folder x/y/z on disk. You can use a package declaration statement at the top of each source file, like package x.y.z;.

Enums provide a way to organize a group of constant values in a convenient way. In the tic-tac-toe example we'll use, the possible entries on the game board are either X, O, or EMPTY. We could just pick numbers or char data to represent each type, but Java provides a shortcut for defining groups of such related constants. In the simplest case, we can just say:

public enum Piece {

Then we can use Piece.X, Piece.O, and Piece.EMPTY to represent the various entries. In addition to convenience, we are given an extra mesasure of type safety: if we had represented the pieces using a char, we would have to worry about handling errors due to the wrong letter being used. But with an enum, the three listed values are the only ones possible anywhere in our program.

Modeling procedures as objects

Here's a simple example that filters standard input for numbers in a desired range. How would you use this class to build a more complicated filter that looks for numbers in any one of several ranges? For example, checking for numbers that lie in [0, 1], [2, 3], or [4, 5].

import java.util.Scanner;

public class RangeFilter {
    private double lower;
    private double upper;
    public RangeFilter(double min, double max) {
        lower = min;
        upper = max;
    public boolean contains(double x) {
        return x >= lower && x <= upper;
    // Filter standard input for numbers in the range [0, 10].
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        RangeFilter range = new RangeFilter(0, 10);
        while (input.hasNextDouble()) {
            double x = input.nextDouble();
            if (range.contains(x))

Modeling rules as objects

Look in the examples directory for a tic-tac-toe-like project. We'll fill in definitions for methods used to model the rules of the game, starting from the template here:

package org.ilzd.tictacx;

/** Represent rules for a tic-tac-toe style game, 
 *  and track status of game instance with respect
 *  to the rules.
public class Rules {
    private Board board;
    /** Track current player. */
    private Piece player = Piece.X;
    /** Track winner (when game is over) */
    private Piece winner = null;
    /** Number in-a-row required for win */
    private int goal = 3;
    /** Construct rules object to govern given board.
     * @param b board to track
    public Rules(Board b) {
        board = b;
    // Override default goal of 3.
    public Rules(Board b, int goal) {
        this.board = b;
        this.goal = goal;
    /** Determine if game is over.
     * @return true if game is over
    public boolean gameOver() {
        // Check all possible starting points
        for (int r = 0; r < board.getRows(); r++) {
            for (int c = 0; c < board.getCols(); c++) {
                // Check all possible directions
                if (check(r, c, 1, 0) // Columns
                    || check(r, c, 0, 1) // Rows
                    || check(r, c, 1, 1) // Diag down-right
                    || check(r, c, 1, -1) // Diag down-left
                    ) {
                    // Track winner
                    winner = board.get(r, c);
                    return true;
        return false;

    /** Check starting at position (r, c) and moving in direction
     *  (deltaR, deltaC), check to see if all squares are occupied
     *  by same player.
    private boolean check(int r, int c, int deltaR, int deltaC) {
        // Determine piece to check for
        Piece player = board.get(r, c);
        if (player == Piece.EMPTY)
            return false;
        // Count of pieces in-a-row
        int count = 1;
        // Current location to check
        int r1 = r + deltaR;
        int c1 = c + deltaC;
        while (count < goal) {
            // Check for going off board
            if (r1 < 0 || r1 >= board.getRows())
                return false;
            if (c1 < 0 || c1 >= board.getCols())
                return false;
            // Check for not hitting desired piece type
            if (board.get(r1, c1) != player)
                return false;
            // If we make it past checks, we have another hit
            // And go on to next square
            r1 += deltaR;
            c1 += deltaC;
        // If we exit the loop, we've hit the goal
        return true;

    /** Determine if given move is legal.
     * @param r row location
     * @param c column location
     * @return true if move is legal
    public boolean legal(int r, int c) {
        // Check bounds.
        if (r < 0 || r >= board.getRows())
            return false;
        if (c < 0 || c >= board.getCols())
            return false;
        // Check earlier plays.
        if (board.get(r, c) != Piece.EMPTY)
            return false;
        // Check if square below exists and is empty
        if (r + 1 < board.getRows() && board.get(r + 1, c) == Piece.EMPTY)
            return false;
        return true;
    /** Determine active player.
     * @return player who can take the next turn
    public Piece getPlayer() {
        // Fill in logic to track current player.
        return player;

    /** Return winning player.
     * @return winning player, or null if game is not over
    public Piece getWinner() {
        return winner;
    /** Play a piece at given location.
     * @param row row location
     * @param col column location
     * @return true if play was allowed.
    public boolean play(int row, int col) {
        if (!legal(row, col))
            return false;
        board.play(getPlayer(), row, col);
        return true;
    private void nextPlayer() {
        if (player == Piece.X) 
            player = Piece.O;
            player = Piece.X;