SE450: Lecture 4 (Structural Patterns)

You have one and a half hours to take the exam.
If a question is unclear or ambiguous, write down your assumptions.
The exam is closed book and closed notes.
You may consult one letter-size page (front and back) of notes that you have prepared.
Write your answers on the exam. If I can not read your answer clearly, it will be marked as incorrect.
You will find some information on Java APIs, junit, and design patterns at the end of the exam.
When drawing UML class diagrams, follow these guidelines:
- Be specific (prefer aggregation and dependency to association, prefer composition to aggregation).
- Show mutiplicities on aggregations and compositions.
- Be careful with arrowheads and with dashed/solid lines.
- Clearly distinguish classes and interfaces.
- Clearly indicate static classes.

Here is a syllabus for the exam.

+ UML Object Diagrams
  - objects (fields with value)
  - relations
    * link

+ UML Sequence Diagrams
  - objects (lifetime) (also static classes)
  - method/constructor call (lifetime and arguments)
  - method/constructor return (value)

+ UML Class Diagrams
  - classes (fields and methods with type and visibility)
  - interfaces (methods with type and visibility)
  - big arrow relations (triangular arrowhead)
    * specialization
    * realization
  - small arrow relations
    * aggregation
    * composition
    * dependency

+ Simple Idioms and OO programming techniques (using java)
  - packages
  - interfaces
  - classes
  - constructors
  - delegation
  - inner classes
  - static versus object classes
  - immutable data classes
  - mutable data classes
  - data object methods (equals, hashCode, compareTo, ...)
  - collection classes

+ Patterns
  - static factory
  - builder
  - command
  - strategy
  - state
  - composite

Looking Back: OO Mechanisms [2/24]

Interface: Primitive for describing the type or interface of an object.

Class: Primitive for describing implementation of an object.

Constructor: Primitive construct for building objects.

Delegation: (Partial) responsibility for a message is given to another object.

Subclassing: (Partial) responsibility for a message is given to a class other than the actual class of the object. [Not covered on midterm, except with respect to Object]

Looking Back: Basic Concepts [3/24]

Immutable Data Class: Unchanging data (eg, String).

Mutable Data Class: Changing data (eg, an Employee class that contains salary information).

Collection Class: A collection. May be mutable or immutable.

Looking Back: System Architecture [4/24]

MVC lite: Separate IO from business logic.

Looking Back: Controlling the number of instances [5/24]

Static Class: A set of global variables and functions.

Looking Back: Creating instances [6/24]

Static Factory: a static class whose purpose is to generate instances of an interface (or interfaces). The interface and factory are public, but the implementing classes are not.

Builder: A mutable object used to build an immutable object. Add pieces to the builder gradually, then convert to its immutable representation (eg, StringBuilder).

Looking Back: Structuring Behavior [7/24]

Command: Encapsulate a function as an object. The command can then be accessed from many places. It may also support undo/redo.

Strategy: Encapsulate variation into a separate object. A method accesses the variation (strategy) by delegating to a field or parameter.

State: Create the illusion that an object changes its actual type (using delegation to a field). A nice way to eliminate case statments.

Looking Back: Collections [8/24]

Composite: Make collections of objects have the same interface as single objects.

Looking Back: Homework 3 [9/24]

Homework 3
code [source]
public javadoc
package-private javadoc

Composite: The Composite Pattern [10/24]

Allow collections to be treated the same as single objects.

Define a typed tree.

Here is an object diagram from the GOF:

Here is a class diagram from the GOF:

Composite: An example [11/24]

Here is an object diagram from the GOF:

Here is a class diagram from the GOF:

Composite: Example [12/24]

I will discuss these notes.

file:composite/one/Main.java [source] [doc-public] [doc-private]

package composite.one;
public class Main {
  public static void main(String[] args) {
    Expr one = new Const(1);
    Expr onePtwo = new Plus (new Const(1), new Const(2));
    Expr threeMfour = new Mult (new Const(3), new Const(4));
    Expr m = new Minus (onePtwo, threeMfour);
    Expr n = new Quot (m, new Const(5));

    System.out.println(n);
    System.out.println("Value: " + n.eval());
  }
}

file:composite/one/Expr.java [source] [doc-public] [doc-private]

package composite.one;
public interface Expr {
  int eval();
}

final class Const implements Expr {
  private final int v;
  public Const(int v) {
    this.v = v;
  }
  public int eval() {
    return v;
  }
  public String toString() {
    return Integer.toString(v);
  }
}

final class Plus implements Expr {
  private final Expr l;
  private final Expr r;
  public Plus(Expr l, Expr r) {
    if ((l == null) || (r == null)) {
      throw new IllegalArgumentException();
    }
    this.l = l;
    this.r = r;
  }
  public int eval() {
    return l.eval() + r.eval();
  }
  public String toString() {
    return l.toString() + " " + r.toString() + " +";
  }
}

final class Minus implements Expr {
  private final Expr l;
  private final Expr r;
  public Minus(Expr l, Expr r) {
    if ((l == null) || (r == null)) {
      throw new IllegalArgumentException();
    }
    this.l = l;
    this.r = r;
  }
  public int eval() {
    return l.eval() - r.eval();
  }
  public String toString() {
    return l.toString() + " " + r.toString() + " -";
  }
}

final class Mult implements Expr {
  private final Expr l;
  private final Expr r;
  public Mult(Expr l, Expr r) {
    if ((l == null) || (r == null)) {
      throw new IllegalArgumentException();
    }
    this.l = l;
    this.r = r;
  }
  public int eval() {
    return l.eval() * r.eval();
  }
  public String toString() {
    return l.toString() + " " + r.toString() + " *";
  }
}

final class Quot implements Expr {
  private final Expr l;
  private final Expr r;
  public Quot(Expr l, Expr r) {
    if ((l == null) || (r == null)) {
      throw new IllegalArgumentException();
    }
    this.l = l;
    this.r = r;
  }
  public int eval() {
    return l.eval() / r.eval();
  }
  public String toString() {
    return l.toString() + " " + r.toString() + " /";
  }
}

Composite: Variations [13/24]

Using a static factory
Refactor to strategy (binary operations all have same form)
nary ops. What if Plus and Mult take any number of operands? Need an add method on the composite.
Using Builder for nary ops
Mutable Composites
- put add in interface
- use two interfaces

Composite: With a static factory [14/24]

file:composite/two/Main.java [source] [doc-public] [doc-private]

package composite.two;
public class Main {
  public static void main(String[] args) {
    Expr one = ExprFactory.newConst(1);
    Expr onePtwo = ExprFactory.newPlus
        (ExprFactory.newConst(1), ExprFactory.newConst(2));
    Expr threeMfour = ExprFactory.newMult
        (ExprFactory.newConst(3), ExprFactory.newConst(4));
    Expr m = ExprFactory.newMinus (onePtwo, threeMfour);
    Expr n = ExprFactory.newQuot (m, ExprFactory.newConst(5));

    System.out.println(n);
    System.out.println("Value: " + n.eval());
  }
}

file:composite/two/Expr.java [source] [doc-public] [doc-private]
01 02 03 04
package composite.two;
public interface Expr {
  int eval();
}

file:composite/two/ExprFactory.java [source] [doc-public] [doc-private]

package composite.two;
public class ExprFactory {
  private ExprFactory() {}
  static public Expr newConst(int v) {
    return new Const(v);
  }
  static public Expr newPlus(Expr l, Expr r) {
    return new Plus(l, r);
  }
  static public Expr newMinus(Expr l, Expr r) {
    return new Minus(l, r);
  }
  static public Expr newMult(Expr l, Expr r) {
    return new Mult(l, r);
  }
  static public Expr newQuot(Expr l, Expr r) {
    return new Quot(l, r);
  }

  private static class Const implements Expr {
    private final int v;
    public Const(int v) {
      this.v = v;
    }
    public int eval() {
      return v;
    }
    public String toString() {
      return Integer.toString(v);
    }
  }

  private static class Plus implements Expr {
    private final Expr l;
    private final Expr r;
    public Plus(Expr l, Expr r) {
      if ((l == null) || (r == null)) {
        throw new IllegalArgumentException();
      }
      this.l = l;
      this.r = r;
    }
    public int eval() {
      return l.eval() + r.eval();
    }
    public String toString() {
      return l.toString() + " " + r.toString() + " +";
    }
  }

  private static class Minus implements Expr {
    private final Expr l;
    private final Expr r;
    public Minus(Expr l, Expr r) {
      if ((l == null) || (r == null)) {
        throw new IllegalArgumentException();
      }
      this.l = l;
      this.r = r;
    }
    public int eval() {
      return l.eval() - r.eval();
    }
    public String toString() {
      return l.toString() + " " + r.toString() + " -";
    }
  }

  private static class Mult implements Expr {
    private final Expr l;
    private final Expr r;
    public Mult(Expr l, Expr r) {
      if ((l == null) || (r == null)) {
        throw new IllegalArgumentException();
      }
      this.l = l;
      this.r = r;
    }
    public int eval() {
      return l.eval() * r.eval();
    }
    public String toString() {
      return l.toString() + " " + r.toString() + " *";
    }
  }

  private static class Quot implements Expr {
    private final Expr l;
    private final Expr r;
    public Quot(Expr l, Expr r) {
      if ((l == null) || (r == null)) {
        throw new IllegalArgumentException();
      }
      this.l = l;
      this.r = r;
    }
    public int eval() {
      return l.eval() / r.eval();
    }
    public String toString() {
      return l.toString() + " " + r.toString() + " /";
    }
  }
}

Composite: Refactor to Strategy [15/24]

file:composite/three/ExprFactory.java [source] [doc-public] [doc-private]

package composite.three;

public class ExprFactory {
  private ExprFactory() {}
  static public Expr newConst(int v) {
    return new Const(v);
  }
  static public Expr newPlus(Expr l, Expr r) {
    return new BinOp(l, new OpAdd(), r);
  }
  static public Expr newMinus(Expr l, Expr r) {
    return new BinOp(l, new OpSub(), r);
  }
  static public Expr newMult(Expr l, Expr r) {
    return new BinOp(l, new OpMul(), r);
  }
  static public Expr newQuot(Expr l, Expr r) {
    return new BinOp(l, new OpDiv(), r);
  }

  private static final class Const implements Expr {
    private final int v;
    public Const(int v) {
      this.v = v;
    }
    public int eval() {
      return v;
    }
    public String toString() {
      return Integer.toString(v);
    }
  }

  private static final class BinOp implements Expr {
    private final Expr l;
    private final Expr r;
    private final Op op;
    public BinOp(Expr l, Op op, Expr r) {
      if ((l == null) || (op == null) || (r == null)) {
        throw new IllegalArgumentException();
      }
      this.op = op;
      this.l = l;
      this.r = r;
    }
    public int eval() {
      return op.run(l.eval(), r.eval());
    }
    public String toString() {
      return l.toString() + " " + r.toString() + " " + op.toString();
    }
  }

  private static interface Op {
    public abstract int run(int x, int y);
  }
  private static final class OpAdd implements Op {
    public String toString() { return "+"; }
    public int run(int x, int y) { return x+y; }
  }
  private static final class OpSub implements Op {
    public String toString() { return "-"; }
    public int run(int x, int y) { return x-y; }
  }
  private static final class OpMul implements Op {
    public String toString() { return "*"; }
    public int run(int x, int y) { return x*y; }
  }
  private static final class OpDiv implements Op {
    public String toString() { return "/"; }
    public int run(int x, int y) { return x/y; }
  }
}

Composite: Refactor to template method [16/24]

file:composite/three/ExprFactory2.java [source] [doc-public] [doc-private]

package composite.three;

public class ExprFactory2 {
  private ExprFactory2() {}
  static public Expr newConst(int v) {
    return new Const(v);
  }
  static public Expr newPlus(Expr l, Expr r) {
    return new PlusOp(l, r);
  }
//  static public Expr newMinus(Expr l, Expr r) {
//    return new BinOp(l, new OpSub(), r);
//  }
//  static public Expr newMult(Expr l, Expr r) {
//    return new BinOp(l, new OpMul(), r);
//  }
//  static public Expr newQuot(Expr l, Expr r) {
//    return new BinOp(l, new OpDiv(), r);
//  }

  private static final class Const implements Expr {
    private final int v;
    public Const(int v) {
      this.v = v;
    }
    public int eval() {
      return v;
    }
    public String toString() {
      return Integer.toString(v);
    }
  }

  private static abstract class BinOp implements Expr {
    private final Expr l;
    private final Expr r;
    private final String opString;
    public BinOp(Expr l, String opString, Expr r) {
      if ((l == null) || (r == null)) {
        throw new IllegalArgumentException();
      }
      this.l = l;
      this.r = r;
      this.opString = opString;
    }
    protected abstract int run (int x, int y);
    // to be template method, there must a template method
    // template method = method of abstract class, that calls an abstract method
    public int eval() {
      return this.run(l.eval(), r.eval());
    }
    public String toString() {
      return l.toString() + " " + r.toString() + " " + opString;
    }
  }
  private static final class PlusOp extends BinOp {
    public PlusOp(Expr l, Expr r) { super (l, "+", r); }
    public int run(int x, int y) { return x+y; }
  }
}

Composite: N-ary Ops [17/24]

file:composite/four/Main.java [source] [doc-public] [doc-private]

package composite.four;
public class Main {
  public static void main(String[] args) {
    Expr onePtwo = ExprFactory.newPlus
        (ExprFactory.newConst(1), ExprFactory.newConst(2));

    ExprBuilder eb = ExprFactory.newMultBuilder();
    eb.add(ExprFactory.newConst(3));
    eb.add(ExprFactory.newConst(4));
    eb.add(onePtwo);
    Expr multiplies = eb.toExpr();
    Expr m = ExprFactory.newMinus (onePtwo, multiplies);

    System.out.println(m);
    System.out.println("Value: " + m.eval());
  }
}

file:composite/four/ExprBuilder.java [source] [doc-public] [doc-private]
01 02 03 04 05
package composite.four;
public interface ExprBuilder {
  Expr toExpr();
  void add(Expr e);
}

file:composite/four/ExprFactory.java [source] [doc-public] [doc-private]

package composite.four;
import java.util.List;
import java.util.LinkedList;

public class ExprFactory {
  private ExprFactory() {}
  static public Expr newConst(int v) {
    return new Const(v);
  }
  static public Expr newPlus(Expr l, Expr r) {
    return new BinOp(l, new OpAdd(), r);
  }
  static public Expr newMinus(Expr l, Expr r) {
    return new BinOp(l, new OpSub(), r);
  }
  static public Expr newMult(Expr l, Expr r) {
    return new BinOp(l, new OpMul(), r);
  }
  static public Expr newQuot(Expr l, Expr r) {
    return new BinOp(l, new OpDiv(), r);
  }
  static public ExprBuilder newPlusBuilder() {
    return new NaryOpBuilder(new OpAdd(), new Const(0));
  }
  static public ExprBuilder newMultBuilder() {
    return new NaryOpBuilder(new OpMul(), new Const(1));
  }
}

final class Const implements Expr {
  private final int v;
  public Const(int v) {
    this.v = v;
  }
  public int eval() {
    return v;
  }
  public String toString() {
    return Integer.toString(v);
  }
}

final class BinOp implements Expr {
  private final Expr l;
  private final Expr r;
  private final Op op;
  public BinOp(Expr l, Op op, Expr r) {
    if ((l == null) || (op == null) || (r == null)) {
      throw new IllegalArgumentException();
    }
    this.op = op;
    this.l = l;
    this.r = r;
  }
  public int eval() {
    return op.eval(l.eval(), r.eval());
  }
  public String toString() {
    return l.toString() + " " + r.toString() + " " + op.toString();
  }
}

final class NaryOp implements Expr {
  private final Expr[] args;
  private final Expr zero;
  private final Op op;
  public NaryOp(Expr[] args, Op op, Expr zero) {
    // Don't need to test these, since the builder checks them.
    //     if ((args == null) || (op == null) || (zero == null))
    //       throw new IllegalArgumentException();
    //     for (int i=0; i<args.length; i++)
    //       if (args[i] == null)
    //         throw new IllegalArgumentException();
    this.op = op;
    this.args = args;
    this.zero = zero;
  }
  public int eval() {
    int result = zero.eval();
    for (int i=0; i<args.length; i++)
      result = op.eval(result, args[i].eval());
    return result;
  }
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("[");
    for (int i=0; i<args.length; i++) {
      sb.append(args[i].toString());
      if (i+1<args.length)
        sb.append(", ");
    }
    sb.append("]");
    sb.append(op.toString());
    sb.append(" ");
    return sb.toString();
  }
}

final class NaryOpBuilder implements ExprBuilder {
  private final List<Expr> args;
  private final Expr zero;
  private final Op op;
  public NaryOpBuilder(Op op, Expr zero) {
    if ((op == null) || (zero == null))
      throw new IllegalArgumentException();
    this.args = new LinkedList<Expr>();
    this.op = op;
    this.zero = zero;
  }
  public void add(Expr e) {
    if (e == null)
      throw new IllegalArgumentException();
    args.add(e);
  }
  public Expr toExpr() {
    return new NaryOp(args.toArray(new Expr[0]), op, zero);
  }
}

interface Op {
  public abstract int eval(int x, int y);
}
final class OpAdd implements Op {
  public String toString() { return "+"; }
  public int eval(int x, int y) { return x+y; }
}
final class OpSub implements Op {
  public String toString() { return "-"; }
  public int eval(int x, int y) { return x-y; }
}
final class OpMul implements Op {
  public String toString() { return "*"; }
  public int eval(int x, int y) { return x*y; }
}
final class OpDiv implements Op {
  public String toString() { return "/"; }
  public int eval(int x, int y) { return x/y; }
}

State: An example [18/24]

Remember the awful finite state machine from Homework 3?

file:Control.java [source] [doc-public] [doc-private]

Here is a version refactored to the state pattern:

file:Control.java [source] [doc-public] [doc-private]

package state.ui.main;

import state.ui.UI;
import state.ui.UIMenu;
import state.ui.UIMenuBuilder;

class Control {
  final State EXITED;
  final State EXIT;
  private State state;
  Control(UI ui) {
    EXITED = new ExitedState();
    EXIT = new ExitState(this,ui);
    state = EXIT;
  }

  void run() {
    while (state != EXITED) {
      state = state.run();
    }
  }
}

interface State {
  public State run();
}

final class ExitedState implements State {
  public State run() {
    return this;
  }
}

final class ExitState implements State {
  Control control;
  UI ui;
  UIMenu m;
  ExitState(Control control, UI ui) {
    this.control = control;
    this.ui = ui;

    UIMenuBuilder mb;
    mb = new UIMenuBuilder();

    //mb.add("Default", new UIMenuAction() { public Object run() {return this;} });
    mb.add("Default", () -> this);
    mb.add("Yes", () -> control.EXITED);
    mb.add("No", () -> control.EXIT);
    this.m = mb.toUIMenu("Are you sure you want to exit?");
  }
  public State run() {
    return (State) ui.processMenu(m);
  }
}

Full code: dir:state/ui [source]

State: General form [19/24]