• View
• Edit
• History
• Print

Object Design and Design Patterns

A Software Engineering Lecture by Steven Choy

Lecture Overview: In this lecture, we start to learn object design and design patterns.

Object design is about identifying additional solution-domain objects and refining existing objects. Object design includes the following activities:

• Reuse : use inheritance and composition/delegation, identify off-the-shelf framework, and apply design patterns
• Service specification : describe interface of classes precisely
• Restructuring : transform the object model to increase code reuse or meet other design goals such as readability and maintainability
• Optimization address performance goals such as response time and throughput

Design patterns take the reuse concept a step further. A design pattern encapsulates a specific way that a number of different objects work together. Different design patterns can be applied in certain situations to achieve specific benefits.

Reading: Chapter 8 of the textbook Object Design: Reusing Pattern Solutions

Where are we now?

Object Design Overview

Deliverables of System Analysis

Application Domain Object vs Solution Domain Object

• Application Domain Objects
  • Represent concepts of the domain that are relevant to the system.
  • They are identified by the application domain specialists and by the end users.
• Solution Domain Objects
  • Represent concepts that do not have a counterpart in the application domain
  • They are identified by the developers

Example

Object Design Activities

• Reuse (Covered in this lecture)
  • Use of Inheritance and Composition/Delegation
  • Identify Off-the-shelf framework
  • Design Patterns
• Interface Specification (Covered later)
  • Describe interface of classes precisely
• Restructuring (Covered later)
  • Transform the object model to increase code reuse or meet other design goals such as readability and maintainability
• Optimization (Covered later)
  • Address performance goals such as response time and throughput

Main topics in this lecture

• Reuse Concepts
• Use of Inheritance
• Inheritance vs Composition
• Design Patterns (next lecture)
  • Creational Pattern
  • Structural Pattern
  • Behavioral Pattern

Reuse Concepts

Why Reuse?

• Business requirements are always changing. The system you design for today may not be the same for tomorrow.
• You can't say "No, my system is not designed for that business requirement."
• You don't want to rewrite your system when there are some new requirements raise up.
• ⇒ The need for reusable and flexible design.

Reuse of Classes

• Two fundamental ways of reuse:
  • The use of inheritance
  • The use of composition

Inheritance Overview

• Inheritance is one of merits of OO Design
• Extend from a Base Class
  • Add in new operations
  • Overwrite the existing operations
  • Reuse operations in the base class
• Promote code reuse, reduce redundancy and make your class extensible

Composition Overview

• An alternative to inheritance for code reuse
• Implementation view: Class A holds an instance of Class B . Class A can call on methods of Class B.

Example

Inheritance Problem

• The Ripple Effect: A change in Base Class may lead to change of other subclasses
• Example: Modify an interface in base class may result compilation failure of the subclasses

Inheritance Problem Example

• What if the return value of getSalary() method is change?

The Composition Alternative

• For the inheritance problem, what if composition is used for code reuse?

Inheritance or Composition?

• When using inheritance, make sure the base class and subclass has a is-a relationship.
• Generally, favor composition over inheritance for code reuse.
• Composition helps you keep each class encapsulated.

Design Pattern

A little bit History

• Pattern is not firstly adopted by software experts
• In 1970s, Christopher Alexander wrote a number of books about patterns in architecture and civil engineering

• Software engineers inspired by the pattern principle and applied it in software design
• Pattern in software were popularized by the book "Design Patterns: Elements of Reusable Object-Oriented Software", written by Gang of Four or GoF

What's Design Pattern?

• Design patterns are recurring solutions to design problems you see over and over again [Alpert, et al.,1998]
• Design patterns constitute a set of rules describing how to accomplish certain tasks in the realm of software development [Pree, 1994]
• Design patterns are template solutions that developrs have refined over time to solve a range of recurring problems [Gamma et al., 1994]

Pattern Characteristics

• Patterns are not created but observed through experience
• Patterns avoid you to re-invent the wheel
• Patterns are reusable artifacts
• Patterns undergo continuous improvement
• Patterns can be used together to solve larger problem

Benefits of Using Patterns

• Reuse proven solutions
  • You do not need to reinvent your wheel
  • The best solution is already there
• Establish common vocabulary
  • Pattern provides developers a common point of reference to communicate design
• Have a higher perspective on analysis and design
  • Free you from dealing with details too early
• Improve flexibility of your code

"Gang of Four" Design Patterns

• The GoF revealed a total of 23 design patterns and categorized them
• Creational Patterns
  • Patterns that are for object creations
  • But rather than just instantiate objects directly, they defines the best ways to create objects
• Structural Patterns
  • Patterns that helps you compose objects into larger structures
• Behavioral Patterns
  • Patterns that concerns with interactions between objects
  • Help developers define the communication between objects in the system

Pattern Categories

Documenting Design Pattern

• A design pattern has four elements:
  • A name
    • Name of the pattern
  • A problem description
    • Describe the problem/situation faced by developers in which the pattern can be used
  • A solution
    • Describe the solution approach and the solution elements in detail
  • A set of consequences
    • Describe the trade-offs of pattern, that the pros and cons of using the pattern

Strategies Behind Design Patterns

• The GoF suggests the following strategies for creating good OO Design:
  • Design to interface
  • Favour composition over inheritance
  • Find what varies and encapsulate it

Design Pattern: Singleton

How do you ensure only a single instance of class is instantiated?

Singleton Pattern

• What did GoF say?
  • Ensure a single instance of a class
  • Provide a global access point to the instance
• How does it work?

Singleton Implementation

	private static Singleton instance = null;
 	private Singleton () {
  	}

	public static Singleton getInstance() {
		if (instance == null) { 
		     instance = new Singleton ();
		}
		return instance;
	}

	// Other method implementations

Singleton Example

• You can find plenty of singleton usages in JDK
  • java.util.Calendar API Specification
  • java.util.Currency API Specification
  • java.text.DateFormat API Specification
  • java.security.KeyStore
  • java.security.KeyFactory

Design Pattern: Observer

What if a group of objects needs to update themselves when some object changes state?

The Observer Pattern

• This pattern solves a common problem:
  • What if a group of objects needs to update themselves when some object changes state?
• aka Dependents & Publish-Subscribe
  • An object notifies other objects if it changes

Implement in Java

• There are two types of objects used to implement the observer pattern in Java
  • Interface Observer
  • Class Observable
• The Observable object keeps track of everybody who wants to be informed when a change happens.
• When someone says "OK, everybody should check and potentially update yourselves,"
  • The Observable object performs the notifyObservers( ) method for each one on the list.
  • The notifyObservers( ) method is part of the base class Observable.
• An Observer object is some object that implements the Observer interface
• The Observer object will register with an Observable object.
• When a change has been made in the Observable object, the Observable object will call the Observer object's update( ) method.

Java API Reference

Example

	private String forename ;
	private String surname ;
	private int age ;

	... ...

	public void setForename(String f) {
	    	forename = f ;
            	setChanged();
            	notifyObservers();
	} 

	public void setSurname(String s) {
		... ...
	} 

	public void setAge(int a) {
		... ...
	} 

	implements ActionListener, Observer {

	... ...

	public void update( Observable o, Object arg ) {
		Person aperson = ( Person ) o;
		... ...
		al.setText( "Age: " + String.valueOf( aperson.getAge() ) );
	}

	public static void main( String[] args ) {

		Person p = new Person( "Ivor", "Pattern", 23 );
		PersonView pfr = new PersonView( "Person GUI" );
		p.addObserver( pfr );

		pfr.setLocation( 200, 200 );
		pfr.setVisible( true );
		try {
			for( int i = 0; i <= 300; i++ ) {
				p.increaseAge( 1 );
				Thread.sleep( 1000 );
			}
		}
		catch( Exception e ) {
			System.out.println( e );
		}
	}

Extra materials for your to probe further

• The Open-Closed principle is an important principle for a good object-oriented design (OOD).

• GoF Patterns : http://www.fluffycat.com/java/patterns.html
• J2EE Patterns : http://java.sun.com/blueprints/patterns/

Thanks for Reading

If you would rather like to have this lecture note in printed format, please click the print action link in the top right corner.

If you find any problem in this lecture note, please feel free to tell Steven by steven@findaway.hk