did-you-know? rent-now

Amazon no longer offers textbook rentals. We do!

did-you-know? rent-now

Amazon no longer offers textbook rentals. We do!

We're the #1 textbook rental company. Let us show you why.

9780201711615

The Art of Objects Object-Oriented Design and Architecture

by
  • ISBN13:

    9780201711615

  • ISBN10:

    0201711613

  • Edition: 1st
  • Format: Paperback
  • Copyright: 2000-10-16
  • Publisher: Addison-Wesley Professional
  • Purchase Benefits
  • Free Shipping Icon Free Shipping On Orders Over $35!
    Your order must be $35 or more to qualify for free economy shipping. Bulk sales, PO's, Marketplace items, eBooks and apparel do not qualify for this offer.
  • eCampus.com Logo Get Rewarded for Ordering Your Textbooks! Enroll Now
List Price: $43.99

Summary

Object-oriented programming relies on programming languages. However, the concepts of objects transcend any specific programming languages. Many design patterns offer efficient modeling of static and dynamic object relationships. They can be used as the building blocks for sophisticated software systems. Similarly, at a system level, object-oriented architecture provides a lucid, high-level description of interconnected objects.

Tools may change. Programming languages may go out of favor. Yet the foundation of object design and architecture, and the art of applying it, will remain sound for a long time.

This book systematically presents the basic concepts of objects and practical object design patterns (both static and dynamic). It helps readers to gain a deep understanding of the patterns, allowing them to find design solutions quickly. In addition, the topics are forward looking, encompassing persistent objects, distributed objects, interface design patterns, XML (eXtensible Markup Language) object models, Web applications with thin clients, and so forth. Going beyond the design level, the book discusses object-oriented architecture, covering clients/servers, multi-tier systems, federations, agents, and others.

The Unified Modeling Language (UML), especially its graphic notation, is used as the primary means of presentation. The contents are independent of specific programming languages, making the book a general-purpose reference. However, many exercises do relate to certain languages (mostly Java). They help bring the readers closer to implementation and foster a concrete understanding of the underlying concepts. In addition, a wide range of real-world case studies and examples help elucidate these concepts and their practical application.

I did not use UML to specify all the details of an object design. For example, the UML Object Constraint Language is not used. In my opinion, source code with adequate inline comments is the best place to document the detailed logic of object behaviors.

This book can be used as a textbook for university or industrial training courses, or as a reference book for courses on object-oriented programming languages. This book is also suitable as a reference for mid- to advanced-level software professionals and graduate students. Many exercises are derived from actual projects. They expose readers to the full complexity of real-world systems.

Organization of the Book
This book has nine chapters, including several integrated case studies throughout the book. Chapter 1 describes the basic concepts in object-oriented programming, which include object, class, association, aggregation, servant class, and inheritance. It also introduces some basic notations of UML.

Chapter 2 discusses the common patterns in static design. The focus here is on the static relationships between classes. The dynamic or time-dependent behaviors are left to later chapters. I systematically present simple and complex patterns. They allow object designers to design with patterns rather than with individual classes.

I note that the distinction between analysis and design is vague. Analysis is more on understanding the concepts in an application domain and investigating the requirements. Design is more on finding a solution and verifying that the solution fits the requirements. With a concrete understanding of the object concepts and the relationships behind the static patterns, one would naturally apply object analyses and designs in an iterative fashion. The ultimate criterion for an appropriate object design is its fitness to the requirements.

In Chapter 3 I first present the basic concepts on database management and persistent objects. I then discuss different strategies to make objects persistent, particularly those involving object-oriented databases and relational databases. I also examine object-relational mapping in detail and give a comparison between the two types of databases.

Chapter 4 introduces some advanced topics in object modeling. They include abstract classes, multiple inheritance, interfaces, inner classes, collections, packages, and components. These are extensions to the basic object concepts. I also discuss the reverse engineering of object designs and the identification of irreducible patterns, which is presented in Chapter 2.

Chapter 5 describes modeling the dynamic behavior of objects. I discuss use case analyses and object sequence diagrams. I also introduce the important concepts of client/server and distributed objects. For distributed objects, I cover interface definition, and the Common Object Request Broker Architecture (CORBA) standard and its operational mechanisms.

Then in Chapter 6 I present various interface design patterns. These patterns are intimately related to the dynamic behaviors of their constituent objects. Such behaviors are documented with sequence diagrams. I also discuss interface patterns related to CORBA objects.

In Chapter 7 I elevate the discussion to the system level. I describe various object-oriented architectures, including procedural processing systems, client/server systems, layered systems, multi-tier systems, agents, and aggregations and federations. Note that the distinction between architecture and design is not absolute. In architecture we are more concerned with the coordination between components, overall system performance, and scaling properties. In design we focus on the details within a component, an interface, or a subsystem.

Chapter 8 gives summaries and notes for the preceding chapters, whereas Chapter 9 provides answers to all exercises.

The integrated case studies serve as real-life examples to illustrate the

practical applications of the concepts. They appear at the ends of various chapters, culminating in Chapter 7 with a discussion of their system architectures. Readers are highly recommended to work through them in some detail. A concrete understanding of the basic concepts can only be built through hands-on design and implementation.

Sections with an asterisk after their titles may be skipped during the first reading. They are topics with somewhat narrower interests. Readers who are primarily interested in software system architecture may proceed directly to Chapter 7, which can be read as a survey of different architectural patterns.

Finally, the appendices provide various reference information. In particular, Appendix A summarizes UML notations, followed by a quick look-up table to all object designs appearing in the main text and exercises. Appendix B provides a list of code samples for each chapter. Appendix C lists the features of various object-oriented languages.

Online Resources
Fully functional code samples are available from http://www.awl.com/cseng/titles/0-201-71161-3/. The code samples have more than 40,000 source lines and are all written in Java. They cover nearly all examples described in the main text and most case studies. Appendix B lists the sample code for the chapters. Studying the code will help solidify the reader's understanding of the designs. Readers are encouraged to extend and enrich the sample code. Furthermore, students in courses on object-oriented programming languages may implement the designs appearing in the chapter exercises as additional exercises.

0201711613P04062001

Author Biography

Dr. Yun-Tung Lau is a chief engineer at Science Application International Corporation (SAIC), and he has been involved in large-scale software architecture, design, and development for more than twelve years. Dr. Lau has served as chief architect for a wide range of software projects, including scientific computing and engineering simulation, supply chain management, product data management, and electronic commerce.

0201711613AB04062001

Table of Contents

Preface xiii
Organization of the Book ix
Online Resources x
Acknowledgments xi
Basic Concepts
1(20)
The Nature of Objects
1(2)
Unified Modeling Language
3(1)
UML Notation Basics
4(2)
Object Creation and Destruction
6(1)
Associations and Links
7(6)
Binary Associations and Links
8(1)
Ordering and Sorting
9(1)
Navigation and Referential Integrity
10(1)
Ternary and Higher Order Associations
11(2)
Aggregation and Composition
13(1)
Servant Classes and Delegation
14(1)
Inheritance
15(4)
Inherited versus Servant Classes
16(1)
Polymorphism and Object Substitution
17(2)
Exercies
19(2)
Common Patterns in Static Design
21(48)
Collection Managers
21(2)
Containers
23(1)
Self-Containing Classes, Hierarchies, and Networks
24(2)
Relationship Loops
26(7)
Relationship Fission
30(1)
Inheritance of Relationship Loops
31(1)
Double Loops
32(1)
Three-Tier Relationship Loops
32(1)
Binary Association Classes
33(6)
Implementing Binary Association Classes
36(2)
Recursive Association Class
38(1)
The Handle-Body Pattern
39(1)
Dynamic Schema
40(1)
Shared Object Pools
41(2)
Object Model for Extensible Markup Language
43(6)
XML Basics
44(2)
XML Object Models
46(2)
The Strengths and Weaknesses of XML
48(1)
Case Study: ATM System Software---Part 1
49(4)
Project Description
49(1)
State Analysis and Design
50(3)
Case Study: Shared Whiteboard---Part 1
53(8)
Case Study: Access Control Lists---Part 1
61(2)
Exercises
63(6)
Persistent Objects
69(56)
Transactions and Database Management Systems
70(1)
Object-Oriented Databases
71(5)
Database Roots and Extents
72(2)
Persistence-Enabled Objects
74(1)
Destruction of Persistent Objects
75(1)
Schema Evolution
76(1)
Relational Databases
76(1)
Mapping Persistent Objects to Tables
77(14)
Classes and Binary Associations
78(2)
Aggregation, Composition, and Servant Classes
80(1)
Ternary and Higher Order Associations
81(1)
Reducing Ternary Associations to Binary Ones
82(3)
Degenerate Ternary Associations
85(3)
Inheritance
88(2)
Mapping Rules Summary
90(1)
A Critical Comparison Between Relational and Object-Oriented Databases
91(6)
Optimization of Relational Tables
93(2)
Optimization of Persistent Objects
95(2)
Case Study: ATM System Software---Part 2
97(1)
Case Study: Shared Whiteboard---Part 2
97(1)
Case Study: A Rental Business---Part 1
98(12)
Initial Analysis and Design
98(3)
Full Object Design for Multiple Stores
101(1)
Detailed Object Designs
101(9)
Case Study: Access Control Lists---Part 2
110(6)
Exercises
116(9)
Advanced Topics in Object Modeling
125(14)
Abstract Classes
125(1)
Multiple Inheritance
126(2)
Interfaces
128(1)
Inner Classes
129(1)
Collections
130(1)
Packages
131(1)
Components
132(1)
Nodes
133(1)
UML Notation Basics for Dynamic Modeling
134(1)
Reverse Engineering and Irreducible Patterns
135(2)
Exercises
137(2)
Dynamic Object Modeling Basics
139(30)
Use Case Analyses
139(2)
Sequence Diagrams
141(3)
The Client/Server Model and Distributed Objects
144(2)
Interface Definition and Client/Server Development
146(2)
The CORBA Standard
148(2)
Interface Definition Language
150(4)
Statechart Diagrams
154(2)
Case Study: ATM System Software---Part 3
156(3)
Case Study: Shared Whiteboard---Part 3
159(3)
Case Study: A Rental Business---Part 2
162(3)
Case Study: Access Control Lists---Part 3
165(1)
Exercises
166(3)
Common Interface Design Patterns
169(38)
Object Wrappers
169(2)
Object Adapters
171(1)
Object Factories and Managers
172(1)
Interfaces as Servant Classes
173(2)
Servant Interfaces in Event Processing
175(7)
Single Event Pushing and Observers
176(1)
Callbacks from Server Objects
177(1)
Subscription and Notification
177(3)
Model-View-Controller
180(2)
Relationship Loops with Interfaces
182(1)
Inheritance Ladders
183(1)
CORBA Objects
183(5)
CORBA Client Stubs
188(1)
Tactics in Designing Distributed Objects
189(2)
Proxy and Surrogate Objects
191(1)
Case Study: ATM System Software---Part 4
192(5)
Case Study: Shared Whiteboard---Part 4
197(6)
Message Port---An Infrastructure for a Collaboration Group
197(4)
Sequence Diagrams for MessagePort
201(2)
Case Study: Access Control Lists---Part 4
203(1)
Exercises
204(3)
Object-Oriented Architecture
207(52)
Notations for Architecture Diagrams
208(1)
Procedural Processing Systems
209(2)
Client/Server Systems
211(6)
``Thin Clients'' and Object IDs
213(2)
Web Applications Using the MVC Framework
215(2)
Layered Systems
217(4)
Layering with Servant Objects
219(2)
Three-Tier and Multi-Tier Systems
221(5)
Clustering and Serializing
223(3)
Agents
226(2)
Aggregations and Federations
228(2)
Architectural Patterns in UML
230(3)
Case Study: ATM System Software---Part 5
233(3)
Case Study: Shared Whiteboard---Part 5
236(11)
The Shared Whiteboard Aggregation
236(1)
Image Exchange Formats and Policies
237(3)
The Interface and Control Layers
240(4)
Synchronization and Related Issues
244(2)
Trace Table for Requirements
246(1)
Case Study: A Rental Business---Part 3
247(2)
Case Study: The Enterprise JavaBeans Framework
249(9)
Static Structures
249(4)
Resource Management Strategies
253(1)
Dynamic Behaviors of Entity Beans
254(4)
Exercises
258(1)
Summaries and Notes
259(10)
Summary and Notes
259(1)
Summary and Notes
260(1)
Summary and Notes
261(1)
Summary and Notes
262(1)
Summary and Notes
263(1)
Notes on CORBA-COM Interoperability
264(1)
Summary and Notes
264(1)
Summary and Notes
265(1)
Case Studies Summary
266(3)
Answers to Exercises
269(72)
Exercise Answers
269(5)
Exercise Answers
274(20)
Exercise Answers
294(16)
Exercise Answers
310(3)
Exercise Answers
313(5)
Exercise Answers
318(10)
Exercise Answers
328(13)
Appendix A Quick References for Object Designers 341(6)
Appendix B Sample Code Reference List 347(4)
Appendix C Features of Object-Oriented Languages 351(2)
References 353(4)
Index 357

Supplemental Materials

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

Excerpts

Object-oriented programming relies on programming languages. However, the concepts of objects transcend any specific programming languages. Many design patterns offer efficient modeling of static and dynamic object relationships. They can be used as the building blocks for sophisticated software systems. Similarly, at a system level, object-oriented architecture provides a lucid, high-level description of interconnected objects.Tools may change. Programming languages may go out of favor. Yet the foundation of object design and architecture, and the art of applying it, will remain sound for a long time.This book systematically presents the basic concepts of objects and practical object design patterns (both static and dynamic). It helps readers to gain a deep understanding of the patterns, allowing them to find design solutions quickly. In addition, the topics are forward looking, encompassing persistent objects, distributed objects, interface design patterns, XML (eXtensible Markup Language) object models, Web applications with thin clients, and so forth. Going beyond the design level, the book discusses object-oriented architecture, covering clients/servers, multi-tier systems, federations, agents, and others.The Unified Modeling Language (UML), especially its graphic notation, is used as the primary means of presentation. The contents are independent of specific programming languages, making the book a general-purpose reference. However, many exercises do relate to certain languages (mostly Java). They help bring the readers closer to implementation and foster a concrete understanding of the underlying concepts. In addition, a wide range of real-world case studies and examples help elucidate these concepts and their practical application.I did not use UML to specify all the details of an object design. For example, the UML Object Constraint Language is not used. In my opinion, source code with adequate inline comments is the best place to document the detailed logic of object behaviors.This book can be used as a textbook for university or industrial training courses, or as a reference book for courses on object-oriented programming languages. This book is also suitable as a reference for mid- to advanced-level software professionals and graduate students. Many exercises are derived from actual projects. They expose readers to the full complexity of real-world systems. Organization of the Book This book has nine chapters, including several integrated case studies throughout the book. Chapter 1 describes the basic concepts in object-oriented programming, which include object, class, association, aggregation, servant class, and inheritance. It also introduces some basic notations of UML.Chapter 2 discusses the common patterns in static design. The focus here is on the static relationships between classes. The dynamic or time-dependent behaviors are left to later chapters. I systematically present simple and complex patterns. They allow object designers to design with patterns rather than with individual classes.I note that the distinction between analysis and design is vague. Analysis is more on understanding the concepts in an application domain and investigating the requirements. Design is more on finding a solution and verifying that the solution fits the requirements. With a concrete understanding of the object concepts and the relationships behind the static patterns, one would naturally apply object analyses and designs in an iterative fashion. The ultimate criterion for an appropriate object design is its fitness to the requirements.In Chapter 3 I first present the basic concepts on database management and persistent objects. I then discuss different strategies to make objects persistent, particularly those involving object-oriented databases and relational databases. I also examine object-relational ma

Rewards Program