Register your product to gain access to bonus material or receive a coupon.
Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design
- By Craig Larman
- Published Oct 30, 1997 by Pearson.
Book
- Sorry, this book is no longer in print.
About
Features
- Shows developers how to make practical use of the most significant recent developments in object-oriented analysis and design—UML and patterns.
- Covers how to investigate requirements, create solutions, and then translate designs into code.
- Includes extensive practical job aids—Summary of UML notation, Checklists of class categories, and Summaries of patterns.
Description
- Copyright 1998
- Edition: 1st
- Book
- ISBN-10: 0-13-748880-7
- ISBN-13: 978-0-13-748880-3
74888-9
Master the Unified Modeling Language, the new standard for object orientation.
It's not enough just to learn an object-oriented language. A proficient programmer must also have the ability to design robust, scalable, maintainable systems. Applying UML and Patterns was written especially to provide the foundation for a complete understanding of the object paradigm, and how to put it to practical use.
Applying UML and Patterns provides beginning object programmers with a detailed activity roadmap to guide them through each step of requirements, analysis, design, and coding. This book strongly emphasizes translating theoretical concepts to practical applications, including:
- Mapping object-oriented diagrams directly to Java code
- Expressing models using UML
- Integrating patterns for analysis and design
- Creating layered architectures
- Building frameworks
Using a single integrated case study throughout the book, Applying UML and Patterns provides a comprehensive, hands-on approach that gives a thorough grounding to beginning and intermediate programmers.
This book is also available as part of Applying UML and Patterns - The Complete Video Course (ISBN: 0-13-025559-9).
Sample Content
Downloadable Sample Chapter
Click here for a sample chapter for this book: 0137488807.pdf
Table of Contents
I. INTRODUCTION.
1. Object-Oriented Analysis and Design.2. Introduction to a Development Process.
3. Defining Models and Artifacts.
II. PLAN AND ELABORATE PHASE.
4. Case Study: Point-of-Sale.5. Understanding Requirements.
6. Use Cases: Describing Processes.
7. Ranking and Scheduling Use Cases.
8. Starting a Development Cycle.
III. ANALYZE PHASE (1).
9. Building a Conceptual Model.10. Conceptual Model-Adding Associations.
11. Conceptual Model-Adding Attributes.
12. Recording Terms in the Glossary.
13. System Behavior-System Sequence Diagrams.
14. System Behavior-Contracts.
IV. DESIGN PHASE (1).
15. From Analysis to Design.16. Describing Real Use Cases.
17. Collaboration Diagrams.
18. GRASP: Patterns for Assigning Responsibilities.
19. Designing a Solution with Objects and Patterns.
20. Determining Visibility.
21. Design Class Diagrams.
22. Issues in System Design.
V. CONSTRUCT PHASE (1).
23. Mapping Designs To Code.24. Program Solution In Java.
VI. ANALYZE PHASE (2).
25. Choosing Development Cycle 2 Requirements.26. Relating Multiple Use Cases.
27. Extending the Conceptual Model.
28. Generalization.
29. Packages: Organizing Elements.
30. Polishing the Conceptual Model.
31. Conceptual Model-Summary.
32. System Behavior.
33. Modeling Behavior in State Diagrams.
VII. DESIGN PHASE (2).
34. GRASP: More Patterns for Assigning Responsibilities.35. Designing with More Patterns.
VIII. SPECIAL TOPICS.
36. Other UML Notation.37. Development Process Issues.
38. Frameworks, Patterns, and Persistence.
Appendix A. Recommended Readings.
Appendix B. Sample Development Activities and Models.
Bibliography.
Glossary.
Index.
Preface
Preface
Congratulations and thank you for reading this book! You hold in your hands a practical guide and roadmap through the landscape of object-oriented analysis and design. Here is how it will benefit you.
Design robust and maintainable object systems.
First, the use of object technology is proliferating in the development of software-even more so with the widespread adoption of Java-and mastery of object-oriented analysis and design is critical for you to create robust and maintainable object-oriented systems. It also opens up new opportunities for you as an architect, analyst, and designer.
Follow a roadmap through requirements, analysis, design and coding.
Second, if you are new to object-oriented analysis and design, you are understandably challenged about how to proceed through this complex subject; this book presents a well-defined activity roadmap so that you can move in a step-by-step process from requirements to code.
Use the UML to illustrate analysis and design models.
Third, the Unified Modeling Language (UML) has emerged as the standard notation for modeling; so it is useful for you to be conversant in it. This book teaches the skills of object-oriented analysis and design using the UML notation.
Improve designs by applying the "gang-of-four" and GRASP design patterns.
Fourth, design patterns communicate the "best practice" idioms and solutions that object-oriented design experts apply in order to create systems. In this book you will learn to apply design patterns, including the popular "gang-of-four" patterns, and most importantly the GRASP patterns which communicate very fundamental principles of responsibility assignment in object-oriented design. Learning and applying patterns will accelerate your mastery of analysis and design.
Learn efficiently by following a refined presentation.
Fifth, the structure and emphasis in this book is based on years of experience in training and mentoring people in the art of object-oriented analysis and design. It reflects that experience by providing a refined, proven, and efficient approach to learning the subject so your investment in reading and learning is optimized.
Learn from a realistic exercise.
Sixth, it exhaustively examines a single case study-to realistically illustrate the entire object-oriented analysis and design process, and goes deeply into thorny details of the problem; it is a realistic exercise.
Translate to code.
Seventh, it shows how to map object-oriented design artifacts to code in Java.
Design a layered architecture.
Eighth, it explains how to design a layered architecture and relate the graphical user interface layer to domain and system services layers. This is a matter of practical importance that is often overlooked.
Design a framework.
Finally, it shows you how to design an object-oriented framework and specifically applies this to the creation of a framework for persistent storage in a database.
Objectives
The overarching objective is this:
Help students and developers create better object-oriented designs through the application of a set of explainable principles and heuristics.
By studying and applying the information and techniques presented here, you will become more adept at understanding a problem in terms of its processes and concepts, and designing a solid solution using objects.
Intended Audience
This book is for the following audience:
- Developers with experience in an object-oriented programming language, but who are new-or relatively new-to object-oriented analysis and design.
- Students in computer science or software engineering courses studying object technology.
- Those with some familiarity in object-oriented analysis and design who want to learn the Unified Modeling Language notation, apply patterns, or who want to sharpen and deepen their analysis and design skills.
Prerequisites
Some prerequisite knowledge is assumed-and necessary-to benefit from this book:
- Knowledge and experience in an object-oriented programming language such as C++, Java, or Smalltalk.
- Knowledge of fundamental object technology concepts, such as class, instance, interface, polymorphism, encapsulation, and inheritance.
Fundamental object technology concepts are not defined.
Book Organization
The overall strategy in the organization of this book is that object-oriented analysis and design topics are introduced in an order similar to that of a software development project running across two iterative development cycles. The first development cycle introduces analysis and design. In the second development cycle, new analysis and design topics are presented and existing ones are explored more deeply.
Figure 1. The organization of the book follows that of a development project.
Motivation for this Book
Object technology holds great promise, but its potential will not be fully realized without the appropriate skills. It is my goal to promote the successful adoption of object technology through the skillful activity of object-oriented analysis and design, and to promote the acquisition of related abilities, because I observe these are critical for the successful creation and maintenance of significant systems.
Acknowledgments
Thanks to all the users and students of the UML and object-oriented analysis and design who I have tried to assist; they are my best teachers.
Special thanks to the reviewers of this book (or portions), including Kent Beck, Jens Coldewey, Clay Davis, Tom Heruska, Luke Hohmann, David Norris, David Nunn, Brett Schuchert, and the entire Mercury team. Thanks to Grady Booch for reviewing a tutorial related to this work, and to Jim Rumbaugh for some feedback related to the relationship between the UML and process.
For insightful feedback on process and models, thanks to Todd Girvin, John Hebley, Tom Heruska, David Norris, David Nunn, Charles Rego, and Raj Wall.
Many thanks to Grady Booch, Ivar Jacobson, and Jim Rumbaugh for the development of the Unified Modeling Language; creating an open, standard notation in the current Tower of Babel environment is most welcome. In addition, I have learned much from their teachings.
Thanks to my colleague Jef Newsom for providing the case study Java solution. Thanks to my publisher at Prentice-Hall, Paul Becker, for believing that this would be a worthwhile project.
Finally, a special thanks to Graham Glass for opening a door.
About the Author
Craig Larman has a B.Sc. and M.Sc. in computing science and since 1978 has been developing large and small software systems on platforms ranging from mainframes to microcomputers, using software technologies ranging from 4GLs to logic programming to object-oriented programming.
In the early 1980s he fell in love with artificial intelligence and knowledge systems programming techniques, from which he received his first exposure to object-oriented programming (in Lisp). He has taught and worked with object-oriented programming in Lisp since 1984, Smalltalk since 1986, C++ since 1991, and recently Java, in conjunction with teaching a variety of object-oriented analysis and design methods. He has assisted over 2,000 students in learning object technology topics.
He is currently Principal Instructor at ObjectSpace, a company specializing in distributed computing, agents, and object technology.
Craig may be reached at clarman@acm.org