Exchange

1.  Exchange.java
• Some necessary comments are missing.
• The names arrayCurrencies and arrayRates are bad choices. In general, the identifiers are not enough meaningful. Moreover, arrayCurrencies and arrayRates are class constants and then must be written with only uppercases, with words separated by undescores ("_").
• The managing of a lacking currency is very dangerous. In fact, it is not taken in account in the main() method.
• It is difficult to reuse this program. In particular, it is necessary to modify Exchange in order to manage a new currency.
• Using the index to make in correspondance between a curreny name and its rate is dangerous. Moreover, it make difficult the use of different names for a same currency.
• The method convert() is not efficient. Its computing time is proportional to the number of currencies managed.
• The variable i in convert() must be declared in the loop.
• The class Exchange is incomplete. It is not possible to know if a currency is managed without asking for an exchange.
  Moreover, the possibilty to make a conversion from euro to another currency seems to be desirable.
2. Exchange.java
• This version does some corrections of problems observed in version 1.
  
• Nevertheless, it's always impossible to add easily a currency.
  
• The complexity of the method convert() remains to be improved. 
• The instruction return -1 is no more the result of a public method. It is then controlled internally. It is possible to avoid this instruction return -1 in the method searchCurrencyIndex(String currency), without having code duplication, by replacing the methods searchCurrencyIndex(String currency), currencyIndex(String currency) et processedCurrency(String currency) by the following code, using an extra variable.

  private int currencyIndex;

  private static int currencyIndex(String currency) {
      if (! processedcurrency(currency)) {
          throw new Error("Currency " + currency + " unknown");
      }
      return currencyIndex;
  }

  public static boolean processedCurrency(String currency) {
      for (currencyIndex = 0; currencyIndex < currencies.length; currencyIndex++) {
          if (currencies[currencyIndex].equals(currency)) {
              break;
          }
      }
      return currencyIndex < currencies.length;
  }

• The instruction throw new Error(<message>) stops a program execution with printing the message given as parameter. In some way, it is similar than using the assert() function of the C language. It would be better to throw an exception instead stopping the program.
3. Exchange.java, Currency.java
• This version is based on an architecture modification, with the addition of the class Currency, which improve the modularity.
• Please note in the class Currency the redefinition of the methods equals(Object), toString() and hashCode(), inherited from java.lang.Object.
• The class Exchange contains a static block for initialization.
• The method name() in the class Currency is declared final to avoid name modification by inheritance.
4. Exchange.java, Currency.java
• This version uses a list instead an array. This allows to add easily the currencies to process.
• Please note the use of a generic list, i.e. in which the content is typed. This kind of list exists since the release 1.5 of Java (see http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf) as the loop which simplify the use of iterators (see http://java.sun.com/j2se/1.5.0/docs/guide/language/foreach.html).
5. exchange.Exchange.java, exchange.Currency.java, exchange.ExistingCurrencyException.java, 
   exchange.UnknownCurrencyException.java, TestExchange.java
   
• Release with package.
  
• The instanciation of currencies is encapsulated in the class Exchange. In that way, it is guaranteed that Exchange will know all the existing currencies. To do that, the constructor of Currency is available only in its package.
• Two classes of exceptions have been added to manage critical cases. Note that exceptions must be catched in a static block, as it is done in Exchange.
  
6. exchange.Exchange.java, exchange.Currency.java, exchange.AbstractCurrency.java, 
   exchange.FixedRateCurrency.java, exchange.VariableRateCurrency.java, 
   exchange.ExistingCurrencyException.java, exchange.UnknownCurrencyException.java, 
   TestExchange.java
   
• Version with currencies with fixed or variable rate. For that, we use two classes implementing an interface Currency, and an abstract class to factorize the code.
• The method exchangeRateInEuro() is keeped abstract in AbstractCurrency because the corresponding data cannot be factorized at this level.
  
7. exchange.Exchange.java, exchange.Currency.java, exchange.AbstractCurrency.java, 
   exchange.FixedRateCurrency.java, exchange.VariableRateCurrency.java, 
   exchange.ExistingCurrencyException.java, exchange.UnknownCurrencyException.java, 
   TestExchange.java
   
• This version uses an hash table to manage the currencies, using their name as index. This increases the efficiency for testing the existance of a currency or getting it from its name.