COP 3331 Object Oriented Analysis and Design Chapter 7

1
COP 3331 Object Oriented Analysis and
DesignChapter 7 Design by Abastraction

• Jean Muhammad

2
Overview

• Introduction to Patterns
• Generic Components
• Abstract Coupling

3
Introduction to Patterns

• Design reusable components
• Template method
• Strategy
• Factory
• Iterator

4
Introduction to Patterns

• Design pattern was originally articulated by
  Christopher Alexander and his colleagues to
  describe architectural designs.
• The architectural design of any building can be
  captured in one of 253 patterns.
• Each pattern describes a problem that occurs over
  and over gain in an environment, and then
  describes the core solution.

5
Introduction to Patterns

• Software design patterns are classified into
  three categories
• Creational Patterns
• Structural Patterns
• Behavioral Patterns

6
Introduction to Patterns

• Describing design patterns
• Pattern Name
• Category creational, structural, or behavioral
• Intent
• Also Known As
• Applicability
• Structure
• Participants

7
Generic Components

• Refactoring Refactoring is the process of
  identifying recurring code and organizing/modifyin
  g the code such that it can be used more then
  once.

8
Generic Components

• Refactoring consists of
• Identifying code segments in a program that
  implement the same logic.
• Capturing this logic in a generic component that
  is defined once.
• Restructuring the program so that every occurence
  of the code segment is replaced with a reference
  to the generic component.

9
Generic Components

• Refactoring by Inheritance
• class Common
• void computeAll (. . . )
• computeStep1()
• computeStep2()
• computeStep3()
• class ComputationA class
  ComputationB
• extends Common
  extends Common
• void method1(. . .) void
  method2(. . .)
• computeAll()
  computeAll()

10
Generic Components

• Refactoring by Delegation
• To refactor the recurring code sequence in the
  previous example using delegation, we introduce a
  helper class instead of inheritance.

11
Generic Components

• class Helper
• void computeAll (. . . )
• computeStep1()
• computeStep2()
• computeStep3()
• class ComputationA class
  ComputationB
• void compute(. . .) void
  compute(. . .)
• helper.computeAll()
  helper.computeAll()
• Helper helper Helper
  helper

12
Template Method

• Use of an abstract class that serves as a
  template for classes with shared functionality.
• An abstract class contains behavior common to all
  of its subclasses.
• The common behavior is captured in non-abstract
  methods.
• Using abstract classes ensures that all
  subclasses will inherit the same behavior.

13
Strategy Pattern

• The strategy pattern can be considered as a
  variation of the Template method
• The hood method and template method reside in
  different classes.
• The abstract methods declared in the Strategy
  class are the hood methods.
• The methods in the Context class that call the
  hook methods are the template methods.

14
Strategy Pattern

• Strategy Pattern should be used when
• Many related classes differ only in their
  behavior
• Different variations of an algorithm are needed.
• An algorithm uses data that clients should not
  know about.
• A class defines many behaviors, which appear as
  multiple conditional statements in a method.

15
Abstract Coupling

• The strategy pattern is an example of abstract
  coupling. A client accesss a service through an
  interface or an abstract class without knowing
  the actual concrete class that provided the
  service.

16
Abstract Coupling
Customer
Service Provider A
Customer
Service Provider B
Customer
Service Provider C
Example of Direct Coupling No Abstraction
17
Abstract Coupling
Service Provider A
Standard Service Protocol
Customer
Service Provider B
Service Provider C
Abstract Coupling Any customer calls the
Standard Service Protocol and the correct
interface is automatically used.