g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8...
Transcript of g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8...
![Page 1: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/1.jpg)
Usi
ng
UM
L, P
atte
rns,
and J
ava
Ob
ject
-Ori
ente
d S
oft
wa
re E
ng
inee
rin
g
Chapter 8, Object Design: Reuse and Patterns I
![Page 2: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/2.jpg)
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
![Page 3: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/3.jpg)
System Development as a Set of Activities
Custom objects
Analysis
- System Design
- Object Design
System
Design
Application objects
Solution objects
Existing Machine
Problem
Off-the-Shelf Components
![Page 4: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/4.jpg)
Examples of Object Design Activities
Identification of existing components
Full definition of associations
Full definition of classes (System Design => Service, Object
Design => Subsystem interfaces/API)
Choosing algorithms and data structures
Identifying possibilities of reuse
Detection of solution-domain classes
Optimization
Increase of inheritance
Decision on control
……
![Page 5: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/5.jpg)
A More Detailed View of Object Design Activities
Specifying constraints
Specifying types & signatures
Identifying patterns
Adjusting patterns
Identifying missing attributes & operations
Specifying visibility
Specification
Specifying exceptions
Reuse
Identifying components
Adjusting components
Select Subsystem
![Page 6: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/6.jpg)
Detailed View of Object Design Activities (ctd)
Collapsing classes
Restructuring Optimization
Revisiting inheritance
Optimizing access paths
Caching complex computations
Delaying complex computations
Check Use Cases
Realizing associations
![Page 7: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/7.jpg)
Terminology: Naming of Design Activities
Methodology: Object-oriented
software engineering (OOSE)
System Design
Decomposition into
subsystems, etc
Object Design
Data structures and
algorithms chosen
Implementation
Implementation
language is chosen
Methodology: Structured
analysis/structured design (SA/SD)
Preliminary Design
Decomposition into subsystems,
etc
Data structures are chosen
Detailed Design
Algorithms are chosen
Data structures are refined
Implementation language is
chosen
![Page 8: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/8.jpg)
Plan for the next Lectures
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
![Page 9: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/9.jpg)
Reuse Concepts
Application objects versus solution objects
Specification inheritance and implementation inheritance
The Liskov Substitution Principle
Delegation
Delegation and inheritance in design patterns
![Page 10: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/10.jpg)
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.
![Page 11: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/11.jpg)
Application Domain vs Solution Domain Objects
Incident
Report
Requirements Analysis
(Language of Application
Domain)
Incident
Report
Object Design
(Language of Solution Domain)
Text box Menu Scrollbar
![Page 12: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/12.jpg)
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() erases pixels in background color not covered by other objects
![Page 13: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/13.jpg)
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
![Page 14: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/14.jpg)
The use of inheritance
Inheritance is used to achieve two different goals
Description of Taxonomies
Interface Specification
Identification of taxonomies
Used during requirements analysis.
Activity: identify application domain objects that are
hierarchically related
Goal: make the analysis model more understandable
Interface specification
Used during object design
Activity: identify the signatures of all identified objects
Goal: increase reusability, enhance modifiability and extensibility
Inheritance is found either by specialization or generalization
![Page 15: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/15.jpg)
Metamodel for Inheritance
Inheritance is used during analysis and object design
Inheritance
Specification
Inheritance
Implementation
Inheritance
Inheritance for Reuse Taxonomy
Inheritance detected
by generalization
Inheritance detected
by specialization
Analysis
activity
Object
Design
![Page 16: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/16.jpg)
Taxonomy Example
Mammal
Tiger Wolf Wale
![Page 17: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/17.jpg)
Problem with implementation inheritance:
Some of the inherited operations might exhibit unwanted behavior.
What happens if the Stack user calls Remove() instead of Pop()?
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 ()
Remove()
List
Push ()
Pop()
Stack
Top()
“Already
implemented”
Implementation Inheritance
A very similar class is already implemented that does almost
the same as the desired class implementation.
![Page 18: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/18.jpg)
Implementation Inheritance vs Specification Inheritance
Implementation 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
Specification inheritance
Also called subtyping
Inherit from an abstract class with all operations specified, but not
yet implemented
![Page 19: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/19.jpg)
Client Receiver Delegate Delegates to calls
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
![Page 20: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/20.jpg)
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
![Page 21: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/21.jpg)
Comparison: Delegation vs Implementation Inheritance
Delegation
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
Pro:
Straightforward to use
Supported by many programming languages
Easy to implement new functionality
Con:
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)
![Page 22: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/22.jpg)
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
![Page 23: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/23.jpg)
Classification of Frameworks
Frameworks can be classified by their position in the software
development process
Frameworks can also be classified by the techniques used to
extend them
Whitebox frameworks
Blackbox frameworks
![Page 24: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/24.jpg)
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
![Page 25: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/25.jpg)
White-box and Black-Box Frameworks
Whitebox frameworks
Extensibility achieved through inheritance and dynamic binding
Existing functionality is extended by subclassing framework base
classes and overriding predefined hook methods
Often design patterns such as the template method pattern are used
to override the hook methods
Blackbox frameworks
Extensibility achieved by defining interfaces for components that can
be plugged into the framework
Existing functionality is reused by defining components that conform
to a particular interface
These components are integrated with the framework via delegation
![Page 26: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/26.jpg)
Class libraries and Frameworks
Class Libraries:
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…. )
![Page 27: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/27.jpg)
Components and Frameworks
Components
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.
![Page 28: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/28.jpg)
Example: Framework for Building Web Applications
WebBrowser
RelationalDatabase
StaticHTML
WOAdaptor WebServer
WoRequest Template
WebObjectsApplication
WORequest
EOF
WebObjects
![Page 29: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/29.jpg)
Documenting the Object Design: The Object Design Document (ODD)
Object design document
Same as the Requirements Analysis Document (RAD) plus...
… additions to object, functional and dynamic models (from solution
domain)
… navigational map for object model
ODD Template:
http://www.oose.org
![Page 30: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/30.jpg)
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
![Page 31: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/31.jpg)
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 chapter)
Object model restructuring
Object model optimization
Object design is documented in the Object Design Document
Chapter on Mapping Models to Code
![Page 32: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/32.jpg)
Chapter 8, Object Design Reuse and Patterns II
Usi
ng U
ML
, P
atte
rns,
and J
ava
Ob
ject
-Ori
ente
d S
oft
wa
re E
ng
inee
rin
g
![Page 33: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/33.jpg)
Outline of the Lecture
Design Patterns
Usefulness of design patterns
Design pattern categories
Patterns covered in this lecture
Composite: Model dynamic aggregates
Adapter: Interfacing to existing systems (legacy systems)
Bridge: Interfacing to existing and future systems
Facade: Interfacing to subsystems
Abstract Factory
Proxy
Command
Observer
Strategy
![Page 34: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/34.jpg)
Finding Objects
The hardest problems in object-oriented system development are:
Identifying objects
Decomposing the system into objects
Requirements Analysis focuses on application domain:
Object identification
System Design addresses both application and implementation
domain:
Subsystem Identification
Object Design focuses on implementation domain:
Additional solution objects
![Page 35: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/35.jpg)
Techniques for Finding Objects
Requirements Analysis
Start with Use Cases. Identify participating objects
Textual analysis of flow of events (find nouns, verbs, ...)
Extract application domain objects by interviewing client
(application domain knowledge)
Find objects by using general knowledge
System Design
Subsystem decomposition
Try to identify layers and partitions
Object Design
Find additional objects by applying implementation domain
knowledge
![Page 36: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/36.jpg)
Another Source for Finding Objects : Design Patterns
What are Design Patterns?
A design pattern describes a problem which occurs over and
over again in our environment
Then it describes the core of the solution to that problem, in
such a way that you can use the this solution a million times
over, without ever doing it the same twice
![Page 37: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/37.jpg)
What is common between these definitions?
Definition: Software System
A software system consists of subsystems which are either other
subsystems or collection of classes
Definition: Software Lifecycle
The software lifecycle consists of a set of development activities
which are either other activities or collection of tasks
![Page 38: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/38.jpg)
Introducing the Composite Pattern
Models tree structures that represent part-whole hierarchies
with arbitrary depth and width.
The Composite Pattern lets client treat individual objects and
compositions of these objects uniformly
Client Component
Leaf
Operation()
Composite
Operation()
AddComponent
RemoveComponent()
GetChild()
Children
*
![Page 39: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/39.jpg)
What is common between these definitions?
Software System:
Definition: A software system consists of subsystems which are
either other subsystems or collection of classes
Composite: Subsystem (A software system consists of subsystems
which consists of subsystems , which consists of subsystems,
which...)
Leaf node: Class
Software Lifecycle:
Definition: The software lifecycle consists of a set of development
activities which are either other actitivies or collection of tasks
Composite: Activity (The software lifecycle consists of activities
which consist of activities, which consist of activities, which....)
Leaf node: Task
![Page 40: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/40.jpg)
Modeling a Software System������ with a Composite Pattern
Software
System
Class
Subsystem
Children
* User
![Page 41: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/41.jpg)
Modeling the Software Lifecycle with a Composite Pattern
Software
Lifecycle
Task
Activity
Children
* Manager
![Page 42: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/42.jpg)
The Composite Patterns models dynamic aggregates
University School Department
Organization Chart (variable aggregate):
Dynamic tree (recursive aggregate):
Car Fixed Structure:
Doors Wheels Battery Engine
Compound Statement
Simple Statement
Program
Block
* *
* *
* *
Dynamic tree (recursive aggregate):
Composite
Pattern
![Page 43: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/43.jpg)
Graphic Applications also use Composite Patterns
The Graphic Class represents
both primitives (Line, Circle)
and their containers (Picture)
Client Graphic
Circle
Draw()
Picture
Draw()
Add(Graphic g)
RemoveGraphic)
GetChild(int)
Children Line
Draw()
*
![Page 44: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/44.jpg)
Design Patterns reduce the Complexity of Models
To communicate a complex model we use navigation and reduction
of complexity
We do not simply use a picture from the CASE tool and dump it in front
of the user
The key is navigate through the model so the user can follow it
We start with a very simple model and then decorate it incrementally
Start with key abstractions (use animation)
Then decorate the model with the additional classes
To reduce the complexity of the model even further, we
Apply the use of inheritance (for taxonomies, and for design patterns)
If the model is still too complex, we show the subclasses on a separate slide
Then identify (or introduced) patterns in the model
We make sure to use the name of the patterns
![Page 45: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/45.jpg)
*
Resource
Participant
Fund
Equipment
Schedule
Task
*
Activity
con-
Facility
*
Staff
Department Team
produces
Work Set of Work
*
ProductProducts
*
Internal Project
Work
respon-
sumes
Package
Role
*
des-
*
cribes
Deliverable
sibleplays
for
Organi-zation
Structure
**
depends
Work ProductProject Function
Project
Outcome WorkOrganizational
Unit
Work Breakdown
Example: A More Complex Model of a Software Project
Composite Patterns
Basic Abstractions
![Page 46: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/46.jpg)
*
Resource
Participant
Fund
Equipment
Schedule
Task
*
Activity
con-
Facility
*
Staff
Department Team
produces
Work Set of Work
*
ProductProducts
*
Internal Project
Work
respon-
sumes
Package
Role
*
des-
*
cribes
Deliverable
sibleplays
for
Organi-zation
Structure
**
depends
Work ProductProject Function
Project
Outcome WorkOrganizational
Unit
Work Breakdown
Example: A More Complex Model of a Software Project
Taxonomies
![Page 47: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/47.jpg)
Delegation is used to bind an Adapter and an Adaptee
Interface inheritance is use to specify the interface of the Adapter class
Target and Adaptee (usually called legacy system) pre-exist the Adapter
Target may be realized as an interface in Java
Adapter Pattern
Client ClientInterface
Request()
LegacyClass
ExistingRequest()
Adapter
Request()
Adaptee
![Page 48: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/48.jpg)
Adapter Pattern
Convert the interface of a class into another interface clients expect
The adapter pattern lets classes work together that couldn’t
otherwise because of incompatible interfaces
Used to provide a new interface to existing legacy components
(Interface engineering, reengineering).
Also known as a wrapper
Two adapter patterns:
Class adapter:
Uses multiple inheritance to adapt one interface to another
Object adapter:
Uses single inheritance and delegation
Object adapters are much more frequent. We will only cover object
adapters (and call them therefore simply adapters)
![Page 49: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/49.jpg)
Bridge Pattern
Use a bridge to “decouple an abstraction from its
implementation so that the two can vary independently”. (From
[Gamma et al 1995])
Also know as a Handle/Body pattern
Allows different implementations of an interface to be decided
upon dynamically
![Page 50: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/50.jpg)
Using a Bridge
The bridge pattern is used to provide multiple implementations
under the same interface
Examples: Interface to a component that is incomplete, not yet
known or unavailable during testing
JAMES Project: if seat data is required to be read, but the seat is
not yet implemented, known, or only available by a simulation,
provide a bridge:
VIP
Seat (in Vehicle Subsystem)
Seat Implementation
Stub Code SARTSeat AIMSeat
imp
GetPosition()
SetPosition()
![Page 51: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/51.jpg)
Seat Implementation
public interface SeatImplementation {
public int GetPosition();
public void SetPosition(int newPosition);
}
public class Stubcode implements SeatImplementation {
public int GetPosition() { // stub code for GetPosition } ... } public class AimSeat implements SeatImplementation {
public int GetPosition() { // actual call to the AIM simulation system } …. } public class SARTSeat implements SeatImplementation {
public int GetPosition() { // actual call to the SART seat simulator } ... }
![Page 52: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/52.jpg)
Bridge Pattern
Abstraction
Operation()
imp
Client
Imp->OperationImp();
Concrete Implementor B
OperationImpl()
Refined Abstraction 2
Operation()
Refined Abstraction 1
Operation()
Concrete Implementor A
OperationImpl()
Implementor
OperationImpl()
![Page 53: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/53.jpg)
Adapter vs Bridge
Similarities:
Both are used to hide the details of the underlying implementation.
Difference:
The adapter pattern is geared towards making unrelated
components work together
Applied to systems after they’re designed (reengineering, interface
engineering).
A bridge, on the other hand, is used up-front in a design to let
abstractions and implementations vary independently
Green field engineering of an “extensible system”
New “beasts” can be added to the “object zoo”, even if these are not
known at analysis or system design time
![Page 54: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/54.jpg)
Facade Pattern
Provides a unified interface to a set of objects in a subsystem.
A facade defines a higher-level interface that makes the
subsystem easier to use (i.e. it abstracts out the gory details)
Facades allow us to provide a closed architecture
![Page 55: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/55.jpg)
Design Example
Subsystem 1 can look into the Subsystem 2
(vehicle subsystem) and call on any
component or class operation at will.
This is “Ravioli Design”
Why is this good?
Efficiency
Why is this bad?
Can’t expect the caller to understand how
the subsystem works or the complex
relationships within the subsystem.
We can be assured that the subsystem will
be misused, leading to non-portable code
Subsystem 2
Subsystem 1
AIM
Card
SA/RT
Seat
![Page 56: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/56.jpg)
Subsystem Design with Façade, Adapter, Bridge
The ideal structure of a subsystem consists of
an interface object
a set of application domain objects (entity objects) modeling real entities
or existing systems
Some of the application domain objects are interfaces to existing systems
one or more control objects
We can use design patterns to realize this subsystem structure
Realization of the Interface Object: Facade
Provides the interface to the subsystem
Interface to existing systems: Adapter or Bridge
Provides the interface to existing system (legacy system)
The existing system is not necessarily object-oriented!
![Page 57: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/57.jpg)
Realizing an Opaque Architecture with a Facade
The subsystem decides exactly
how it is accessed.
No need to worry about misuse
by callers
If a façade is used, the
subsystem can be used in an
early integration test
We need to write only a driver
VIP Subsystem
AIM
Card
SA/RT
Seat
Vehicle Subsystem API
![Page 58: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/58.jpg)
Design Patterns encourage reusable Designs
A facade pattern should be used by all subsystems in a software
system. The façade defines all the services of the subsystem
The facade will delegate requests to the appropriate components within
the subsystem. Most of the time the façade does not need to be changed,
when the component is changed
Adapters should be used to interface to existing components
For example, a smart card software system should provide an adapter
for a particular smart card reader and other hardware that it controls
and queries
Bridges should be used to interface to a set of objects
Where the full set is not completely known at analysis or design time
When the subsystem must be extended later after the system has been
deployed and client programs are in the field (dynamic extension)
![Page 59: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/59.jpg)
Summary
Design patterns are partial solutions to common problems such as
Separating an interface from a number of alternate implementations
Wrapping around a set of legacy classes
Protecting a caller from changes associated with specific platforms
A design pattern is composed of a small number of classes
use delegation and inheritance
provide a robust and modifiable solution
These classes can be adapted and refined for the specific system
under construction
Customization of the system
Reuse of existing solutions
![Page 60: g Chapter 8, Object Design: Reuse and Patterns Ipalm.seu.edu.cn/zhangml/files/Chapter 8 (SE).pdfDesign patterns 2. Interface specification Describes precisely each class interface](https://reader033.fdocuments.us/reader033/viewer/2022050114/5f4b7fd0ae541f63173626e1/html5/thumbnails/60.jpg)
Summary II
Composite Pattern:
Models trees with dynamic width and dynamic depth
Facade Pattern:
Interface to a subsystem
closed vs open architecture
Adapter Pattern:
Interface to reality
Bridge Pattern:
Interface to reality and prepare for future