Practical Object-Oriented Development With Uml and Java

by Lee, Richard C.; Tepfenhart, William M.

• ISBN13: 9780130672384
• ISBN10: 0130672386
• Edition: 1st
• Format: Paperback
• Copyright: 2002-05-15
• Publisher: Prentice Hall

Summary

This practical book tells readers how to actually build object-oriented models using UML notation, and how to implement these models using Java. The authors introduce all of the basic fundamentals necessary to start applying and understanding the object-oriented paradigm without having to be an expert in computer science or advanced mathematics. It can help the reader to make the right decisions to meet their individual business needs.Using cases, recommended approach scenarios, and examples, this clearly-written book covers a multitude of topics: managing complexity, principles of Object-Orientation, specification models, current techniques, behaviors, relationships, rules, design, Java background and fundamentals, multi-tasking, JAR files, security, Swing Applets, class and interface, internationalization, and implementing generalization and specialization.For professional software analysts and developers who work on large systems, and others in the field of computer science.

Author Biography

Richard C. Lee has more than 35 years experience developing and managing software projects. He has worked and/or managed leading-edge development in electronic publishing, embedded systems, large IMS projects, multi-media, operating support systems; process control, transaction processing, and switching. Being one of the earlier adopters of object-oriented technology, his current interest is making more object-oriented projects successful.

William M. Tepfenhart is currently Program Director for the Software Engineering Department at Monmouth University. He has eighteen years of experience developing manufacturing, military, and telecommunications applications as a programmer, developer, and technologist. He has developed object-oriented systems over the past 17 years.

Table of Contents

Preface	xvii
Object-Oriented Technology	xvii
Why Unified Modeling Language?	xviii
Why Java?	xix
Our Approach to Object-Oriented Technology	xx
Organization of the Book	xxi
Using this Book	xxii
Acknowledgments	xxv
Managing Complexity with Abstraction	1	(23)
Complex Systems	3	(3)
System Development Is Modeling	4	(1)
A Strategy for Modeling	5	(1)
Abstraction Mechanisms	6	(7)
Basic Data Types	7	(1)
Functions	7	(1)
Modules	8	(1)
Abstract Data Types	9	(1)
Objects	9	(1)
Class	10	(1)
Generalization/Specialization	10	(1)
Polymorphism	11	(1)
Interface	11	(1)
Reflection	12	(1)
Service Activation Abstractions	13	(1)
Function Call	13	(1)
Event Processing (Asynchronous Communication)	13	(1)
Message Passing (Synchronous Communication)	13	(1)
Subscription (Asynchronous Communication)	14	(1)
Processing Control Abstractions	14	(2)
Single Program Execution	15	(1)
Multitasking	15	(1)
Sequential Execution	15	(1)
Multithreading	16	(1)
Relationships	16	(5)
Associations	16	(2)
Aggregation	18	(1)
Behavior	19	(1)
Static Behavior	20	(1)
Dynamic Behavior	20	(1)
Rules	21	(3)
The Object-Oriented Paradigm	24	(22)
The Object-Oriented Paradigm	24	(4)
What Is and Object?	25	(2)
What Is a Class?	27	(1)
Principles of Object-Orientation	28	(7)
Principle 1. Encapsulation	28	(1)
Principle 2. Information Hiding	29	(1)
Principle 3. Message Passing	29	(1)
Principle 4. Late Binding	30	(2)
Principle 5. Delegation	32	(1)
Principle 6. Class/Instance/Object	32	(1)
Principle 7. Generalization/Specialization without Polymorphism	33	(1)
Principle 8. Generalization/Specialization with Polymorphism	33	(1)
Principle 9. Relationships	34	(1)
Principle 10. Interface/Instance/Object	34	(1)
Principle 11. Generalization/Specialization of Interfaces	34	(1)
Principle 12. Reflection	35	(1)
Principle 13. Multithreading	35	(1)
Object-Oriented Model of Computation	35	(11)
Building a Specification Model	46	(33)
Introduction to Use Cases	47	(10)
System	48	(1)
Actors	49	(1)
Use Cases	49	(6)
Use-Case Bundles	55	(2)
Documenting Use Cases	57	(3)
Use-Case Diagram	57	(1)
Sequence Diagram: Documenting the Details	58	(1)
Textual Description	59	(1)
Guidelines for Developing Use Cases	60	(8)
Avoiding Analysis Paralysis	60	(1)
Indentifying Actors	61	(2)
Identifying High-Level and Essential Use Cases	63	(2)
Establishing Use-Case Bundles	65	(1)
Developing Use-Case Details	65	(2)
Identifying Supporting Use Cases	67	(1)
Contracts	68	(2)
Recommended Approach	70	(9)
Finding the Objects	79	(22)
Object-Oriented Analysis: Model of an Application Domain	80	(1)
Building the Objected-Oriented Model	80	(2)
Identification of Objects, Classes, and Interfaces	82	(2)
Current Techniques	84	(5)
Using the Things to Be Modeled	84	(1)
Using the Definitions of Objects, Categories, and Types	84	(1)
Using Object Decomposition	84	(1)
Using Generalization	85	(1)
Using Subclasses	85	(1)
Using Object-Oriented Domain Analysis	86	(1)
Reusing an Application Framework	86	(1)
Reusing Class Hierarchies	87	(1)
Reusing Individual Objects and Classes	88	(1)
Using Subassemblies	88	(1)
Using Personal Experience	89	(1)
Traditional Techniques	89	(5)
Using Nouns	89	(1)
Using Traditional Data Flow Diagrams	90	(2)
Using Class-Responsibility-Collaboration (CRC) Cards	92	(2)
Recommended Approaches	94	(7)
Identifying Responsibilities	101	(14)
What Is an Object?	101	(1)
What Is an Attribute?	102	(2)
Descriptive Attributes	103	(1)
Naming Attributes	103	(1)
What Is a Service?	104	(1)
What Is a Method?	104	(1)
Identifying Attributes	104	(2)
Specifying Attributes	106	(2)
Identifying Services	108	(1)
Specifying Services	109	(1)
Recommended Approach	109	(6)
Specifying Static Behavior	115	(16)
What Is Behavior?	115	(2)
Java Services (Operations) That Affect the Behavior Specification	117	(1)
Techniques for Specifying Static Behavior	118	(2)
Techniques for Specifying Control	120	(1)
Techniques for Documenting Control	121	(3)
Activity Diagrams	121	(1)
Collaboration Diagram	122	(1)
Sequence Diagram	123	(1)
Techniques for Documenting Static Behavior	124	(1)
Pre-conditions and Post-conditions	124	(1)
Flowcharting	124	(1)
Data Flow Diagrams	125	(1)
Structured English	125	(1)
Recommended Approach	125	(6)
Dynamic Behavior	131	(24)
Introduction	132	(1)
Techniques for Identifying Dynamic Behavior	133	(4)
Common Lifecycle Forms	134	(1)
Models for Capturing Lifecycle	135	(2)
Identifying and Specifying Events	137	(5)
Use Case and Scenario	137	(1)
Sequence Diagram	137	(5)
Specifying Dynamic Behavior	142	(6)
Event List	142	(2)
State Transition Table	144	(4)
Documenting Dynamic Behavior	148	(4)
State Diagrams	148	(4)
Recommended Approach	152	(3)
Identifying Relationships	155	(23)
Accessing Another Object's Services	155	(1)
Relationships	156	(1)
Generalization	157	(3)
Identifying and Specifying Generalization/Specialization	160	(1)
Object Aggregation	161	(1)
Classification of Aggregation	162	(6)
Assembly-Parts (Component-Integral) Composition	163	(1)
Material-Object Composition	164	(1)
Portion-Object Composition	165	(1)
Place-Area Composition	166	(1)
Collection-Members Composition	166	(1)
Container Content (Member-Bunch) Composition	167	(1)
Member-Partnership Composition	167	(1)
Objects and Aggregation Relationships	168	(1)
Links Between Objects	168	(2)
Identifying and Specifying Links and Aggregations	170	(1)
Managing Relationships	171	(2)
Documenting Relationships	173	(2)
Recommended Approach	175	(3)
Rules	178	(9)
Introduction	178	(2)
Rules	180	(1)
Identifying Declarative Statements	180	(1)
Specifying and Documenting Rules	181	(2)
Mapping Rules to the Proper Object-Oriented Concepts	183	(1)
Documenting the Rules Using UML	184	(1)
Implementing Rules	184	(1)
Recommended Approach	185	(2)
The Model	187	(23)
Concepts	187	(2)
Concepts and Object-Oriented Model	189	(4)
Class	189	(1)
Interface	189	(1)
Association	190	(1)
Class Aggregation	190	(1)
Generalization/Specialization of Classes	191	(1)
Polymorphism	192	(1)
Instantiation	192	(1)
Documenting Concepts Using UML	193	(5)
Class Concept	193	(1)
Basic Class Construct	193	(1)
Parameterized Class and Bounded Class Construct	194	(1)
Interface Construct	194	(1)
Association	194	(2)
Class Aggregation	196	(1)
Generalization/Specialization of Class	196	(1)
Generalization/Specialization of Interface	197	(1)
Polymorphism	197	(1)
Instantiation	197	(1)
Refining the Model	197	(1)
Subsystems	198	(2)
Domain	198	(1)
Bridge	199	(1)
Organizing Subsystems	200	(1)
Horizontal Layers	200	(1)
Vertical Partitions	201	(1)
Combination	201	(1)
Identifying Subsystems	201	(1)
Documenting Subsystem	201	(1)
Recommended Approach	202	(8)
Subsystems	205	(5)
Design	210	(17)
Introduction	211	(1)
System Design	211	(6)
Subsystems	211	(1)
Architectural Frameworks	212	(2)
Software Control Within a Framework	214	(1)
Documenting System Design	215	(2)
Detailed Design	217	(10)
Class Design	217	(2)
Association Design	219	(1)
Generalization and Inheritance	220	(1)
Delegation	221	(2)
Orlando Treaty	223	(1)
Multiple Inheritance	223	(2)
Documenting Detailed Design	225	(2)
Java Fundamentals	227	(46)
Introduction to the Java Language	227	(2)
Example Statements	227	(1)
Unicode Character	228	(1)
Programming Elements	229	(10)
Comments	230	(1)
Reserved Words (Keywords)	231	(1)
Identifiers	232	(1)
Literals	232	(1)
Operators	233	(1)
Arithmetic Operators	234	(1)
Boolean Operators	235	(1)
Conditional and Relational Operators	235	(2)
Bitwise Operators	237	(1)
Class-Defined Operators	238	(1)
Punctuators	238	(1)
Primitive Data Types	239	(4)
Primitive Data Types	239	(1)
Constant Values	240	(1)
Symbolic Variables	241	(1)
Reference Variables	242	(1)
Constants	242	(1)
Class ``Data Type''	242	(1)
What Is a Statement?	243	(4)
Expressions	244	(1)
Null Statement	245	(1)
Assignment Statement	245	(1)
Service Request Statement	246	(1)
Block (Compound Statement)	246	(1)
Statement Flow Control	247	(4)
If Statement	247	(1)
If-Else Statement	247	(1)
For Statement	248	(1)
Switch Statement	248	(2)
While Statement	250	(1)
Do-While Statement	250	(1)
Branching Statements	251	(4)
The Break Statement	251	(2)
The Continue Statement	253	(1)
The Return Statement	254	(1)
Exception Handling	255	(4)
Throws and Try-Catch Block	255	(2)
Throwable Class	257	(2)
NameSpace	259	(6)
No Global Variables	259	(1)
Package and Imports	260	(1)
Packages of the Java API	261	(1)
Filenames and Directories	262	(1)
Access to Members of a Class	262	(1)
Public	262	(1)
Private	263	(1)
Protected	263	(1)
Package	264	(1)
Summary	264	(1)
Type Conversion	265	(2)
Casting Between Primitive Data Types	265	(1)
Casting Objects	266	(1)
Converting Primitive Data Types to Objects	267	(1)
Recommended Approach	267	(6)
Implementing Class and Interface	273	(37)
Components of a Class	273	(1)
Class Definition	274	(1)
Class Body	275	(11)
Visibility	275	(1)
Data Variables	276	(1)
Instance Data Variables	276	(1)
Class Data Variables	277	(1)
Constants	278	(1)
Initialization of Member Variables	279	(1)
Other Attributes of a Class Member	280	(1)
Member Methods	280	(3)
Class Method	283	(1)
Details of Member Method Prototype	284	(1)
Abstract Class	285	(1)
Nested, Inner, and Anonymous Inner Classes	286	(3)
Nested Classes	286	(1)
Inner Class	287	(1)
Anonymous Inner Classes	288	(1)
Predefined Java Classes	289	(15)
String Data Type	289	(1)
String Concatenation	289	(1)
Conversion of an Object to a String Instance	289	(1)
Conversion from String to Integer and Vice Versa	290	(1)
Substrings	290	(1)
Length of String	290	(1)
Individual Characters in a String	290	(1)
Immutable Property	291	(1)
StringBuffer Data Type	292	(1)
Number Data Types	293	(1)
Array Data Type	294	(1)
Declaring a Variable to Hold and Array	295	(1)
Initialization of an Array	295	(2)
Access and Assignment by Position	297	(1)
Multidimensional Array	298	(1)
Interface	298	(1)
Interface Declaration	299	(1)
Interface Body	300	(1)
Using an Interface as a Data Type	300	(1)
Implementing the Interface	300	(3)
Why Can't I Just Use an Abstract Class?	303	(1)
Do Interfaces Provide for Multiple Inheritance?	303	(1)
What Can I Use Interfaces For?	303	(1)
Recommended Approach	304	(6)
Implementing Static Behavior	310	(23)
What Is a Service?	310	(2)
Method Definition	312	(4)
Method (Service) Prototype	312	(1)
Method Implementation	313	(2)
Return Type	315	(1)
Return Statement	315	(1)
Body	316	(3)
this	316	(1)
super	317	(1)
Local Variables	318	(1)
Service Argument List	318	(1)
Passing Arguments	319	(2)
Pass-By-Value	319	(1)
Pass-By-Reference (or Pointer)	320	(1)
Identifier's Scope	321	(1)
Polymorphism	321	(2)
Overriding Methods	322	(1)
Calling the Original Method	323	(1)
Creating Objects and Destroying Objects	323	(6)
Introduction	324	(1)
Constructor Methods	324	(3)
Calling Another Constructor	327	(1)
Overloading Constructors	327	(1)
Calling Sequence of Constructors	328	(1)
Visibility of Constructor	329	(1)
Finalizer Method	329	(1)
Constructor and Finalizer Coding Guidelines	329	(1)
Recommended Approach	330	(3)
Implementing Dynamic Behavior	333	(23)
Elements of Dynamic Behavior	333	(1)
Simple State Diagrams	334	(7)
Implement the Actions Performed by the Object	334	(2)
Adding State	336	(1)
Introduce Helper Methods for Managing State Entry and Exit Actions	337	(2)
Implement the Event Handlers (Methods) for Responding to Events	339	(2)
Nested State Diagrams	341	(6)
Implement the Actions Performed by the Object	341	(1)
Adding State	342	(1)
Introduce Helper Methods for Managing State Entry and Exit Actions	343	(3)
Implement the Event Handlers (Methods) for Responding to Events	346	(1)
Concurrent State Diagrams	347	(9)
Introduction	348	(1)
Changes to the Microwave Class	349	(2)
Creating a Parallel State Machine	351	(1)
Extending Thread Class	351	(1)
Implement the Actions Performed by the Object	352	(1)
Creating States	352	(1)
Introduce Helper Methods for Managing State Entry and Exit Actions	352	(1)
Implement the Event Handlers (Methods) for Responding to Events	353	(3)
Implementing Generalization/Specialization	356	(24)
Introduction	356	(1)
Java Inheritance Hierarchy	357	(1)
Generalization/Specialization Mapping to Inheritance	357	(1)
Inheritance	357	(9)
Derived Class and Base Class	357	(1)
Specifying a Derived Class	358	(1)
Inheriting from a Derived Class and Implementing Association	359	(2)
Adding Polymorphism	361	(2)
Abstract Class	363	(1)
Abstract Service (Method)	364	(2)
Implementing Generalization/Specialization	366	(6)
Interfaces	366	(3)
Aggregation with Delegation	369	(3)
The Object Class	372	(8)
Clone Method	372	(1)
Equals and HashCode Methods	373	(1)
Finalize Method	374	(1)
ToString Method	375	(1)
GetClass Method	375	(1)
Notify, NotifyAll, and Wait Methods	376	(4)
Implementing More Relationships	380	(15)
Introduction	380	(2)
Implementing Association	381	(1)
Implementing Attributes of an Association	382	(1)
Implementing Aggregation	382	(1)
References	382	(2)
Static Members	384	(1)
Implementing Association	385	(5)
Binary Association	385	(2)
Many-to-One Association	387	(2)
Many-to-Many Association	389	(1)
Implementing Aggregation	390	(1)
Buried Reference	390	(1)
Inner Classes	391	(1)
Implementing Static Members	391	(2)
Recommended Approach	393	(2)
A Unified Modeling Language	395	(30)
Introduction	395	(3)
What Is the Unified Modeling Language?	396	(1)
What UML Is Not	396	(1)
What Are the Goals of UML?	396	(1)
Why Use UML?	396	(1)
What Are the Diagrams of UML?	397	(1)
What Are the Most Important UML Diagrams?	397	(1)
UML Diagrams	398	(23)
Use-Case Diagram	398	(2)
Class Diagram	400	(10)
Sequence Diagram	410	(2)
Collaboration Diagram	412	(2)
Statechart Diagram	414	(2)
Activity Diagram	416	(2)
Component Diagram	418	(2)
Deployment Diagram	420	(1)
UML Glossary	421	(4)
B Java Language Summary	425	(10)
Reserved Words	426	(1)
Comments	426	(1)
Literals	427	(1)
Variable Declaration	427	(1)
Variable Assignment	428	(1)
Operators	429	(1)
Loops and Conditions	430	(1)
Class and Interface Definitions	431	(1)
Objects	431	(1)
Arrays	432	(1)
Method and Constructor Definitions	432	(2)
Packages and Importing	434	(1)
Exceptions and Synchronization	434	(1)
C How the Java Language Differs from C and C++	435	(9)
C Data Types Not Supported	436	(3)
Pointers	436	(1)
Struct and Union	436	(2)
Enumerated Data Types	438	(1)
Primitive Data Types	439	(1)
Operators	439	(1)
Arguments	439	(1)
Command Line	439	(1)
Method Arguments	440	(1)
Arrays	440	(1)
Java Strings	441	(1)
Memory Management	442	(1)
Miscellaneous	443	(1)
Bibliography	444	(3)
Index	447

Excerpts

Practical Object-Oriented Development with UML and Javais for busy professional software analysts and developers who work on large systems. If you do not have time to take a class and need to get up-to-speed on object-oriented technology using unified modeling language (UML) and Java, then this book is a self-teaching guide for you. It will help you understand the differences between object-oriented analysis, object-oriented design, and object-oriented programming. Our goals are to Teach you to build an object-oriented application using Java and make the right trade-off decisions to meet your business needs Clarify the basic concepts associated with object-oriented technology Supply sufficient depth in coverage for students and practitioners entering the field to get them up-to-speed Expose some of the myths surrounding object-oriented technology while focusing on its practicality as a software engineering tool Provide a practical approach to analysis, design, and programming in object-oriented technology Show how to implement object-oriented technology using Java Balance theory with application practices in the existing literatureYou do not have to know computer science or advanced mathematics to understand the important object-oriented concepts and issues in depth. Even the programming chapters do not require a background in Java; they illustrate how working code in Java is produced. OBJECT-ORIENTED TECHNOLOGYWe are software developers of large systems. We have delivered code written in several dozen programming languages representing a half-dozen software technologies. There have been few software revolutions that we have not experienced over the last 30 years. So it is from some nontrivial perspective that we say that it is our belief that object-oriented technology is the most important software technology with which we have worked.Why do we say this? Well, object-orientation has changed the way we build software and the way applications intercommunicate over worldwide networks and across mufti-vendor computers. Moreover, the object model is changing the way we design business processes and the way we think about an enterprise.Most enterprises are in the process of redesigning themselves to meet current business challenges introduced by the Internet. Object-orientation is playing a major role in this effort by providing a model that captures the business processes, procedures, policies, and rules that facilitate design. The use of tools that translate the model into an operational system speeds implementation of the redesign. As-market or business conditions change, these systems should be regenerated to reflect these changes by updating the model and using these tools. Solid software engineering practices have taken us farther and faster than any other approach in previous decades.It is a common belief that object-oriented technology has put a dent in the software crisis, meaning that the mechanisms of object-oriented technology are becoming for software what the bolts and beams are for construction design and what the chip is for computer hardware design. This belief stems from the following: The proficiency of a higher-level object-oriented model provides the software designer with real-world, programmable components, thereby reducing software development costs. Its capability to share and reuse code with object-oriented techniques reduce time to develop an application. Its capability to localize and minimize the effects of modifications through programming abstraction mechanisms allows for faster enhancement development and provides more reliable and more robust software. Its capability to manage complexity allows developers to address more difficult applications.The collection of object-oriented concepts is a tool set for modeling reality. This object-or