1. Chapter 8
Object Design:
Reuse and Patterns 1

2. Object Design
Object design is the process of adding details to the requirements analysis and making implementation decisions
The object designer must choose among different ways to implement the analysis model with the goal to minimize execution time, memory and other measures of cost.
Requirements Analysis: Use cases, functional and dynamic model deliver operations for object model
Object Design: Iterates on the models, in particular the object model and refine the models
Object Design serves as the basis of implementation
System design: sub-systems decomposition, architectures, strategies.

3. Object Design: Closing the Gap

4. Examples of Object Design Activities
Identification of existing components
Full definition of associations
Full definition of classes (System Design => Service, Object Design => API)
Specifying the contract for each component
Choosing algorithms and data structures
Identifying possibilities of reuse
Detection of solution-domain classes
Optimization
Increase of inheritance
Decision on control
Packaging
The analysis phase determines what the implementation must do (What), and the system design phase formulates the plan of attack (How), but on a very high level (namely subsystems, layers and partitions). The object design phase carries out the plan of attack!
It determines the full definitions of classes and associations used in the implementation, as well as the interfaces and the algorithms of the methods used to implement operations.
The objects discovered during the analysis can be thought of as the skeleton of the final system, but new classes are needed. In particular, the operations found during analysis must be expressed as algorithms, the classes, associations and attributes must be implemented with specific data structures. New objects will be identifed during this activity. For example, intermediate results might have to be stored to avoid the need for recompilation. This is an important issue if we implement a distributed system. Maps retrieved by the UI from the database should be stored locally, so not every access is an access across processor boundaries.
The object design phases therefore addresses any internal objects needed for the implementation and optimizes data structures and algorithms.
Object design is the basis of implementation.
Note that there is no change of notation, we are still using object models, functional models and dynamic models as our main weapons.

5. Lectures for Object Design
1. Reuse: Identification of existing solutions
Use of inheritance
Off-the-shelf components and additional solution objects
Design patterns
2. Interface specification
Describes precisely each class interface
3. Object model restructuring
Transforms the object design model to improve its understandability and extensibility
4. Object model optimization
Transforms the object design model to address performance criteria such as response time or memory utilization.
Object
Design
lectures
Mapping
Models to Code
lecture

6. Outline of Today Reuse Concepts The use of inheritance
Class inheritance (implementation inheritance) vs Interface Inheritance
Inheritance vs Delegation Delegation (Section 8.3.3)
Components
Documenting the Object Design
JavaDoc

7. Application domain vs solution domain objects
Application objects, also called 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 objects represent concepts that do not have a counterpart in the application domain,
They are identified by the developers
Examples: Persistent data stores, user interface objects, middleware.

8. Application Domain vs Solution Domain Objects
Requirements Analysis
(Language of Application
Domain)
Object Design
(Language of Solution Domain)
Incident
Report
Incident
Report
Text box
Menu
Scrollbar

9. Implementation of Application Domain Classes
New objects are often needed during object design:
The use of design patterns introduces new classes
The implementation of algorithms may necessitate objects to hold values
New low-level operations may be needed during the decomposition of high-level operations
Example: The EraseArea() operation in a drawing program.
Conceptually very simple
Implementation
Area represented by pixels
Repair () cleans up objects partially covered by the erased area
Redraw() draws objects uncovered by the erasure
Draw() draws pixels in background color not covered by other objects

10. Observation about Modeling of the Real World
[Gamma et al 94]:
Strict modeling of the real world leads to a system that reflects today’s realities but not necessarily tomorrow’s.
There is a need for reusable and flexible designs
Design knowledge complements application domain knowledge and solution domain knowledge.

11. The use of inheritance
Inheritance is used to achieve two different goals
Description of Taxonomies
Service Specification
Identification of taxonomies
Used during requirements analysis.
Activity: identify application domain objects that are hierarchically related
Goal: make the analysis model more understandable
Service specification
Used during object design
Activity:
Goal: increase reusability, enhance modifiability and extensibility
Inheritance is found either by specialization or generalization

12. Taxonomy Example
Mammal
Tiger
Wolf
Wale

13. Implementation Inheritance
A very similar class is already implemented that does almost the same as the desired class implementation.
List
Example: I have a List class, I need a Stack class. How about subclassing the Stack class from the List class and providing three methods, Push() and Pop(), Top()?
Add ()
“Already
implemented”
Remove()
Inheritance is a generalization technique, in which the behavior of a superclass is shared by all its subclasses. Sometimes it is misused as an implementation technique.
Question: Can you give me an example for unwanted behavior?
Stack
Push ()
Pop()
Top()
Problem with implementation inheritance:
Some of the inherited operations might exhibit unwanted behavior. What happens if the Stack user calls Remove() instead of Pop()?

14. Implementation Inheritance vs Interface Inheritance
Also called class inheritance
Goal: Extend an applications’ functionality by reusing functionality in parent class
Inherit from an existing class with some or all operations already implemented
Interface inheritance
Also called subtyping
Inherit from an abstract class with all operations specified, but not yet implemented

15. Delegation as alternative to Implementation Inheritance
Delegation is a way of making composition (for example aggregation) as powerful for reuse as inheritance
In Delegation two objects are involved in handling a request
A receiving object delegates operations to its delegate.
The developer can make sure that the receiving object does not allow the client to misuse the delegate object
Delegate
Client
Receiver
calls
Delegates to

16. Delegation instead of Implementation Inheritance
Inheritance: Extending a Base class by a new operation or overwriting an operation.
Delegation: Catching an operation and sending it to another object.
Which of the following models is better for implementing a stack?
+Add()
+Remove()
List
Stack
+Push()
+Pop()
+Top()
+Push()
+Pop()
+Top()
Stack
Add()
Remove()
List

17. Delegation and Inheritance
An example – handout: Hashtable and mySet (textbook P.311)
Delegation is an extreme example of object composition. It shows that you can always replace inheritance with object composition as a mechanism for code reuse.

18. Comparison: Delegation vs Implementation Inheritance
Pro:
Flexibility: Any object can be replaced at run time by another one (as long as it has the same type)
Con:
Inefficiency: Objects are encapsulated.
Inheritance
Straightforward to use
Supported by many programming languages
Easy to implement new functionality
Inheritance exposes a subclass to the details of its parent class
Any change in the parent class implementation forces the subclass to change (which requires recompilation of both)

19. Many design patterns use a combination of inheritance and delegation
Lecture on
Design Patterns
Many design patterns use a combination of inheritance and delegation

20. Component Selection Select existing
off-the-shelf class libraries
frameworks or
components
Adjust the class libraries, framework or components
Change the API if you have the source code.
Use the adapter or bridge pattern if you don’t have access
Architecture Driven Design

21. Reuse... Look for existing classes in class libraries
JSAPI, JTAPI, ....
Select data structures appropriate to the algorithms
Container classes
Arrays, lists, queues, stacks, sets, trees, ...
It might be necessary to define new internal classes and operations
Complex operations defined in terms of lower-level operations might need new classes and operations

22. Frameworks
A framework is a reusable partial application that can be specialized to produce custom applications.
Frameworks are targeted to particular technologies, such as data processing or cellular communications, or to application domains, such as user interfaces or real-time avionics.
The key benefits of frameworks are reusability and extensibility.
Reusability leverages of the application domain knowledge and prior effort of experienced developers
Extensibility is provided by hook methods, which are overwritten by the application to extend the framework.
Hook methods systematically decouple the interfaces and behaviors of an application domain from the variations required by an application in a particular context.

23. Frameworks in the Development Process
Infrastructure frameworks aim to simplify the software development process
System infrastructure frameworks are used internally within a software project and are usually not delivered to a client.
Middleware frameworks are used to integrate existing distributed applications and components.
Examples: MFC, DCOM, Java RMI, WebObjects, WebSphere, WebLogic Enterprise Application [BEA].
Enterprise application frameworks are application specific and focus on domains
Example domains: telecommunications, avionics, environmental modeling, manufacturing, financial engineering, enterprise business activities.

24. Class libraries and Frameworks
Less domain specific
Provide a smaller scope of reuse.
Class libraries are passive; no constraint on control flow.
Framework:
Classes cooperate for a family of related applications.
Frameworks are active; affect the flow of control.
In practice, developers often use both:
Frameworks often use class libraries internally to simplify the development of the framework.
Framework event handlers use class libraries to perform basic tasks (e.g. string processing, file management, numerical analysis…. )

25. Components and Frameworks
Self-contained instances of classes
Plugged together to form complete applications.
Blackbox that defines a cohesive set of operations,
Can be used based on the syntax and semantics of the interface.
Components can even be reused on the binary code level.
The advantage is that applications do not always have to be recompiled when components change.
Frameworks:
Often used to develop components
Components are often plugged into blackbox frameworks.

26. Example: Framework for Building Web Applications
WebObjects
WebBrowser
StaticHTML
WOAdaptor
WebServer
WoRequest
Template
WebObjectsApplication
WORequest
EOF
RelationalDatabase

27. Documenting Object Design: ODD Conventions
Each subsystem in a system provides a service (see Chapters on System Design)
Describes the set of operations provided by the subsystem
Specifying a service operation as
Signature: Name of operation, fully typed parameter list and return type
Abstract: Describes the operation
Pre: Precondition for calling the operation
Post: Postcondition describing important state after the execution of the operation
Use JavaDoc for the specification of service operations.

28. JavaDoc Add documentation comments to the source code.
A doc comment consists of characters between /** and */
When JavaDoc parses a doc comment, leading * characters on each line are discarded. First, blanks and tabs preceding the initial * characters are also discarded.
Doc comments may include HTML tags
Example of a doc comment:
/**
* This is a <b> doc </b> comment */
The specification of a class interface includes the class name and the superclass name. You should also include an overall description of the class here. The attributes of a given class (as defined in OMTool and later in C++) need not be given here since this is the interface to the outside world and attributes are considered private to each class. The class specification should also include the specification of each operation that can be performed on the class.
The specification of an operation consists of a header and a semantic part. The header contains the name of the operation and includes the number, order and types of its input parameters in standard C++ style. The semantic part defines the meaning of the operation and consists of three clauses, the requires, modifies and ensures clause. The requires clause states an assertion or list of assertions that are the preconditions of the operation. This expresses the condition under which the call to the routine is correct. [For example, if an array has to be sorted before the search() operation can be called, this would be in the requires section of search()]. The modifies clause lists the names of any input parameters that are modified by the operation. The ensures clause states an assertion or list of assertions that are the postconditions of the operation. This expresses the conditions that the operator will ensure when it returns, assuming it was called in a state satisfying the preconditions. All the clauses may be written in informal English or in C++ syntax where this is more concise.

29. More on JavaDoc
Doc comments are only recognized when placed immediately before class, interface, constructor, method or field declarations.
When you embed HTML tags within a doc comment, you should not use heading tags such as <h1> and <h2>, because JavaDoc creates an entire structured document and these structural tags interfere with the formatting of the generated document.
Class and Interface Doc Tags
Constructor and Method Doc Tags

30. Class and Interface Doc Tags
@author name-text
Creates an “Author” entry.
@version version-text
Creates a “Version” entry.
@see classname
Creates a hyperlink “See Also classname”
@since since-text
Adds a “Since” entry. Usually used to specify that a feature or change exists since the release number of the software specified in the “since-text”
@deprecated deprecated-text
Adds a comment that this method can no longer be used. Convention is to describe method that serves as replacement
Replaced by setBounds(int, int, int, int).

31. Constructor and Method Doc Tags
Can as well as:
@param parameter-name description
Adds a parameter to the "Parameters" section. The description may be continued on the next line.
@return description
Adds a "Returns" section, which contains the description of the return value.
@exception fully-qualified-class-name description
Adds a "Throws" section, which contains the name of the exception that may be thrown by the method. The exception is linked to its class documentation.
@see classname
Adds a hyperlink "See Also" entry to the method.

32. Example of a Class Doc Comment
/**
* A class representing a window on the screen.
* For example:
* <pre>
* Window win = new Window(parent);
* win.show();
* </pre> *
Sami Shaio
%I%, %G%
java.awt.BaseWindow
java.awt.Button */
class Window extends BaseWindow {
... }

33. Example of a Method Doc Comment
/**
* Returns the character at the specified index. An index
* ranges from <code>0</code> to <code>length() - 1</code>. *
index the index of the desired character.
the desired character.
StringIndexOutOfRangeException
* if the index is not in the range <code>0</code>
* to <code>length()-1</code>.
java.lang.Character#charValue() */
public char charAt(int index) {
... }

34. Example of a Field Doc Comment
A field comment can contain tags
/**
* The X-coordinate of the window. *
window#1 */
int x = ;

35. Example: Specifying a Service in Java
/** Office is a physical structure in a building. It is possible to create an instance of a office; add an occupant; get the name and the number of occupants */
public class Office {
/** Adds an occupant to the office */
NAME name is a nonempty string */
public void AddOccupant(string name);
Returns the name of the office. Requires, that Office has been initialized with a name */
public string GetName();
.... }
The specification of a class interface includes the class name and the superclass name. You should also include an overall description of the class here. The attributes of a given class (as defined in OMTool and later in C++) need not be given here since this is the interface to the outside world and attributes are considered private to each class. The class specification should also include the specification of each operation that can be performed on the class.
The specification of an operation consists of a header and a semantic part. The header contains the name of the operation and includes the number, order and types of its input parameters in standard C++ style. The semantic part defines the meaning of the operation and consists of three clauses, the requires, modifies and ensures clause. The requires clause states an assertion or list of assertions that are the preconditions of the operation. This expresses the condition under which the call to the routine is correct. [For example, if an array has to be sorted before the search() operation can be called, this would be in the requires section of search()]. The modifies clause lists the names of any input parameters that are modified by the operation. The ensures clause states an assertion or list of assertions that are the postconditions of the operation. This expresses the conditions that the operator will ensure when it returns, assuming it was called in a state satisfying the preconditions. All the clauses may be written in informal English or in C++ syntax where this is more concise.

36. Package it all up
Pack up design into discrete physical units that can be edited, compiled, linked, reused
Construct physical modules
Ideally use one package for each subsystem
System decomposition might not be good for implementation.
Two design principles for packaging
Minimize coupling:
Classes in client-supplier relationships are usually loosely coupled
Large number of parameters in some methods mean strong coupling (> 4-5)
Avoid global data
Maximize cohesion:
Classes closely connected by associations => same package

37. Packaging Heuristics
Each subsystem service is made available by one or more interface objects within the package
Start with one interface object for each subsystem service
Try to limit the number of interface operations (7+-2)
If the subsystem service has too many operations, reconsider the number of interface objects
If you have too many interface objects, reconsider the number of subsystems
Difference between interface objects and Java interfaces
Interface object : Used during requirements analysis, system design and object design. Denotes a service or API
Java interface: Used during implementation in Java (A Java interface may or may not implement an interface object)

38. Lecture on Mapping Models to Code
Summary
Object design closes the gap between the requirements and the machine.
Object design is the process of adding details to the requirements analysis and making implementation decisions
Object design activities include:
Identification of Reuse
Identification of Inheritance and Delegation opportunities
Component selection
Interface specification (next lecture)
Object model restructuring
Object model optimization
Object design is documented in the Object Design Document, which can be automatically generated from a specification using tools such as JavaDoc.
Lecture on Mapping Models to Code