OOP Design Patterns

1
OOP Design Patterns

• Chapters 13-16

2
Design Patterns

• The main idea behind design patterns is to
  extract the high level interactions between
  objects and reuse their behaviors from
  application to application.
• They were inspired by an architect, Christopher
  Alexander, discussing the way that architectural
  design has patterns of its own
• Each pattern describes a problem which occurs
  over and over again in our environment, and then
  describes the core of the solution to that
  problem, in such a way that you can use this
  solution a million times over, without ever doing
  it the same way twice. A Timeless Way of Building
  

3
MVC Design Patterns

• Model-View-Controller (MVC)
• A collection of simpler patterns that are
  incredibly useful.
• Using MVC, you think of the application in terms
  of these three modules -
• Model The core of the application. This
  maintains the state and data that the application
  represents. When significant changes occur in the
  model, it notifies all of its views
• Controller The user interface presented to the
  user to manipulate the application.
• View The user interface which displays
  information about the model to the user. Any
  object that needs information about the model
  needs to be a registered view with the model.

4
MVC Advantages

• MVC decouples the model, view, and controller
  from each other to increase flexibility and
  reuse.
• You can attach multiple views to the model
  without rewriting it.
• You can change the way a view responds to user
  input without changing the visual presentation.
  For example, you might use a pop-up menu instead
  of keyboard command keys.

5
MVC Design Patterns

• MVC decouples views and model by establishing a
  subscribe/notify protocol which is an example of
  the Observer design pattern.
• Observer
• Problem How do you allow two or more
  independent and loosely coupled objects to change
  in synchrony with each other?
• Solution Maintain a list of objects that are
  tied, or dependent, on another object. When the
  target object changes, the dependents, or
  observers, are notified that they should update
  themselves.

6
Observer Design Pattern

• Examples
• User interface components that permit interaction
  (buttons, scrollbar, etc.) maintain a collection
  of listener objects.
• We can dynamically add or remove listener objects
  as long as they satisfy an interface.
• When the state of the GUI component changes, each
  of the listeners is notified of a change.

7
Observer Design Pattern

• The class library Observable represents objects
  that can be observed.
• the equivalent of the GUI component in AWT
• What would be observed in the MVC architecture?
• Objects wishing to be observed can either
• subclass Observable, or
• have an Observable instance variable
• Other objects can implement the Observer
  interface which correspond to the listeners
• An Observer registers itself with the object
  being observed.
• The Observable object invokes notifyObservers()
  at any time to indicate that it has changed
  state.
• notifyObservers() causes each observer to be sent
  a message update(Observable, Object), where
• first argument is the observable that changed
• second argument is optional, but usually provides

8
Observer Design Pattern

• Look at code for HeartBeat example

9
MVC Design Patterns

• MVC also lets you change the way a view responds
  to user input without changing its visual
  presentation
• A view uses an instance of a Controller subclass
  to implement a particular response strategy
• To implement a different strategy, simply replace
  the instance with a different kind of controller
• e.g., a view can be disabled so that it does
  not accept input simply by giving it a controller
  that ignores input events
• The view-controller relationship is an example of
  the Strategy design pattern.

10
Strategy Design Pattern

• Problem How do you allow the algorithm that is
  used to solve a particular problem to be easily
  and dynamically changed by the client?
• Solution Define a family of algorithms with a
  similar interface. Each algorithm provides a
  different strategy for solving the problem at
  hand. Encapsulate each algorithm, and let the
  client select the strategy to be used in any
  situation.

11
Strategy Design Pattern

• Example the creation of layout managers in the
  AWT
• rather that coding in the component library
  (e.g., frame, panel, etc.) the details of how
  items are laid out on the screen, these decisions
  are left to the layout manager.
• an interface for LayoutManager is defined
• the activities of the GUI components (e.g.,
  frame, panel, etc.) are independent of the layout
  manager being used.

12
MVC Design Patterns

• MVC views can be nested
• Nested views is supported with the CompositeView
  class which is a subclass of the View class
• CompositeView objects act just like View objects,
  except they also contain and manage nested views.