Introduction to Software Engineering CEN4010 Object Design Spring

Introduction to Software Engineering (CEN-4010) Object Design Spring 2006 Instructor: Masoud Sadjadi http: //www. cs. fiu. edu/~sadjadi/ CEN 4010 Ninth Lecture March 15, 2006

Acknowledgements Overview: Overview Dr. Bernd Bruegge Dr. Allen Dutoit Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 2

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 3

Object Design Overview: Overview 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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 CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 4

Object Design: Closing the Gap Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 5

App. vs. Solution Domain Objects Overview: Overview 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 6

Example Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Requirements Analysis (Language of Application Domain) Object Design (Language of Solution Domain) Documentation Incident Report. Form Java. Doc & Pack. Summary Incident Report Text box CEN 4010: Introduction to Software Engineering Menu Scrollbar Ninth Lecture on March 15, 2006 7

Refining App. Domain Objects Overview: Overview 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 Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Example: The Erase. Area() 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 CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 8

Examples of Object Design Activities Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib – System Design => Service – Object Design => API Documentation Java. Doc & Pack. Summary Identification of existing components Full definition of associations Full definition of classes 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 CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 9

Object Design Activities (1) Overview: Overview Select Subsystem Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Specification Identifying missing attributes & operations Reuse Identifying components Specifying visibility Adjusting components Specifying types & signatures Identifying patterns Specifying constraints Specifying exceptions CEN 4010: Introduction to Software Engineering Adjusting patterns Ninth Lecture on March 15, 2006 10

Object Design Activities (1) Overview: Overview Check Use Cases Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Restructuring Optimization Revisiting inheritance Optimizing access paths Collapsing classes Caching complex computations Realizing associations Delaying complex computations CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 11

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 12

Reuse Motivation Overview: Overview Reuse Concepts Observation about Modeling of the Real World in [Gamma et al 94] Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary – 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 13

Reuse Heuristics Overview: Overview Look for existing classes in class libraries – JSAPI, JTAPI, . . Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Select data structures appropriate to the algorithms – Container classes – Arrays, lists, queues, stacks, sets, trees, . . . Summary Define new internal classes and operations only if necessary – Complex operations defined in terms of lower-level operations might need new classes and operations CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 14

Reuse Overview: Overview Main goal: – Reuse knowledge and functionality from previous experience to current problem. – Approaches: Inheritance and Delegation Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 15

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 16

Metamodel for Inheritance Overview: Overview Reuse Concepts Inheritance is used to achieve two different goals: Taxonomies and Reuse. Inher. , Deleg. Comp. , FW, Lib Documentation Inheritance Java. Doc & Pack. Summary Object Design Analysis activity Taxonomy Inheritance detected by specialization by generalization CEN 4010: Introduction to Software Engineering Inheritance for Reuse Interface Inheritance Implementation Inheritance Ninth Lecture on March 15, 2006 17

Taxonomy Example Overview: Overview Reuse Concepts Inher. , Deleg. Mammal Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Tiger Wolf CEN 4010: Introduction to Software Engineering Wale Ninth Lecture on March 15, 2006 18

Implementation Inheritance Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation A very similar class is already implemented that does almost the same as the desired class implementation. “Already implemented” Java. Doc & Pack. Summary 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()? CEN 4010: Introduction to Software Engineering List Add () Remove() Stack Push () Pop() Top() Ninth Lecture on March 15, 2006 19

Problems Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 20

Impl. vs Interface Inheritance Overview: Overview 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 Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Interface inheritance – Also called subtyping – Inherit from an abstract class with all operations specified, but not yet implemented CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 21

Delegation Overview: Overview Delegation – is an alternative to implementation inheritance. – is as powerful as implementation inheritance. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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 calls Receiver CEN 4010: Introduction to Software Engineering Delegates to Delegate Ninth Lecture on March 15, 2006 22

Delegation vs. Impl. Inheritance Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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? List +Add() +Remove() Stack +Push() +Pop() +Top() CEN 4010: Introduction to Software Engineering List Remove() Add() Ninth Lecture on March 15, 2006 23

Comparison Overview: Overview – Pro: Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Flexibility: Any object can be replaced at run time by another one (as long as it has the same type) – Con: Documentation Java. Doc & Pack. Summary Delegation 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) CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 24

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 25

Reuse Code Overview: Overview Select existing code – class libraries – frameworks – components Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 26

Frameworks Overview: Overview 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 27

Key Benefits Overview: Overview Reusability – leverages of the application domain knowledge and prior effort of experienced developers. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 28

Classification of Frameworks Overview: Overview 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 29

Another Classification of Frameworks Overview: Overview – 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Infrastructure frameworks Middleware frameworks – are used to integrate existing distributed applications and components. – Examples: MFC, DCOM, Java RMI, Web. Objects, Web. Sphere, Web. Logic Enterprise Application [BEA]. Summary Enterprise application frameworks – are application specific and focus on domains – Example domains: telecommunications, avionics, environmental modeling, manufacturing, financial engineering, enterprise business activities. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 30

Class libraries and Frameworks Overview: Overview – Less domain specific – Provide a smaller scope of reuse. – Class libraries are passive; no constraint on control flow. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Class Libraries: Summary 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…. ) CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 31

Components and Frameworks Overview: Overview 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 32

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 33

Documenting the System Design Overview: Overview 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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/System. Design. Docu ment. Template CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 34

SDD Template Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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. 2. 3. 4. 5. 6. 7. Overview Subsystem decomposition Hardware/software mapping Persistent data management Access control and security Global software control Boundary conditions 4. Subsystem services Glossary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 35

Documenting the Object Design Overview: Overview Purpose – Object design is documented in the Object Design Document (ODD). It describes object design tradeoffs 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. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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/Object. Design. D ocument. Template CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 36

ODD Template (1) Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Outline 1. Introduction 1. Object design trade-offs e. g. , buy vs. build, memory space vs. response time 2. Interface documentation guidelines e. 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. Class interfaces Glossary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 37

Alternative Approaches for ODD Overview: Overview – Write and maintain a UML model and generate the document automatically – con: redundancy with the RAD and source code, hard to maintain consistency. Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Self-Contained ODD generated from model 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. Summary 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 Java. Doc. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 38

Embedded ODD approach Overview: Overview Analysis Reuse Concepts Inher. , Deleg. Analysis model Comp. , FW, Lib Document analysis RAD System design Documentation Subsystem decomposition Java. Doc & Pack. Summary Design goals Object design Initial object design model Generate class stubs Initial class stubs Implementation Commented code Document object design CEN 4010: Introduction to Software Engineering ODD Ninth Lecture on March 15, 2006 39

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 40

Java. Doc Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Add documentation comments to the source code. A doc comment consists of characters between /** and */ When Java. Doc 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 */ CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 41

More on Java. Doc Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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 <h 1> and <h 2>, because Java. Doc 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 CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 42

Class and Interface Doc Tags Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary @author name-text – Creates an “Author” entry. @version-text – Creates a “Version” entry. @see classname – Creates a hyperlink “See Also classname” @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-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 set. Bounds(int, int). CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 43

Constructor and Method Doc Tags Overview: Overview Reuse Concepts Can contain @see tag, @since tag, @deprecated as well as: Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary @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. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 44

Example of a Class Doc Comment Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary /** * 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. Base. Window * @see java. awt. Button */ class Window extends Base. Window {. . . CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 45

Example of a Method Doc Comment Overview: Overview /** * Returns the character at the specified index. An Reuse Concepts index Inher. , Deleg. * ranges from <code>0</code> to <code>length() 1</code>. * * @param index the index of the desired character. * @return the desired character. * @exception String. Index. Out. Of. Range. Exception * if the index is not in the range <code>0</code> * to <code>length()-1</code>. * @see java. lang. Character#char. Value() */ public char. At(int index) {. . . } Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 46

Example of a Field Doc Comment Overview: Overview Reuse Concepts Inher. , Deleg. A field comment can contain only the @see, @since and @deprecated tags Comp. , FW, Lib Documentation Java. Doc & Pack. Summary /** * The X-coordinate of the window. * * @see window#1 */ int x = 1263732; CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 47

Example: Specifying a Service Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation /** 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 Add. Occupant(string name); Java. Doc & Pack. Summary /** @Returns the name of the office. Requires, that Office has been initialized with a name */ public string Get. Name(); . . } CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 48

Package it all up Overview: Overview Reuse Concepts Inher. , Deleg. – Ideally use one package for each subsystem – System decomposition might not be good for implementation. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary Pack up design into discrete physical units that can be edited, compiled, linked, reused Construct physical modules 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 CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 49

Packaging Heuristics Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary 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) CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 50

Agenda Overview: Overview of Object Design Reuse Concepts Inheritance and Delegation Components, Frameworks, and Libraries System and Object Design Document Java. Doc and Packaging Summary Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. Summary CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 51

Summary Overview: Overview Reuse Concepts Inher. , Deleg. Comp. , FW, Lib Documentation Java. Doc & Pack. 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: ü ü ü – – – Summary 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 Java. Doc. CEN 4010: Introduction to Software Engineering Ninth Lecture on March 15, 2006 52