CS 3500 Day 7

Object Oriented Design

Today we’re moving onto controllers, the C in MVC.

The controller takes input from the user and decides what to do.

Controllers:

  • Glue of the system
  • Controls how and when the model is used
  • Controls what must be shown to the view and when (in some cases)
  • Controls what action must be taken when user interacts with system (in some cases)
  • Controls the sequence of operations in an application(in some cases)

The view should NEVER talk directly to the model (and vice versa). The controller is the middle man.

MVC Pattern:

  • Model: Offers actual operations

    • Oblivious to when they are needed and how to present results
  • View: Presents results

    • Oblivious to how they are produced or what to do next
  • Controller: Delegates to model and view

    • Oblivious to how model completes the operations or how specifically the view shows output

Our next assignment is going to be the controller of Freecell. Our FreecellController looks like this:

FreeCellController:

  • “Controls” the game
  • Uses the model and the view in specific sequence

    • Determines when to ask for user input
    • Determines when to use which operation of model
    • Determines when to show output to the view
  • The sequence of the game is determined by the controller, not the user

Synchronous Controllers

  • Determines the sequence of operations of the system
  • Determines when and how the system interacts with something external
  • Suitable for pre-baked “rules-based” applications, like games
  • Challenges:

    • How to truly separate controller from view so each one is replacable?
    • What to do when system is reactive in nature (to user input)?

      • User interaction decides program behavior, not controller
      • Examples: Microsoft Word, IntelliJ

Synchronicity happens like 1->2->3->4. There’s an order to events. Synchronous tells the user to do something and then gets input. Asynch gets input and does something.

Asynchronous Controllers

  • Controller gets control when external input is given
  • Controller methods are called as a response to external input
  • Such methods in the controller are called callbacks
  • GUI programs typically work this way

    • User clicks a button, moves the mouse ⇒ a controller method is called
    • In OO GUIs, callbacks are often wrapped in classes called listeners
  • Look at MVCExample code

In most Java projects, the main method creates everything. For example:

public class MainRunner {
   public static void main(String[] args) {
     IModel theModel = makeAModel();
     IView aView = makeAView();
     IController theController = makeController(theModel, aView);
     theController.go();
   }
}

How do we show output? The simplest way is to just use System.out.print. To get input we use a Scanner. Now we’re going an in class example.

public class SimpleCalc1 {
  public static void main(String[] args) {
    int num1, num2;
    Scanner scan = new Scanner(System.in);
    num1 = scan.nextInt();
    num2 = scan.nextInt();
    System.out.printf("%d", num1 + num2);
  }
}

Let’s turn this into an MVC example:

public class SimpleCalc2 {
  public static void main(String[] args) {
    int num1, num2;
    Scanner scan = new Scanner(System.in);
    num1 = scan.nextInt();
    num2 = scan.nextInt();
    System.out.printf("%d", new Calculator().add(num1, num2));
  }
}

class Calculator {
  public int add(int num1, int num2) {
    return num1 + num2;
  }
}

Let’s add a controller:

public class SimpleCalc1 {
  public static void main(String[] args) {
    Calculator model = new Calculator();
    CalcController controller = new CalcController(model);
    controller.go();
  }
}
class CalcController {
  private final Calculator model;

  public CalcController(Calculator model){
    this.model = model;
  }
  public void go(){
    int num1, num2;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    num1 = scan.nextInt();
    System.out.println("Enter another number: ");
    num2 = scan.nextInt();
    System.out.printf("The answer is: %d", model.add(num1, num2));
  }
}
class Calculator {
  public int add(int num1, int num2){
    return num1+num2;
  }
}

Now we’re running into issues with testing. How do you test something that takes input and output? We need to set a System.in and a System.out. In order to make this work we add an input stream and output stream property to our class:

class CalcController {
  private final Calculator model;
  private InputStream input;
  private OutputStream output;

  public CalcController(Calculator model) {
    this.model = model;
    this.input = System.in;
    this.output = System.out;
  }

  public CalcController(Calculator model, InputStream input, OutputStream output) {
    this.model = model;
    this.input = input;
    this.output = output;
  }

	public void go() {
  	  int num1, num2;
  	  Scanner scan = new Scanner(input);
  	  output.println("Enter a number: ");
  	  num1 = scan.nextInt();
  	  output.println("Enter another number: ");
  	  num2 = scan.nextInt();
  	  output.printf("The answer is: %d", model.add(num1, num2));
  	}
}

Now for the test:

public class CalcControllerTest {
  @Test
  public void go() throws Exception {
    Calculator model = new Calculator();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    PrintStream printStream = new PrintStream(baos);
    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("6\n 8\n".getBytes());
    CalcController controller = new CalcController(model, byteArrayInputStream, printStream);
    controller.go();
    assertEquals(baos.toString(), "Enter a number: \n"
            + "Enter another number: \n"
            + "The answer is: 14");
  }

}