Week 7 [Fri, Feb 19th] - Topics

import java.util.*;

public class Manager {
    private ArrayList<Account> theAccounts;

    public void addAccount(Account acc) throws Exception {
        if (theAccounts.size() == 8) {
            throw new Exception("adding more than 8 accounts");
        }
        
        if (!theAccounts.contains(acc)) {
            theAccounts.add(acc);
        }
    }

    public void removeAccount(Account acc) {
        theAccounts.remove(acc);
    }
}

public class Marriage {
    private Man husband = null;
    private Woman wife = null;

    // extra information like date etc can be added

    public Marriage(Man m, Woman w) throws Exception {
        if (m == null || w == null) {
            throw new Exception("no man/woman");
        }
        if (m.isMarried() || w.isMarried()) {
            throw new Exception("already married");
        }
        husband = m;
        m.enterMarriage(this);
        wife = w;
        w.enterMarriage(this);
    }

    public Man getHusband() throws Exception {
        if (husband == null) {
            throw new Exception("error state");
        } else {
            return husband;
        }
    }

    public Woman getWife() throws Exception {
        if (wife == null) {
            throw new Exception("error state");
        } else {
            return wife;
        }
    }

    // removal of both ends of 'Marriage'
    public void divorce() throws Exception {
        if (husband == null || wife == null) {
            throw new Exception("no marriage");
        }
        husband.removeFromMarriage(this);
        husband = null;
        wife.removeFromMarriage(this);
        wife = null;
    }
} 

class Account {
    private Guarantor myGuarantor; // should not be public

    public Account(Guarantor g) {
        if (g == null) {
            haltWithErrorMessage(“Account must have a guarantor”);
        }
        myGuarantor = g;
    }
    // there should not be a setGuarantor method
}

False

Explanation: While the design requires a City to be connected to exactly one Country, the code allows it to be connected to zero Country objects (by passing null to the setCountry() method).

In this solution, assume Regions can be created without Players (note that you cannot be 100% defensive all the time). The usage will be something like this:

Region r1 = new Region();
Player p1 = new Player(r1);
Region r2 = new Region();
Player p2 = new Player(r2);
p1.setRegion(r2);
r1.setPlayer(p2);

Here are the two classes. Get methods are omitted as they are simple. Note how much extra effort you need to be defensive.

public class Region {
    private Player myPlayer;

    public Region() {
        // initialise region
    }

    public void setPlayer(Player newPlayer) {
        if (newPlayer == null) {
            stopSystemWithErrorMessage("Multiplicity violation");
        }
        if (myPlayer == newPlayer) {
            return; // same player
        }
        if (myPlayer != null) {
            // I already have a Player!
            myPlayer.removeRegion(this);
        }
        myPlayer = newPlayer;
        // set the reverse link
        myPlayer.setRegion(this);
    }

    public void removePlayer(Player disconnectingPlayer) {
        if (myPlayer == disconnectingPlayer) {
            myPlayer = null;
        } else {
            stopSystemWithErrorMessage("Unknown Player trying to disconnect");
        }
    }

    private void stopSystemWithErrorMessage(String msg) {
        ...
    }
}

public class Player {
    private Region myRegion;

    public Player(Region region) {
        setRegion(region);
    }

    public void setRegion(Region newRegion) {
        if (newRegion == null) {
            stopSystemWithErrorMessage("Multiplicity violation");
        }
        if (myRegion == newRegion) {
            return; // no change in Region!
        }
        if (myRegion != null) {
            // previous region exists
            myRegion.removePlayer(this);
        }
        myRegion = newRegion;
        
        // set the reverse link
        myRegion.setPlayer(this);
    }

    public void removeRegion(Region disconnectingRegion) {
        if (myRegion == disconnectingRegion) {
            myRegion = null;
        }
    }

    private void stopSystemWithErrorMessage(String msg) {
        ...
    }
}

Note that the above code stops the system when the multiplicity is violated. Alternatively, you can throw an exception and let the caller handle the situation.

The code below contains a method in the Bank class to create an account; the bank field in the new account is thereby filled by the bank creating it.

Assume that once an Account has been assigned to a Bank, it cannot be assigned to a different Bank. Once the Account is removed from the Bank, it will not be used anymore (hence, no need to remove the link from Account to Bank).

public class Account {
    private int accNumber;
    private Bank theBank;

    public Account(int n, Bank b) {
        accNumber = n;
        theBank = b;
    }
    public int getNumber() {
        return accNumber;
    }
    public Bank getBank() {
        return theBank;
    }
}

import java.util.*;

public class Bank {
    private HashMap<Integer, Account> theAccounts = new HashMap<Integer, Account>();

    public void createAccount(int n) {
        addAccount(new Account(n, this));
    }
    public void addAccount(Account a) {          
        theAccounts.put(a.getNumber(), a);
    }
    public void removeAccount(int accNumber) {
        theAccounts.remove(accNumber);
    }
    public Account lookupAccount(int accNumber) {
        return theAccounts.get(accNumber);
    }
}

(a) Yes. Each link is mutable and unidirectional. A simple reference variable is suitable to hold the link.

The Teacher class can be made even more defensive by introducing a resetFavoriteStudent() method to unlink the current favorite student from a teacher. In that case, the setFavoriteStudent(Student) method should not accept null. This approach is more defensive because it prevents a null value being passed to setFavoriteStudent(Student) by mistake and being interpreted as a request to de-link the current favorite student from the Teacher object.

(b) First diagram has unidirectional links. Second has a bidirectional link. RI is only applicable to the second.

(c)

void removeMember(Member m) {
    if (m==null) {
        throw exception("this is null, not a member!");
    } else if (member_count == 10) {
        throw exception("we need at least 10 members to survive!");
    } else if (!isMember(m)) {
        throw exception("this fellow is not a member of our club!");
    } else {
        members.remove(m); // members is a data structure such as ArrayList
    }
}

True

Explanation: Bidirectional associations require two objects to link to each other. When one of these links is not consistent with the other, you have a referential integrity violation.

(a)(b)(c)(d)(e)

Explanation: Defensive programming requires a lot more checks, possibly making the code longer, more complex, and slower. Use it only when benefits outweigh costs, which is often.

(a)(b)(c)

Explanation: DbC is not an alternative to OOP. You can use DbC in an OOP solution.