CSC/ECE 517 Fall 2010/ch7 7d EC

Introduction to Design Patterns

A design pattern is a type of technique that developers use to create good software design. There are many design patterns available, and they share common benefits. The benefits of design patterns include [1] :

     1. Code is more accessible and understandable.
     2. Use of common vocabulary to help collaboration among developers.
     3. Helps people understand the system more quickly.
     4. Easier to modify system.

GRASP

GRASP stands for General Responsibility Assignment Software Patterns and consists of several design patterns for assigning responsibility and relationships between classes and objects in object-oriented design.

Some of the patterns in GRASP include Information Expert, Creator, Controller, Low Coupling, High Cohesion, Polymorphism, Pure Fabrication, Indirection, and Protected Variations [2].

In this article, we will focus on the Indirection Pattern.

The Indirection Pattern

The Indirection Pattern supports low coupling and code reuse by using a mediator object in between two objects.

A very simple diagram below illustrates the relationship between objects in the indirection pattern.


The relationship between classes in indirection pattern.

In the indirection pattern, a mediator class acts as a proxy in between the client and provider classes. The client interfaces with the mediator, not to the provider. The client accesses functionality from the provider through the mediator. Therefore, the relationship between the client and provider is indirect.

The indirection pattern is seen all of the time. Anytime the programmer accesses an API, be it for operating system call, graphics library call, the programmer is interfacing with a mediator that provides functionality on behalf of the client to some lower-level hardware functionality provided by the operating system or graphics library, etc.

A simple example of the indirection pattern is illustrated below.

Example of Indirection Pattern

Let's say we have a talking robot, and the functionality to get the robot to say a specified string has already been implemented in the code below.

class RobotController {
     void say(String s) {
       // Some complex code for robot to say 's'
     }
 }<br>

We want to create another class that has methods to say common phrases like “hello” and “goodbye”.

class RobotPhrases { 
     RobotController r = new RobotController();
     
     void sayHello() { 
       r.say(“Hello”); 
     } 
     
     void sayGoodbye() {
	 r.say(“Goodbye”);
     }
 }

In the main function, we would do the following:

public class Main {
     public static void main(String[] args) {
         RobotPhrases rp = new RobotPhrases();
         rp.sayHello();
	   rp.sayGoodbye();
     }

 }