Advanced Object-Oriented Analysis and Design Using UML


Composed of updated versions of James Odell's articles from The Journal of Object-Oriented Programming, ROAD , and Object Magazine, this book works to convey the essence of object-oriented programming and software building through the Unified Modeling Language (UML). The author provides concise but in-depth pieces on structural issues, dynamic issues, business rules, object complexity, object aggregation, design templates, and the process of objects.

See more details below
$64.34 price
(Save 10%)$72.00 List Price
Other sellers (Paperback)
  • All (32) from $1.99   
  • New (12) from $3.10   
  • Used (20) from $1.99   
Sending request ...


Composed of updated versions of James Odell's articles from The Journal of Object-Oriented Programming, ROAD , and Object Magazine, this book works to convey the essence of object-oriented programming and software building through the Unified Modeling Language (UML). The author provides concise but in-depth pieces on structural issues, dynamic issues, business rules, object complexity, object aggregation, design templates, and the process of objects.

Read More Show Less

Editorial Reviews

From the Publisher
"These pages contain the essence of what it is to understand the world as objects and build software based on that understanding. You will be able to come back to these articles time and again, gaining new layers of understanding as you gain layers of experience." Kent Beck

"There is certainly good information in this book, and it is presented well. This book should be useful to those seriously interested in object-oriented analysis and design (OOAD)...." Computing Reviews

Read More Show Less

Product Details

  • ISBN-13: 9780521648196
  • Publisher: SIGS
  • Publication date: 3/28/2012
  • Series: SIGS Reference Library Series , #12
  • Pages: 246
  • Product dimensions: 5.98 (w) x 8.98 (h) x 0.59 (d)

Read an Excerpt

Part VI: Design Templates

Interface for Association Templates

For each association, the OOPL interface consists of a set of operations that access and update the association. The exact terms and structure of these operations depend on the cardinalities of the relevant mappings.

In general, a single-valued mapping requires two operations: an accessor and a modifier. The accessor operation returns the object to which a given object is mapped. The modifier operation changes the mapping for a given object by reassigning the mapping pointer from one object to another. Access requests, then, require no input parameters. Modification requests, however, require an input parameter that specifies the object to which the mapping must now point. Thus, for Fig. 17.2, the Employee class would have two operations. In C++, no standard naming convention exists. Here, many programmers use get or set somewhere in the name. For example, the names getEmployer and setEmployer (Organization org) could be used to access and modify the employer mapping. The names getEmployer and setEmployer are the most natural. However, some prefer employerSet and employerGet, because both operations will appear together In an alphabetically sorted browser. In Smalltalk, both operations are conventionally given the mapping name. Here, modifiers are distinguished from accessors by the presence of a parameter. Therefore, the Employee class would have get and set operations named employer and employer: anOrganization.

Multivalued mappings require three operations - again, with one accessor. Single-valued accessors return just one object. Multivalued accessors, however, return aset of objects. (All multivalued mappings are assumed to be sets unless otherwise indicated. The interface for non-sets will be different and is beyond the scope of this month's column.) Multivalued modifiers require two operations - one to add an object to a set, the other to remove an object. The accessor will usually be named in the same way that a singlevalued mapping is named. However, a plural form is recommended to reinforce its multivalued nature-for example, employees or getEmployees. Modifiers would take the form of AddEmployee (Employee emp), RemoveEmployee (Employee emp), or employeeAdd: anEmployee, employeeRemove: anEmployee.

Modifiers, whether single-valued or multivalued, should also ensure that the constraints are met. For example, the SetEmployer operation should ensure that the employer mapping of Employee is not set to null. In other words, the modifier should ensure that both minimum and maximum cardinality constraints are met. Any other constraints, such as invariant, tree, and user-defined constraints, should also be enforced at this time.

Type checking should also be performed. For example, if a SetEmployer: anOrganization operation is requested, the object supplied via the anOrganization parameter must always be an Organization object. If type checking is not built into the programming language, extra code can be added to the modifier operations to ensure type integrity.

Association template option 1: using pointers in both directions

In this option, mappings are implemented by pointers from both participating classes. If a mapping is single valued, there is a single pointer from one object to another. For example in Fig. 17.3, each Employee has a single pointer to his employer. If a mapping is multivalued, the object will have a set of pointers to the other objects. In Fig. 17.3, NASA points to a set of pointers which, in turn, contains pointers to Peter, Jasper, and Paul. For languages that support containment, an object may hold its set of mapping pointers internally rather than point to an external collection. Containment, therefore, has implications for space requirements. Since pointer sets can dramatically increase in size, an object's size can swell. Single-valued mappings can also use containment. Here, the actual object will be stored internally, instead of a pointer to that object. Typically, single-valued containment is limited to storing fundamental objects internally, such as Integer or Date objects. (Fundamental objects will be discussed later in option 6.)

In option 1, the accessor operations are relatively straightforward. For a single-valued mapping, the accessor merely returns a reference to the mapped object. For a multivalued mapping, the accessor returns a set of references. However, it should not return the set of references. If it did return the set, the set's user could change the set's membership-thereby violating encapsulation. The encapsulation boundary should include all sets implementing multivalued mappings. One solution is returning a copy of the set. Thus, if any alterations are made, they do not affect the actual mapping. However, this may incur a significant time overhead for large sets. An alternative is to use a masking class. A masking class is a simple class that has a single field containing the set. Only those operations that are permitted on the contained set are defined in the masking class. This way modifications can be blocked. Another alternative, particularly for C++ implementations, uses iterators as described by Gamma [Gamma, 1995]. Iterators provide a highly flexible way to access the elements of a multivalued mapping without exposing underlying representation.

Since two pointers implement each relationship, modifiers should maintain a two-way, or referential, integrity. Thus, a modifier called to change Peter's employer to IBM must not just change Peter's pointer to IBM. It must also delete the inverse pointer to Peter in NASA'S employees' set and create one in IBM's employees' set.

This template option has both benefits and drawbacks. Its accessor navigation is fast in both directions. However, ensuring referential integrity requires extra processing time. So, while this option provides fast access, modification requires extra time. Additionally, the technique to ensure referential integrity is not trivial. However, once a solution has been chosen, replication is easy. Another disadvantage lies in the space required for this option. Not only are pointers required in both directions, but multivalued mappings can require large sets....

Read More Show Less

Table of Contents

Part I. Structural Issues: 1. Modeling objects: using Binary- and Entity-relationship approaches; 2. Object types as objects and vice versa; 3. Power types; 4. Specifying structural constraints; 5. Toward a formalization of OO analysis; Part II. Dynamic Issues: 6. What is object state?; 7. Dynamic and multiple classification; 8. Events and their specification; 9. Approaches to finite-state machine modeling; Part III. Business Rules: 10. Business rules; 11. Using rules with diagrams; Part IV. Object Complexity: 12. Managing object complexity, Part I: classification and generalization; 13. Managing object complexity, Part II: aggregation; Part V. Object Aggregation: 14. Six different kinds of aggregation; 15. A foundation for aggregation; 16. A user-level model of aggregation; Part VI. Design Templates: 17. From analysis to design using templates, Part I; 18. From analysis to design using templates, Part II; 19. From analysis to design using templates, Part III; Part VII. The Process of Objects: 20. Method engineering; 21. User workshop techniques; 22. Object-oriented methodologies.

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)