Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development / Edition 3

Hardcover (Print)
Rent
Rent from BN.com
$14.10
(Save 83%)
Est. Return Date: 12/23/2014
Buy Used
Buy Used from BN.com
$50.00
(Save 41%)
Item is in good condition but packaging may have signs of shelf wear/aging or torn packaging.
Condition: Used – Good details
Used and New from Other Sellers
Used and New from Other Sellers
from $27.00
Usually ships in 1-2 business days
(Save 68%)
Other sellers (Hardcover)
  • All (27) from $27.00   
  • New (15) from $52.69   
  • Used (12) from $27.00   

Overview

“This edition contains Larman’s usual accurate and thoughtful writing. It is a very good book made even better.”
Alistair Cockburn, author, Writing Effective Use Cases and Surviving OO Projects
“Too few people have a knack for explaining things. Fewer still have a handle on software analysis and design. Craig Larman has both.”
John Vlissides, author, Design Patterns and Pattern Hatching
“People often ask me which is the best book to introduce them to the world of OO design. Ever since I came across it Applying UML and Patterns has been my unreserved choice.”
Martin Fowler, author, UML Distilled and Refactoring
“This book makes learning UML enjoyable and pragmatic by incrementally introducing it as an intuitive language for specifying the artifacts of object analysis and design. It is a well written introduction to UML and object methods by an expert practitioner.”
Cris Kobryn, Chair of the UML Revision Task Force and UML 2.0 Working Group
  • A brand new edition of the world’s most admired introduction to object-oriented analysis and design with UML
  • Fully updated for UML 2 and the latest iterative/agile practices
  • Includes an all-new case study illustrating many of the book’s key points

Applying UML and Patterns is the world’s #1 business and college introduction to “thinking in objects”—and using that insight in real-world object-oriented analysis and design. Building on two widely acclaimed previous editions, Craig Larman has updated this book to fully reflect the new UML 2 standard, to help you master the art of object design, and to promote high-impact, iterative, and skillful agile modeling practices.

Developers and students will learn object-oriented analysis and design (OOA/D) through three iterations of two cohesive, start-to-finish case studies. These case studies incrementally introduce key skills, essential OO principles and patterns, UML notation, and best practices. You won’t just learn UML diagrams—you’ll learn how to apply UML in the context of OO software development.

Drawing on his unsurpassed experience as a mentor and consultant, Larman helps you understand evolutionary requirements and use cases, domain object modeling, responsibility-driven design, essential OO design, layered architectures, “Gang of Four” design patterns, GRASP, iterative methods, an agile approach to the Unified Process (UP), and much more. This edition’s extensive improvements include

  • A stronger focus on helping you master OOA/D through case studies that demonstrate key OO principles and patterns, while also applying the UML
  • New coverage of UML 2, Agile Modeling, Test-Driven Development, and refactoring
  • Many new tips on combining iterative and evolutionary development with OOA/D
  • Updates for easier study, including new learning aids and graphics
  • New college educator teaching resources
  • Guidance on applying the UP in a light, agile spirit, complementary with other iterative methods such as XP and Scrum
  • Techniques for applying the UML to documenting architectures
  • A new chapter on evolutionary requirements, and much more

Applying UML and Patterns, Third Edition, is a lucid and practical introduction to thinking and designing with objects—and creating systems that are well crafted, robust, and maintainable.

Read More Show Less

Product Details

  • ISBN-13: 9780131489066
  • Publisher: Prentice Hall
  • Publication date: 10/22/2004
  • Edition description: REV
  • Edition number: 3
  • Pages: 704
  • Sales rank: 323,486
  • Product dimensions: 8.37 (w) x 10.25 (h) x 1.64 (d)

Meet the Author

Craig Larman serves as chief scientist at Valtech, a leading technology consultancy with offices throughout the United States, Europe, and Asia. He is known throughout the worldwide software community as an expert and coach in OOA/D and design patterns, agile/iterative methods, an agile approach to the Unified Process (UP), and modeling with the UML. He holds a B.S. and M.S. in computer science from Simon Fraser University in Vancouver, British Columbia.

Read More Show Less

Table of Contents

Foreword.

Preface.

I. INTRODUCTION.

1. Object-Oriented Analysis and Design.

What Will You Learn? Is it Useful?

The Most Important Learning Goal?

What is Analysis and Design?

What is Object-Oriented Analysis and Design?

A Short Example.

What is the UML?

Visual Modeling is a Good Thing.

History.

Recommended Resources.

2. Iterative, Evolutionary, and Agile.

What is the UP? Are Other Methods Complementary?

What is Iterative and Evolutionary Development?

What About the Waterfall Lifecycle?

How to do Iterative and Evolutionary Analysis and Design?

What is Risk-Driven and Client-Driven Iterative Planning?

What are Agile Methods and Attitudes?

What is Agile Modeling?

What is an Agile UP?

Are There Other Critical UP Practices?

What are the UP Phases?

What are the UP Disciplines?

How to Customize the Process? The UP Development Case.

You Know You Didn't Understand Iterative Development or the UP When.

History.

Recommended Resources.

3. Case Studies.

What is and isn't Covered in the Case Studies?

Case Study Strategy: Iterative Development + Iterative Learning.

Case One: The NextGen POS System.

Case Two: The Monopoly Game System.

II. INCEPTION.

4. Inception is Not the Requirements Phase.

What is Inception?

How Long is Inception?

What Artifacts May Start in Inception?

You Know You Didn't Understand Inception When...

How Much UML During Inception?

5. Evolutionary Requirements.

Definition: Requirements.

Evolutionary vs. Waterfall Requirements.

What are Skillful Means to Find Requirements?

What are the Types and Categories of Requirements?

How are Requirements Organized in UP Artifacts?

Does the Book Contain Examples of These Artifacts?

Recommended Resources.

6. Use Cases.

Example.

Definition: What are Actors, Scenarios, and Use Cases?

Use Cases and the Use-Case Model.

Motivation: Why Use Cases?

Definition: Are Use Cases Functional Requirements?

Definition: What are Three Kinds of Actors?

Notation: What are Three Common Use Case Formats?

Example: Process Sale, Fully Dressed Style.

What do the Sections Mean?

Notation: Are There Other Formats? A Two-Column Variation.

Guideline: Write in an Essential UI-Free Style.

Guideline: Write Terse Use Cases.

Guideline: Write Black-Box Use Cases.

Guideline: Take an Actor and Actor-Goal Perspective.

Guideline: How to Find Use Cases.

Guideline: What Tests Can Help Find Useful Use Cases?

Applying UML: Use Case Diagrams.

Applying UML: Activity Diagrams.

Motivation: Other Benefits of Use Cases? Requirements in Context.

Example: Monopoly Game.

Process: How to Work With Use Cases in Iterative Methods?

History.

Recommended Resources.

7. Other Requirements.

How Complete are these Examples?

Guideline: Should We Analyze These Thoroughly During Inception?

Guideline: Should These Artifacts be at the Project Website?

NextGen Example: (Partial) Supplementary Specification.

Commentary: Supplementary Specification.

NextGen Example: (Partial) Vision.

Commentary: Vision.

NextGen Example: A (Partial) Glossary.

Commentary: Glossary (Data Dictionary).

NextGen Example: Business Rules (Domain Rules).

Commentary: Domain Rules.

Process: Evolutionary Requirements in Iterative Methods.

Recommended Resources.

III. ELABORATION ITERATION 1-BASICS.

8. Iteration 1-Basics.

Iteration 1 Requirements and Emphasis: Core OOA/D Skills.

Process: Inception and Elaboration.

Process: Planning the Next Iteration.

9. Domain Models.

Example.

What is a Domain Model?

Motivation: Why Create a Domain Model?

Guideline: How to Create a Domain Model?

Guideline: How to Find Conceptual Classes?

Example: Find and Draw Conceptual Classes.

Guideline: Agile Modeling-Sketching a Class Diagram.

Guideline: Agile Modeling-Maintain the Model in a Tool?

Guideline: Report Objects-Include 'Receipt' in the Model?

Guideline: Think Like a Mapmaker; Use Domain Terms.

Guideline: How to Model the Unreal World?

Guideline: A Common Mistake with Attributes vs. Classes.

Guideline: When to Model with 'Description' Classes?

Associations.

Example: Associations in the Domain Models.

Attributes.

Example: Attributes in the Domain Models.

Conclusion: Is the Domain Model Correct?

Process: Iterative and Evolutionary Domain Modeling.

Recommended Resources.

10. System Sequence Diagrams.

Example: NextGen SSD.

What are System Sequence Diagrams?

Motivation: Why Draw an SSD?

Applying UML: Sequence Diagrams.

What is the Relationship Between SSDs and Use Cases?

How to Name System Events and Operations?

How to Model SSDs Involving Other External Systems?

What SSD Information to Place in the Glossary?

Example: Monopoly SSD.

Process: Iterative and Evolutionary SSDs.

History and Recommended Resources.

11. Operation Contracts.

Example.

Definition: What are the Sections of a Contract?

Definition: What is a System Operation?

Definition: Postconditions.

Example: enterItem Postconditions.

Guideline: Should We Update the Domain Model?

Guideline: When Are Contracts Useful?

Guideline: How to Create and Write Contracts.

Example: NextGen POS Contracts.

Example: Monopoly Contracts.

Applying UML: Operations, Contracts, and the OCL.

Process: Operation Contracts Within the UP.

History.

Recommended Resources.

12. Requirements to Design-Iteratively.

Iteratively Do the Right Thing, Do the Thing Right.

Provoking Early Change.

Didn't All That Analysis and Modeling Take Weeks To Do?

13. Logical Architecture and UML Package Diagrams.

Example.

What is the Logical Architecture? And Layers?

What Layers are the Focus in the Case Studies?

What is Software Architecture?

Applying UML: Package Diagrams.

Guideline: Design with Layers.

Guideline: The Model-View Separation Principle.

What's the Connection Between SSDs, System Operations, and Layers?

Example: NextGen Logical Architecture and Package Diagram.

Example: Monopoly Logical Architecture?

Recommended Resources.

14. On to Object Design.

Agile Modeling and Lightweight UML Drawing.

UML CASE Tools.

How Much Time Spent Drawing UML Before Coding?

Designing Objects: What are Static and Dynamic Modeling?

The Importance of Object Design Skill over UML Notation Skill.

Other Object Design Techniques: CRC Cards.

15. UML Interaction Diagrams.

Sequence and Communication Diagrams.

Novice UML Modelers Don't Pay Enough Attention to Interaction Diagrams!

Common UML Interaction Diagram Notation.

Basic Sequence Diagram Notation.

Basic Communication Diagram Notation.

16. UML Class Diagrams.

Applying UML: Common Class Diagram Notation.

Definition: Design Class Diagram.

Definition: Classifier.

Ways to Show UML Attributes: Attribute Text and Association Lines.

Note Symbols: Notes, Comments, Constraints, and Method Bodies.

Operations and Methods.

Keywords.

Stereotypes, Profiles, and Tags.

UML Properties and Property Strings.

Generalization, Abstract Classes, Abstract Operations.

Dependency.

Interfaces.

Composition Over Aggregation.

Constraints.

Qualified Association.

Association Class.

Singleton Classes.

Template Classes and Interfaces.

User-Defined Compartments.

Active Class.

What's the Relationship Between Interaction and Class Diagrams?

17. GRASP: Designing Objects with Responsibilities.

UML versus Design Principles.

Object Design: Example Inputs, Activities, and Outputs.

Responsibilities and Responsibility-Driven Design.

GRASP: A Methodical Approach to Basic OO Design.

What's the Connection Between Responsibilities, GRASP, and UML Diagrams?

What are Patterns?

Where are We Now?

A Short Example of Object Design with GRASP.

Applying GRASP to Object Design.

Creator.

Information Expert (or Expert).

Low Coupling.

Controller.

High Cohesion.

Recommended Resources.

18. Object Design Examples with GRASP.

What is a Use Case Realization?

Artifact Comments.

What's Next?

Use Case Realizations for the NextGen Iteration.

Use Case Realizations for the Monopoly Iteration.

Process: Iterative and Evolutionary Object Design.

Summary.

19. Designing for Visibility.

Visibility Between Objects.

What is Visibility?

20. Mapping Designs to Code.

Programming and Iterative, Evolutionary Development.

Mapping Designs to Code.

Creating Class Definitions from DCDs.

Creating Methods from Interaction Diagrams.

Collection Classes in Code.

Exceptions and Error Handling.

Defining the Sale.makeLineItem Method.

Order of Implementation.

Test-Driven or Test-First Development.

Summary of Mapping Designs to Code.

Introduction to the NextGen POS Program Solution.

Introduction to the Monopoly Program Solution.

21. Test-Driven Development and Refactoring.

Test-Driven Development.

Refactoring.

Recommended Resources.

IV. ELABORATION ITERATION 2-MORE PATTERNS.

22. UML Tools and UML as Blueprint.

Forward, Reverse, and Round-Trip Engineering.

What is a Common Report of Valuable Features?

What to Look For in a Tool?

If Sketching UML, How to Update the Diagrams After Coding?

Recommended Resources.

23. Quick Analysis Update.

Case Study: NextGen POS.

Case Study: Monopoly.

24. Iteration 2-More Patterns.

From Iteration 1 to 2.

Iteration-2 Requirements and Emphasis: Object Design and Patterns.

25. GRASP: More Objects with Responsibilities.

Polymorphism.

Pure Fabrication.

Indirection.

Protected Variations.

26. Applying GoF Design Patterns.

Adapter (GoF).

Some GRASP Principles as a Generalization of Other Patterns.

"Analysis" Discoveries During Design: Domain Model.

Factory.

Singleton (GoF).

Conclusion of the External Services with Varying Interfaces Problem.

Strategy (GoF).

Composite (GoF) and Other Design Principles.

Facade (GoF).

Observer/Publish-Subscribe/Delegation Event Model (GoF).

Conclusion.

Recommended Resources.

V. ELABORATION ITERATION 3-INTERMEDIATE TOPICS.

27. Iteration 3-Intermediate Topics.

NextGen POS.

Monopoly.

28. UML Activity Diagrams and Modeling.

Example.

How to Apply Activity Diagrams?

More UML Activity Diagram Notation.

Guidelines.

Example: NextGen Activity Diagram.

Process: Activity Diagrams in the UP.

Background.

29. UML State Machine Diagrams and Modeling.

Example.

Definitions: Events, States, and Transitions.

How to Apply State Machine Diagrams?

More UML State Machine Diagram Notation.

Example: UI Navigation Modeling with State Machines.

Example: NextGen Use Case State Machine Diagram.

Process: State Machine Diagrams in the UP.

Recommended Resources.

30. Relating Use Cases.

The include Relationship.

Terminology: Concrete, Abstract, Base, and Addition Use Cases.

The extend Relationship.

The generalize Relationship.

Use Case Diagrams.

31. More SSDs and Contracts.

NextGen POS.

32. Domain Model Refinement.

New Concepts for the NextGen Domain Model.

Generalization.

Defining Conceptual Superclasses and Subclasses.

When to Define a Conceptual Subclass?

When to Define a Conceptual Superclass?

NextGen POS Conceptual Class Hierarchies.

Abstract Conceptual Classes.

Modeling Changing States.

Class Hierarchies and Inheritance in Software.

Association Classes.

Aggregation and Composition.

Time Intervals and Product Prices-Fixing an Iteration 1 "Error".

Association Role Names.

Roles as Concepts versus Roles in Associations.

Derived Elements.

Qualified Associations.

Reflexive Associations.

Using Packages to Organize the Domain Model.

Example: Monopoly Domain Model Refinements.

33. Architectural Analysis.

Process: When Do We Start Architectural Analysis?

Definition: Variation and Evolution Points.

Architectural Analysis.

Common Steps in Architectural Analysis.

The Science: Identification and Analysis of Architectural Factors.

Example: Partial NextGen POS Architectural Factor Table.

The Art: Resolution of Architectural Factors.

Summary of Themes in Architectural Analysis.

Process: Iterative Architecture in the UP.

Recommended Resources.

34. Logical Architecture Refinement.

Example: NextGen Logical Architecture.

Collaborations with the Layers Pattern.

Other Layer Pattern Issues.

Model-View Separation and "Upward" Communication.

Recommended Resources.

35. More Object Design with GoF Patterns.

Example: NextGen POS.

Failover to Local Services; Performance with Local Caching.

Handling Failure.

Failover to Local Services with a Proxy (GoF).

Designing for Non-Functional or Quality Requirements.

Accessing External Physical Devices with Adapters.

Abstract Factory (GoF) for Families of Related Objects.

Handling Payments with Polymorphism and Do It Myself.

Example: Monopoly.

Conclusion.

36. Package Design.

Package Organization Guidelines.

Recommended Resources.

37. UML Deployment and Component Diagrams.

Deployment Diagrams.

Component Diagrams.

38. Designing a Persistence Framework with Patterns.

The Problem: Persistent Objects.

The Solution: A Persistence Service from a Persistence Framework.

Frameworks.

Requirements for the Persistence Service and Framework.

Key Ideas.

Pattern: Representing Objects as Tables.

UML Data Modeling Profile.

Pattern: Object Identifier.

Accessing a Persistence Service with a Façade.

Mapping Objects: Database Mapper or Database Broker Pattern.

Framework Design with the Template Method Pattern.

Materialization with the Template Method Pattern.

Configuring Mappers with a MapperFactory.

Pattern: Cache Management.

Consolidating and Hiding SQL Statements in One Class.

Transactional States and the State Pattern.

Designing a Transaction with the Command Pattern.

Lazy Materialization with a Virtual Proxy.

How to Represent Relationships in Tables.

PersistentObject Superclass and Separation of Concerns.

Unresolved Issues.

39. Documenting Architecture: UML & the N+1 View Model.

The SAD and Its Architectural Views.

Notation: The Structure of a SAD.

Example: A NextGen POS SAD.

Example: A Jakarta Struts SAD.

Process: Iterative Architectural Documentation.

Recommended Resources.

VI. SPECIAL TOPICS

40. More on Iterative Development and Agile Project Management.

How to Plan an Iteration?

Adaptive versus Predictive Planning.

Phase and Iteration Plans.

How to Plan Iterations with Use Cases and Scenarios?

The (In)Validity of Early Estimates.

Organizing Project Artifacts.

You Know You Didn't Understand Iterative Planning When...

Recommended Resources.

Bibliography.

Glossary.

Index.

Read More Show Less

Preface

Thank you for reading this book! If I can answer a question, or for consulting or coaching a team (in OOA/D, UML, modeling, iterative and agile methods), please contact me at www.craiglarman.com.

This is a practical introduction to object-oriented analysis and design (OOA/D), and to related aspects of iterative development. I am grateful that the previous editions were extremely popular worldwide. I sincerely thank all the readers!

Here is how the book will benefit you.

Design Well—First, the use of object technology is widespread, so mastery of OOA/D is critical for you to succeed in the software world.

Learn a Process Roadmap—Second, if you are new to OOA/D, you’re understandably challenged about how to proceed; this book presents a well-defined iterative roadmap—an agile approach to the Unified Process—so that you can move in a step-by-step process from requirements to code.

Learn UML for Modeling—Third, the Unified Modeling Language (UML) has emerged as the standard notation for modeling, so it’s useful to be able to apply it skillfully.

Learn Design Patterns—Fourth, design patterns communicate the “best practice” idioms OO design experts apply. You will learn to apply design patterns, including the popular “Gang-of-Four” patterns, and the GRASP patterns. Learning and applying patterns will accelerate your mastery of analysis and design.

Learn from Experience—Fifth, the structure and emphasis in this book are based on years of experience in education and mentoring thousands of people in the art of OOA/D. 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 Study—Sixth, it exhaustively examines two case studies—to realistically illustrate the entire OOA/D process, and goes deeply into thorny details of the problem.

Design to Code, with TDD & Refactoring—Seventh, it shows how to map object design artifacts to code in Java. It also introduces test-driven development and refactor.

Layered Architecture—Eighth, it explains how to design a layered architecture and relate the UI layer to domain and technical services layers.

Design Frameworks—Finally, it shows you how to design an OO framework and applies this to the creation of a framework for persistent storage in a database.

Educator and Web Resources

You may find related articles of interest at www.craiglarman.com.

Hundreds, if not thousands, of teachers use the book worldwide; it’s been translated into at least ten languages. At my website there are a variety of educator resources, including all the book figures organized into Microsoft PowerPoint presentations, sample OOA/D PowerPoint presentations, and more. If you’re an educator, please contact me for resources.

I am collecting material from existing educators using the book, to share with other educators. If you have anything to share, please contact me.

Intended Audience—an Introduction!

This book is an introduction to OOA/D, related requirements analysis, and to iterative development with the Unified Process as a sample process; it is not meant as an advanced text. It is for the following audience:

  • Developers and students with some experience in OO programming, but who are new—or relatively new—to OOA/D.
  • Students in computer science or software engineering courses studying object technology.
  • Those with some familiarity in OOA/D who want to learn the UML notation, apply patterns, or who want to deepen their analysis and design skills.

Prerequisites

Some prerequisites are assumed—and necessary—to benefit from this book:

  • Knowledge and experience in an object-oriented programming language such as Java, C#, C++, or Python.
  • Knowledge of fundamental OO concepts, such as class, instance, interface, polymorphism, encapsulation, and inheritance.

Fundamental OO concepts are not defined.

Java Examples, But...

In general, the book presents code examples in Java due to its widespread familiarity. However, the ideas presented are applicable to most—if not all—object-oriented technologies, including C#, Python, and so on.

Book Organization

The overall strategy in the organization of this book is that analysis and design topics are introduced in an order similar to that of a software development project running across an “inception” phase (a Unified Process term) followed by three.

  1. The inception phase chapters introduce the basics of requirements analysis.
  2. Iteration 1 introduces fundamental OOA/D and how to assign responsibilities to objects.
  3. Iteration 2 focuses on object design, especially on introducing some high-use “design patterns.”
  4. Iteration 3 introduces a variety of subjects, such as architectural analysis and framework design.
Read More Show Less

Introduction

Thank you for reading this book! This is a practical introduction to object-oriented analysis and design (OOA/D), and to related aspects of iterative development. I am grateful that the previous editions were received as a popular introduction to OOA/D throughout the world, translated into many languages. Therefore, this new edition builds upon and refines—rather than replaces—the content in the previous. I want to sincerely thank all the readers of the prior editions.

Here is how the book will benefit you.

Design robust and maintainable object systems. The use of object technology has proliferated in the development of software, and mastery of OOA/D is critical for you to create robust and maintainable object systems.

Follow a roadmap through requirements, analysis, design, and coding. If you are new to OOA/D, you are understandably challenged about how to proceed through this complex subject; this book presents a well-defined iterative roadmap—an agile approach to the Unified Process—so that you can move in a step-by-step process from requirements to code.

Use the UML to illustrate analysis and design models. 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 OOA/D using the UML notation.

Improve designs by applying the "gang-of-four" and GRASP design patterns. 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 designpatterns, including the popular "gang-of-four" patterns, and the GRASP patterns which communicate fundamental principles of responsibility assignment in object design. Learning and applying patterns will accelerate your mastery of analysis and design.

Learn efficiently by following a refined presentation. The structure and emphasis in this book are based on years of experience in training and mentoring thousands of people in the art of OOA/D. 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. It exhaustively examines a single case study—to realistically illustrate the entire OOA/D process, and goes deeply into thorny details of the problem; it is a realistic exercise.

Translate to code. It shows how to map object design artifacts to code in Java.

Design a layered architecture. It explains how to design a layered architecture and relate the graphical user interface layer to domain and technical services layers.

Design a framework. It shows you how to design an object-oriented framework and 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 object 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 an introduction to OOA/D, related requirements analysis, and to iterative development with the Unified Process as a sample process; it is not meant as an advanced text. It is for the following audience:

  • Developers and students 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 OOA/D who want to learn the UML 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 Java, C#, C++, or Smalltalk.
  • Knowledge of fundamental object technology concepts, such as class, instance, interface, polymorphism, encapsulation, interfaces, and inheritance.

Fundamental object technology concepts are not defined.

Java Examples

In general, the book presents code examples in Java or discusses Java implementations, due to its widespread familiarity. However, the ideas presented are applicable to most—if not all—object-oriented programming languages.

Book Organization

The overall strategy in the organization of this book is that analysis and design topics are introduced in an order similar to that of a software development project running across an "inception" phase (a Unified Process term) followed by three iterations.

  1. The inception phase chapters introduce the basics of requirements analysis.
  2. Iteration 1 introduces fundamental OOA/D and how to assign responsibilities to objects.
  3. Iteration 2 focuses on object design, especially on introducing some high-use "design patterns."
  4. Iteration 3 introduces a variety of subjects, such as architectural analysis and framework design.
Read More Show Less

Customer Reviews

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

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com 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 & Noble.com 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 & Noble.com 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 BN.com 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

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com 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 BN.com. 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)