Model to Code

// Interface
public void withdraw(float amt) { ... }

// Contract
// Precondition:  amt > 0, amt <= balance
// Postcondition: new balance = old balance - amt

// SavingsAccount extends Account
class Account { ... }
class SavingsAccount extends Account { ... }

// Invoice implements Payable
interface Payable { ... }
class Invoice implements Payable { ... }

public class Account {
  private DebitCard theCard;  // 0..1 = good match for ref

  public DebitCard getCard() { return theCard; }
  public void setCard(DebitCard card) { theCard = card; }
  public void removeCard() { theCard = null; }
}

public void setCard(DebitCard card) {
  if (theCard != null) {
    // throw ImmutableAssociationException
  }
  theCard = card;
}

public Account(Guarantor g) {
  if (g == null) {
    // throw NullLinkError
  }
  theGuarantor = g;  // must have a guarantor
}

Account acc1 = new Account();
Account acc2 = new Account();
DebitCard aCard = new DebitCard(acc1);  // card → acc1
acc2.setCard(aCard);                          // acc2 → card

// PROBLEM: card.theAccount = acc1, but acc2 thinks it owns card!
// Links inconsistent → violates integrity

public class Account {
  private DebitCard theCard;

  public void addCard() {
    // Account handles BOTH creation and reference setting
    theCard = new DebitCard(this);
  }
}

public class Advertiser {
  private Set accounts;

  public Advertiser() {
    accounts = new HashSet();
  }

  public void addAccount(Account a) {
    if (a != null) {
      accounts.add(a);
      a.setOwner(this);   // Maintain bidirectional
    }
  }
}

public class Account {
  private Advertiser owner;  // single ref — many accounts share owner

  public void setOwner(Advertiser newOwner) {
    if (newOwner != null)
      owner.addAccount(this);
  }
}

public class Bank {
  private HashMap<Integer, Account> accounts;

  public Account lookupAccount(int number) {
    return accounts.get(number);
  }

  public void addAccount(Account a) {
    accounts.put(a.getNumber(), a);
  }
}

class Registration {
  private Student student;
  private int mark;

  Registration(Student st) {
    student = st;
    mark = 0;
  }
}

public class Module {
  private List<Registration> registrations;

  public void enrol(Student st) {
    registrations.add(new Registration(st));
  }
}

public class Account {
  // Step 1: define states
  private final int InCredit = 0;
  private final int Overdrawn = 1;
  private final int Suspended = 2;

  private int state;
  private int historyState;
  private double bal;

  // Step 2: initial state in constructor
  public Account() {
    state = InCredit;
  }

  // Step 3: switch on state per operation
  public void withdraw(double amt) {
    switch (state) {
      case InCredit:
        if (amt > bal) state = Overdrawn;
        bal -= amt;
        break;
      case Overdrawn:
      case Suspended:
        break;
    }
  }
}

public void eventF() {  // transition INTO state S
  switch (state) {
    case T:
      doEntry();  // state T → S: trigger S's entry action
      state = S;
      break;
  }
}

public void eventG() {  // transition OUT of state S
  switch (state) {
    case S:
      doExit();   // state S → U: trigger S's exit action
      state = U;
      break;
  }
}