Solution for Quiz I

Problem I

class BankAccount implements Bank1, Bank2 {
    private int balance;
    
    public BankAccount (int balance) {
	this.balance = balance;
    }

    public int getBalance () { return balance; }

    public void withdraw (int amount) throws BankAccountError, NotEnoughMoney {
	if (amount <= 0) throw new BankAccountError();
	else if (amount <= balance) balance -= amount;
	else throw new NotEnoughMoney(amount-balance);
    }

    public void deposit (int amount) throws BankAccountError {
	if (amount <= 0) throw new BankAccountError();
	else balance += amount;
    }
}

Solution

interface Bank1 {
  void withdraw (int amount) throws BankAccountError, NotEnoughMoney;
}

interface Bank2 {
  void deposit (int amount) throws BankAccountError;
}

Problem II

• Every Person has one bank account in which they keep some of their money.
• A Person may also have additional money in cash (not to exceed $100).
• A Person. implements the following interface:

  interface Financial { 
      int HOURLY_RATE = 10; 
      int MAX_CASH = 100;
  
      /**
       * Returns the current amount of money in cash that the person has.
       */
      int amount_in_cash (); 
  
      /**
       * Returns the current balance in the person's bank account.
       */
      int amount_in_bank ();
  
      void work (int hours); // see below
  
      void pay (int amount); // see below
  }
  

  When invoking the method work, a Person earns an amount of money equals to the HOURLY_RATE times the number of hours they work. This money may be kept in cash or in the bank account subject to the constraint that the maximum cash does not exceed MAX_CASH. When invoking the method pay, a Person attempts to find enough money either in cash or in the bank account to pay for the amount needed. If there is not enough money, the Person may have to work first (i.e., invoke the method work) to acquire enough money.
• You are free to make any other assumptions about the behavior of a Person.

Solution

 
class Person implements Financial {
    private BankAccount account;
    private int cash;

    public Person () {
	this.account = new BankAccount(0);
	cash = 0;
    }

    public int amount_in_cash () { 
	return cash; 
    }

    public int amount_in_bank () {
	return account.getBalance();
    }

    public void work (int hours) {
	try {
	    cash += HOURLY_RATE * hours;
	    if (cash > MAX_CASH) {
		account.deposit(cash - MAX_CASH);
		cash = MAX_CASH;
	    }
	}
	catch (BankAccountError e) {
	}
    }

    public void pay (int amount) {
	if (cash > amount) cash -= amount;
	else {
	    try {
		account.withdraw (amount - cash);
		cash = 0;
	    }
	    catch (NotEnoughMoney e) {
		int amountNeeded = e.getAmount();
		work ((amountNeeded / HOURLY_RATE) + 1);
		pay (amountNeeded);
	    }
	    catch (BankAccountError e) {
	    }
	}
    }
}

• Correct structure for the class. In other words something that looks like:

  class Person implements Financial {
    int cash;
    BankAccount bank;
    // constructor that does something sensible
    // four method declarations that match the ones in the interface
  }
  

  This structure is worth 20 points.
• 10 points: The two methods amount_in_cash and amount_in_bank correctly refer and use the instance variables. There is still quite a bit of confusion between instance variables and local variables.
• 10 points: The method work updates the instance variables, including some kind of comparison with 100, and correctly handles the exception thrown by the method deposit in the bank account.
• 10 points: The method pay catches both exceptions thrown by the method withdraw in the bank account and does something sensible when catching the NotEnoughMoney exception.
• I added an additional 5 points for what I considered perfect solutions.
• I gave significant partial credit to solutions that did not use the BankAccount class at all even though I clarified this point early enough in class.

Problem III

class Lunch {
    Food salad, entree, dessert;

    Lunch () {
        salad = new GreenSalad();
        entree = new Pizza();
        dessert = new IceCream();
    }

    int price () {
        return salad.price() + entree.price() + dessert.price();
    }
}

Solution

abstract class Food {
    abstract int price ();
}

class GreenSalad extends Food {
    int price () { return 3; }
}

class Pizza extends Food {
    int price () { return 9; }
}

class IceCream extends Food {
    int price () { return 2; }
}