1. Chapter 22 Object-Oriented Design

2. Object-Oriented Design

3. OOA and OOD

4. OOA and OOD

5. Design Issues
decomposability—the facility with which a design method helps the designer to decompose a large problem into subproblems that are easier to solve;
composability—the degree to which a design method ensures that program components (modules), once designed and built, can be reused to create other systems;
understandability—the ease with which a program component can be understood without reference to other information or other modules;
continuity—the ability to make small changes in a program and have these changes manifest themselves with corresponding changes in just one or a very few modules;
protection—a architectural characteristic that will reduce the propagation of side affects if an error does occur in a given module.

6. Generic Components for OOD
Problem domain component—the subsystems that are responsible for implementing customer requirements directly;
Human interaction component —the subsystems that implement the user interface (this included reusable GUI subsystems);
Task Management Component—the subsystems that are responsible for controlling and coordinating concurrent tasks that may be packaged within a subsystem or among different subsystems;
Data management component—the subsystem that is responsible for the storage and retrieval of objects.

7. Process Flow for OOD

8. System Design Process • Partition the analysis model into subsystems.
• Identify concurrency that is dictated by the problem.
• Allocate subsystems to processors and tasks.
• Develop a design for the user interface.
• Choose a basic strategy for implementing data management.
• Identify global resources and the control mechanisms required to access them.
• Design an appropriate control mechanism for the system, including task management.
• Consider how boundary conditions should be handled.
• Review and consider trade-offs.

9. System Design

10. Subsystem Example

11. Subsystem Design Criteria
• The subsystem should have a well-defined interface through which all communication with the rest of the system occurs.
• With the exception of a small number of “communication classes,” the classes within a subsystem should collaborate only with other classes within the subsystem.
• The number of subsystems should be kept small.
• A subsystem can be partitioned internally to help reduce complexity.

12. Subsystem Collaboration Table

13. Object Design
A protocol description establishes the interface of an object by defining each message that the object can receive and the related operation that the object performs
An implementation description shows implementation details for each operation implied by a message that is passed to an object.
information about the object's private part
internal details about the data structures that describe the object’s attributes
procedural details that describe operations

14. Design Patterns
... you’ll find recurring patterns of classes and communicating objects in many object-oriented systems. These patterns solve specific design problems and make object-oriented design more flexible, elegant, and ultimately reusable. They help designers reuse successful designs by basing new designs on prior experience. A designer who is familiar with such patterns can apply them immediately to design problems without having to rediscover them.
Gamma and his colleagues [GAM95]

15. Design Pattern Attributes
The design pattern name is an abstraction that conveys significant meaning about it applicability and intent.
The problem description indicates the environment and conditions that must exist to make the design pattern applicable.
The pattern characteristics indicate the attributes of the design that may be adjusted to enable the pattern to accommodate into a variety of problems.
The consequences associated with the use of a design pattern provide an indication of the ramifications of design decisions.

16. Example Miter joint – Dovetail joint in window Miter Dovetail
Simpler lightweight inconspicuous
Dovetail
More complex, impervious temperature and humidity
Independent of fastening system
Beautiful when made well

17. Facade Pattern Name - Facade Problem Solution
You need to use only a subset of a complex system. Or you need to interact with the system in a particular way.
Solution
Define a new class (or classes) That has the required interface
Have this new class use the existing system.
Facade picture p. 89

18. Façade (cont.) Trade-offs
The facade simplifies the use of the required subsystem. However, since the facade is not complete, certain functionality may be unavailable to the client

19. Facade
Subsystem
Facade

20. Summary –
Applies when
You do not need to use all the functionality of a complex system
You want to encapsulate or hide the original system
You want to use the functionality of the original system and want to add some new functionality as well
The cost of writing this new class is less than the cost of everybody learning how to use the original system or is less than you would spend on maintenance in the future

21. Adapter Name – Adaptor (wrapper) Problem
A system has the right data and behavior but the wrong interface. Often used when you have to make something a derivative of an abstract class we are defining or already have
Motivation
Shape hierarchy
Implementation of xx circle but doesn’t inherit from shape

22. Solution Provide a wrapper with the desired interface Object adapter –
Adapter contains the adaptee (pointer?)
Use inline functions to forward
Class adapter
Use multiple inheritance – private

23. Adaptor
Target
Adaptee
Client
Adaptor

24. Trade offs Efficiency issues Writing function forwarding Note
Facade often hides several classes but may be 1
Adapter often hides 1 but may be several

25. Find what varies and encapsulate it
Abstract class
Core – defines commonality
Commonality
Which abstract classes to use
Variations
Derivations of abstract classes
Specification
Interface of classes

26. Abstract class Core concept - commonality
Variations are derivation of an abstract class

27. Specification, Interface, Implementation
Specification – conceptual, identifies interface
Specification implementation - given specification how can I implement this particular variation

28. Bridge Pattern Name - bridge
Problem the derivations of an abstract class must use multiple implementations without causing an explosion in the number of classes

29. Solution
Define an interface for all implementations to use and have the derivations of the abstract class use that.

30. Bridge Pattern Abstraction Implementor Concrete Concrete
Implementor B
Concrete
Implementor A
Refined Abstraction

31. Tradeoffs
The decoupling of the implementation from the objects that use them increases extensibility.
Client objects are not aware of implementation issues.
Variations of shape are encapsulated in shape class
Variations in drawing are encapsulated in drawing class

32. Abstract Factory Name: Abstract Factory
Problem: Families of related objects need to be instantiated.
Solution: The abstract factory defines the interface for how to create each member of the family. Each family is created by having its own unique concrete factory.

33. Tradeoffs Isolates concrete classes
Makes exchanging product families easy
Promotes consistency among products
Hard to add new kinds of products

34. Abstract Factory Client Abstract Product B Abstract Product A Abstract

35. Summary
First, identify the rules for instantiation and define an abstract class with an interface that has a method for each object that needs to be instantiated
Implement concrete classes from this class for each family
The client object uses this factory object to create the server objects that it needs