CEN 4010 - Ninth Lecture Introduction to Software Engineering (CEN- Introduction to Software Engineering (CEN- 4010) 4010) Instructor: Masoud Sadjadi http://www.cs.fiu.edu/~sadjadi/ Object Design Object Design
Jan 07, 2016
CEN 4010 - Ninth Lecture
Introduction to Software Engineering (CEN-Introduction to Software Engineering (CEN-4010)4010)
Instructor: Masoud Sadjadi
http://www.cs.fiu.edu/~sadjadi/
Object DesignObject Design
Ninth Lecture 2CEN 4010: Introduction to Software Engineering
AcknowledgementsAcknowledgements
Dr. Bernd Bruegge
Dr. Allen Dutoit
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 3CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 4CEN 4010: Introduction to Software Engineering
Object DesignObject 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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 5CEN 4010: Introduction to Software Engineering
Object Design: Closing the GapObject Design: Closing the Gap
Custom objects
Application objects
Off-the-shelf components
Solution objects
System Problem
Machine
System design gap
Object design gap
Requirements gap
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 6CEN 4010: Introduction to Software Engineering
App. vs. Solution Domain App. vs. Solution Domain ObjectsObjects
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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 7CEN 4010: Introduction to Software Engineering
ExampleExample
IncidentReport
Requirements Analysis(Language of Application
Domain)
IncidentReportForm
Object Design(Language of Solution Domain)
Text box Menu Scrollbar
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 8CEN 4010: Introduction to Software Engineering
Refining App. Domain ObjectsRefining App. Domain Objects
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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 9CEN 4010: Introduction to Software Engineering
Examples of Object Design Examples of Object Design ActivitiesActivities
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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 10CEN 4010: Introduction to Software Engineering
Object Design Activities Object Design Activities (1)(1)
Specifying constraints
Specifying types &signatures
Identifying patterns
Adjusting patterns
Identifying missingattributes & operations
Specifying visibility
Specification
Specifying exceptions
Reuse
Identifying components
Adjusting components
Select Subsystem
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 11CEN 4010: Introduction to Software Engineering
Object Design Activities Object Design Activities (1)(1)
Collapsing classes
Restructuring Optimization
Revisitinginheritance
Optimizing accesspaths
Caching complexcomputations
Delaying complexcomputations
Check Use Cases
Realizing associations
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 12CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 13CEN 4010: Introduction to Software Engineering
Reuse MotivationReuse Motivation
Observation about Modeling of the Real World in [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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 14CEN 4010: Introduction to Software Engineering
Reuse HeuristicsReuse Heuristics
Look for existing classes in class libraries– JSAPI, JTAPI, ....
Select data structures appropriate to the algorithms– Container classes – Arrays, lists, queues, stacks, sets, trees, ...
Define new internal classes and operations only if necessary– Complex operations defined in terms of lower-level
operations might need new classes and operations
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 15CEN 4010: Introduction to Software Engineering
ReuseReuse
Main goal: – Reuse knowledge and functionality from previous
experience to current problem.– Approaches: Inheritance and Delegation
Inheritance – Interface inheritance
Used for concept classifications type hierarchies
– Implementation inheritance Used for code reuse.
Delegation– An alternative to implementation inheritance.
Used for code reuse.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 16CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 17CEN 4010: Introduction to Software Engineering
Metamodel for InheritanceMetamodel for Inheritance
Inheritance is used to achieve two different goals: Taxonomies and Reuse.
Inheritance
InterfaceInheritance
ImplementationInheritance
Inheritancefor ReuseTaxonomy
Inheritance detectedby generalization
Inheritance detectedby specialization
Analysisactivity
Object Design
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 18CEN 4010: Introduction to Software Engineering
Taxonomy ExampleTaxonomy Example
Mammal
Tiger Wolf Wale
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 19CEN 4010: Introduction to Software Engineering
Implementation InheritanceImplementation Inheritance
A very similar class is already implemented that does almost the same as the desired class implementation.
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”
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 20CEN 4010: Introduction to Software Engineering
ProblemsProblems
Problem with implementation inheritance:– Some of the inherited operations might exhibit
unwanted behavior. – What happens if the Stack user calls Remove()
instead of Pop()?– What happens if the superclass implementation is
modified?– The subclass developer is exposed to internal
information about the superclass and this may result in tight coupling of subclass to superclass.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 21CEN 4010: Introduction to Software Engineering
Impl. vs Interface InheritanceImpl. vs Interface Inheritance
Implementation inheritance– Also called class inheritance– Goal: Extend an application’s 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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 22CEN 4010: Introduction to Software Engineering
DelegationDelegation
Delegation – is an alternative to implementation inheritance.– is as powerful as implementation 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.
Client Receiver DelegateDelegates to calls
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 23CEN 4010: Introduction to Software Engineering
Delegation vs. Impl. Delegation vs. Impl. InheritanceInheritance
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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 24CEN 4010: Introduction to Software Engineering
ComparisonComparison
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)
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 25CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 26CEN 4010: Introduction to Software Engineering
Reuse CodeReuse Code
Select existing code– class libraries– frameworks– 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
What are the differences among class libraries, frameworks, and components?– They are all composed of a set of related classes.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 27CEN 4010: Introduction to Software Engineering
FrameworksFrameworks
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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 28CEN 4010: Introduction to Software Engineering
Key BenefitsKey Benefits
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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 29CEN 4010: Introduction to Software Engineering
Classification of FrameworksClassification of Frameworks
White-Box 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.
Black-Box 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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 30CEN 4010: Introduction to Software Engineering
Another Classification of Another Classification of FrameworksFrameworks
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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 31CEN 4010: Introduction to Software Engineering
Class libraries and FrameworksClass 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…. )
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 32CEN 4010: Introduction to Software Engineering
Components and FrameworksComponents and Frameworks
Components– Self-contained instances of classes.– Plugged together to form complete applications.– Defines a cohesive set of operations– Can be used based on the syntax and semantics
of the interface. – Components may 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 black-box
frameworks.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 33CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 34CEN 4010: Introduction to Software Engineering
Documenting the System Documenting the System DesignDesign
Purpose – System design is documented in the System Design
Document (SDD). It describes design goals set by the project, subsystem decomposition (with UML class diagrams), hardware/software mapping (with UML deployment diagrams), data management, access control, control flow mechanisms, and boundary conditions. The SDD is used to define interfaces between teams of developers and serve as a reference when architecture-level decisions need to be revisited.
Audience – The audience for the SDD includes the project
management, the system architects (i.e., the developers who participate in the system design), and the developers who design and implement each subsystem.
Template – http://wwwbruegge.in.tum.de/OOSE/
SystemDesignDocumentTemplate
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 35CEN 4010: Introduction to Software Engineering
SDD TemplateSDD Template
Outline 1. Introduction
1.1 Purpose of the system 1.2 Design goals 1.3 Definitions, acronyms, and abbreviations 1.4 References 1.5 Overview
2. Current software architecture 3. Proposed software architecture
1. Overview 2. Subsystem decomposition 3. Hardware/software mapping 4. Persistent data management 5. Access control and security 6. Global software control 7. Boundary conditions
4. Subsystem servicesGlossary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 36CEN 4010: Introduction to Software Engineering
Documenting the Object DesignDocumenting the Object Design
Purpose – Object design is documented in the Object Design
Document (ODD). It describes object design trade-offs made by developers, guidelines they followed for subsystem interfaces, the decomposition of subsystems into packages and classes, and the class interfaces. The ODD is used to exchange interface information among teams and as a reference during testing.
Audience – The audience for the ODD includes system
architects (i.e., the developers who participate in the system design), developers who implement each subsystem, and testers.
Template– http://wwwbruegge.in.tum.de/OOSE/
ObjectDesignDocumentTemplate
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 37CEN 4010: Introduction to Software Engineering
ODD Template ODD Template (1)(1)
Outline
1. Introduction1. Object design trade-offs
e.g., buy vs. build, memory space vs. response time
2. Interface documentation guidelinese.g., naming conventions, boundary cases, exception handling
mechanisms
3. Definitions, acronyms, and abbreviation
4. References
2. Packages describes the decomposition of subsystems into packages
and the file organization of the code. This includes an overview of each package, its dependencies with other packages, and its expected usage.3.
3. Class interfaces
Glossary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 38CEN 4010: Introduction to Software Engineering
Alternative Approaches for Alternative Approaches for ODDODD
Self-Contained ODD generated from model– Write and maintain a UML model and generate the
document automatically– con: redundancy with the RAD and source code,
hard to maintain consistency. ODD as extension of the RAD
– The set of application objects augmented with solution objects.
– pro: easier to maintain consistency with the RAD.– con: polluting the RAD with irrelevant information
for the user and client, also it may not be possible. ODD embedded into source code
– represent the ODD using a modeling tool.– Once it becomes stable, generate class stubs.– Complete the source code and comments.– Generate the ODD using a tool such as JavaDoc.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 39CEN 4010: Introduction to Software Engineering
RADDocumentanalysis
Analysis
Analysis model
Object design
Initial objectdesign model
Generate class stubs
Initial classstubs
ODDDocumentobject design
System design
Implementation
Commented code
Subsystemdecomposition Design goals
Embedded ODD approachEmbedded ODD approachOvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 40CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 41CEN 4010: Introduction to Software Engineering
JavaDocJavaDoc
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
*/
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 42CEN 4010: Introduction to Software Engineering
More on JavaDocMore 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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 43CEN 4010: Introduction to Software Engineering
Class and Interface Doc TagsClass 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
– Example: @deprecated Replaced by setBounds(int, int, int, int).
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 44CEN 4010: Introduction to Software Engineering
Constructor and Method Doc Constructor and Method Doc TagsTags
Can contain @see tag, @since tag, @deprecated 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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 45CEN 4010: Introduction to Software Engineering
Example of a Class Doc Example of a Class Doc CommentComment
/** * A class representing a window on the screen. * For example: * <pre> * Window win = new Window(parent); * win.show(); * </pre> * * @author Sami Shaio * @version %I%, %G% * @see java.awt.BaseWindow * @see java.awt.Button */ class Window extends BaseWindow { ...
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 46CEN 4010: Introduction to Software Engineering
Example of a Method Doc Example of a Method Doc CommentComment
/** * Returns the character at the specified index. An
index * ranges from <code>0</code> to <code>length() -
1</code>. * * @param index the index of the desired
character. * @return the desired character. * @exception StringIndexOutOfRangeException * if the index is not in the range
<code>0</code> * to <code>length()-1</code>. * @see java.lang.Character#charValue() */ public char charAt(int index) { ... }
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 47CEN 4010: Introduction to Software Engineering
Example of a Field Doc Example of a Field Doc CommentComment
A field comment can contain only the @see, @since and @deprecated tags
/**
* The X-coordinate of the window.
*
* @see window#1
*/
int x = 1263732;
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 48CEN 4010: Introduction to Software Engineering
Example: Specifying a ServiceExample: Specifying a Service
/** 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 */
* @param NAME name is a nonempty string */
public void AddOccupant(string name);
/** @Return Returns the name of the office. Requires, that Office has been initialized with a name */
public string GetName();
....
}
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 49CEN 4010: Introduction to Software Engineering
Package it all upPackage 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
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 50CEN 4010: Introduction to Software Engineering
Packaging HeuristicsPackaging 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)
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 51CEN 4010: Introduction to Software Engineering
AgendaAgenda
Overview of Object Design
Reuse Concepts
Inheritance and Delegation
Components, Frameworks, and Libraries
System and Object Design Document
JavaDoc and Packaging
Summary
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary
Ninth Lecture 52CEN 4010: Introduction to Software Engineering
SummarySummary
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 Select existing code
– 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.
OvervieOverview:w:Overview
Reuse Concepts
Inher., Deleg.
Comp., FW, Lib
Documentation
JavaDoc & Pack.
Summary