结合枚举类与策略模式进行模块化设计

Question

I am a biologist who is trying to improve my dated knowledge of Java and OOP. I am going through the exercise of writing a game to practice good software design and modularity (why make something fun?).

The idea is like Risk but with international banking. Each bank deals with different currencies; each currency uses different denominations. The banks all offer the same functions (balance, withdraw, deposit, exchange) and so would do well with an interface. A currency can also be well described using an Enum representing each denomination and its value.

This is my very simple example. I can create new Country() objects for each county in the game.

1) Am I forced to manually specify every single country with its respective currency? Eg:

Country Canada = new Country(CANCurrency);

This seems rather clunky and there must be a better way to do this.

2) From a class using County(), how can I directly access its (indirectly contained) Enum values?

Each country looks like this:

public class Country {

    private final String name;
    private ICurrency currency;

    public Country(String name, ICurrency currency) {
        this.name = name;
        this.currency = currency;
    }

    // How do I access the specific Enum constants here?

}

This is my Banking interface:

public interface IBank {
    // Standard banking methods.
    public void deposit(int amount);
    public void withdraw(int amount);
    public int balance();
    public int exchange (Currency demandType, int demand, Currency offerType, int offer);
}

Each country's Currency will largely have similar code, except for the denominations.

public interface ICurrency {
    public Currency getCurrency();
    // Maybe some more helper methods here.
}

This is the Currency for Canada:

public enum CANCurrency interface ICurrency {
    LOONIE(1), TWONIE(2), FIVE(5); // etc....
}

and the currency for USA:

public enum USACurrency interface ICurrency {
    ONE(1), FIVE(5), TEN(10); // etc....
}

Answer 1

You can use enums, even singleton enums, to implement strategies. In fact that is the best way IMHO. It is usually best to ensure that your enums are immutable and stateless, but they are not required to be.