Java Design

Java Design
	Chapter 5. Bin Class

Bin contains a collection of Outcomes which reflect the winning bets that are paid for a particular bin on a Roulette wheel. In Roulette, each spin of the wheel has a number of Outcomes. Example: A spin of 1, selects the “1” bin with the following winning Outcomes: “1”, “Red”, “Odd”, “Low”, “Column 1”, “Dozen 1-12”, “Split 1-2”, “Split 1-4”, “Street 1-2-3”, “Corner 1-2-4-5”, “Five Bet”, “Line 1-2-3-4-5-6”, “00-0-1-2-3”, “Dozen 1”, “Low” and “Column 1”. These are collected into a single Bin.

Fields

Set outcomes ;
Holds the connection of individual Outcomes.

For a discussion on the type declaration used for outcome, see Deferred Binding in Java.

Deferred Binding in Java

Python programmers can skip this section. Because Python uses run-time bindings, it doesn't use variable or parameter type declarations. Java, however, seeks to do as much compile-time binding as possible, and requires variable and parameter type declarations.

Some programmers note that our field declarations use interface names, like Set, not one of the concrete class implementations of that interface like HashSet. We strongly recommend declaring variables to be the highest-level class or interface that has the desired features. This gives the maximum flexibility to change the concrete class as needed.

In this case, we want only a few methods of the Set interface. Any of the available concrete implementations of Set would work perfectly here. By declaring the outcomes field of Bin with the interface, we are free to change the concrete class at some later time. Any concrete class that implements the necessary interface can be used.

Why would we change the concrete class? After all, we've analyzed the problem from several points of view and selected TreeSet. Typically, selecting a collection class represents a trade-off of memory, speed, or other features. These trade-off priorities are subject to considerable change. We have no reason for any design decision to be “cast in concrete”; and a formal declaration of a particular class is something that firmly fixes a design feature. We find that one consequence of our ignorance of the overall application and the uses to which it will be pu is that our assumptions may prove to be invalid, and we need to be able to make changes without devastating the design of our application.

Rather than make it difficult to switch to another implementation of Set, we declare the field with the highest-level interface or superclass. Then we make the concrete class decision in the constructor, deferring the final decision until run-time. A single line of source implements the final choice, simplifying the change process.

The logical extension of this policy is to focus all construction of new objects into builder objects as much as possible. In order to create a flexible application, we can use the Abstract Factory design pattern to create all new instances where change if type is expected. In this design pattern, the factory makes the final decision of which class to construct.

Constructors

In addition to the default constructor that makes an empty Bin, Java programmers may find it helpful to create a two additional constructors to initialize the collection from other collections.

Bin();
Creates an empty Bin. Outcomes can be added to it later.
Bin(Outcome[] outcomes);
Creates an empty Bin using the this() statement to invoke the default constructor. It then loads that collection using elements of the given array.
Bin(Collection outcomes);
Creates an empty Bin using the this() statement to invoke the default constructor. It then loads that collection using an iterator over the given Collection. This relies on the fact that all classes that implement Collection will provide the iterator; the constructor can convert the elements of the input collection to a proper Set.

The array constructor will initialize the outcomes Set from an array of Outcomes. This allows the following kind of constructor call from another class.

Example 5.1. Java Bin Construction

    Outcome five= new Outcome( "00-0-1-2-3", 6 );
    Outcome[] ocZero = {
        new Outcome("0", 35 ), five }; 
    Outcome[] ocZeroZero = {
        new Outcome("00", 35 ), five }; 
    Bin zero= new Bin( ocZero ); 
    Bin zerozero= bew Bin( ocZeroZero );

	This creates `ocZero`, which is an array of references to two objects: the “0” `Outcome` and the “00-0-1-2-3” `Outcome`.
	This creates `ocZeroZero`, which is an array of references to two objects: the “00” `Outcome` and the “00-0-1-2-3” `Outcome`.
	This creates `zero`, which is the final `Bin`, built from `ocZero`, which has both “0” and “five”.

Methods

void add(Outcome outcome);
Adds an Outcome to this Bin. This can be used by a builder to construct all of the bets in this Bin. Since this class is really just a façade over the underlying collection object, this method can simply delegate the real work to the underlying collection.
public String toString();
An easy-to-read String output method is also very handy. This should return a String representation of the list of Outcomes in this Bin.
For some tips on how to implement this, see Formatting in Java.