OOP Design Patterns

Chapters 13-16

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

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 : model

The user interface which displays information about the

model

to the user. Any object that needs information about the needs to be a registered

view

with the

model

.

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.

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.

•

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.

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

Observer Design Pattern

• Look at code for HeartBeat example

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.

•

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.

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.

holds

Container LayoutManager

inherits

Application

implements

GridLayout

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.