Design

Design
	Chapter 4. Outcome Class

Outcome contains a single outcome on which a bet can be placed. In Roulette, each spin of the wheel has a number of Outcomes. For example, the “1” bin has 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”.

Fields

String name ;
Holds the name of the Outcome. Examples include "1", "Red".
int odds ;
Holds the payout odds for this Outcome. Most odds are stated as 1:1 or 17:1, we only keep the numerator (17) and assume the denominator is 1.

Constructors

Outcome(String name, int odds);
Sets the local name and odds from the parameter name and odds.

Methods

int winAmount(int amount);
Multiplies this Outcome's odds by the given amount. The product is returned.
An easy-to-read String output method is also very handy. This should return a String representation of the name and the odds. A form that looks like 1-2 Split (17:1) works nicely. In Java, this is done as follows.
public String toString();
In Python, the following declaration is used.
def __str__(self):
For some tips on how to do this, see Formatting in Java. Python formatting is done more simply, using the % operator.

Formatting in Java

For the very-new-to-Java, there are a variety of ways of implementing toString. Those who are more experienced in Java can skip this section.

String concatenation works neatly, but has some caveats. First, it tends to create a lot of intermediate objects. It isn't the best for high-volume, high-performance programs. Second, when assembling numeric results, additional ()'s are required; something that first-time programmers find unexpected.
StringBuffer assembly works a little better. It doesn't create as many intermediate objects as simple String concatenation. However, it is a bit more wordy.
The java.text.MessageFormat class is perhaps the nicest way to produce these kinds of formatted strings.

Example of simple String concatenation. In this case, we depend on a certain amount of automatic string conversion. This technique requires that the very first element be a String, and that any arithmetic operations have additional ()'s to permit them to be done first as numeric values before being converted to a string.

Example 4.2. Java Simple toString Implementation

public String toString() {
    return name + " (" + odds + ":1)"; 
}

We assemble a string from the name, some literals, and an implicit conversion of the odds to a string.

Example of StringBuffer construction. In this case, we append a number of strings into the StringBuffer.

Example 4.3. Java StringBuffer toString Implementation

public String toString() {
    StringBuffer result= new StringBuffer(); 
    result.append( name ).append( " (" ).
        append( odds ).append( ":1)" ); 
    return result.toString(); 
}

	Create an empty `StringBuffer`.
	Append various strings to the `StringBuffer`.
	Return a final String from the `StringBuffer`.

Example of using a MessageFormat object. In this case, a simple String message template will have the values inserted into it. The {0} markers show where values from the array of Objects are inserted into the output message. Eventually, the message template can be extracted to a ResourceBundle. While not essential for learning OO design, this is a good objective for high-quality software.

Example 4.4. Java MessageFormat toString Implementation

public String toString() {
    Object[] values= { name, new Integer(odds) }; 
    String msgTempl= "{0} ({1}:1)"; 
    return MessageFormat.format( msgTempl, values ); 
}

	Create an array of objects that will be converted to Strings and inserted into the message.
	Create the template message.
	Insert the objects into the template message, returning the new String.