Preface
Object-Oriented Technology
Why Unified Modeling Language?
Why Java?
Our Approach to Object-Oriented Technology
Organization of the Book
Using This Book
Acknowledgments
1 Managing Complexity with Abstraction
Complex Systems
System Development Is Modeling
A Strategy for Modeling
Abstraction Mechanisms
Basic Data Types
Functions
Modules
Abstract Data Types
Objects
Class
Generalization/Specialization
Polymorphism
Interface
Reflection
Service Activation Abstractions
Function Call
Event Processing (Asynchronous Communication)
Message Passing (Synchronous Communication)
Subscription (Asynchronous Communication)
Processing Control Abstractions
Single Program Execution
Multitasking
Sequential Execution
Multithreading
Relationships
Associations
Aggregation
Behavior
Static Behavior
Dynamic Behavior
Rules
2 The Object-Oriented Paradigm
The Object-Oriented Paradigm
What Is an Object?
What Is a Class?
Principles of Object-Orientation
Principle 1. Encapsulation
Principle 2. Information Hiding
Principle 3. Message Passing
Principle 4. Late Binding
Principle 5. Delegation
Principle 6. Class/Instance/Object
Principle 7. Generalization/Specialization without Polymorphism
Principle 8. Generalization/Specialization with Polymorphism
Principle 9. Relationships
Principle 10. Interface/Instance/Object
Principle 11. Generalization/Specialization of Interfaces
Principle 12. Reflection
Principle 13. Multithreading
Object-Oriented Model of Computation
3 Building a Specification Model
Introduction to Use Cases
System
Actors
Use Cases
Use-Case Bundles
Documenting Use Cases
Use-Case Diagram
Sequence Diagram: Documenting the Details
Textual Description
Guidelines for Developing Use Cases
Avoiding Analysis Paralysis
Identifying Actors
Identifying High-Level and Essential Use Cases
Establishing Use-Case Bundles
Developing Use-Case Details
Identifying Supporting Use Cases
Contracts
Recommended Approach
4 Finding the Objects
Object-Oriented Analysis: Model of an Application Domain
Building the Objected-Oriented Model
Identification of Objects, Classes, and Interfaces
Current Techniques
Using the Things to Be Modeled
Using the Definitions of Objects, Categories, and Types
Using Object Decomposition
Using Generalization
Using Subclasses
Using Object-Oriented Domain Analysis
Reusing an Application Framework
Reusing Class Hierarchies
Reusing Individual Objects and Classes
Using Subassemblies
Using Personal Experience
Traditional Techniques
Using Nouns
Using Traditional Data Flow Diagrams
Using Class-Responsibility-Collaboration (CRC) Cards
Recommended Approaches
5 Identifying Responsibilities
What Is an Object?
What Is an Attribute?
Descriptive Attributes
Naming Attributes
What Is a Service?
What Is a Method?
Identifying Attributes
Specifying Attributes
Identifying Services
Specifying Services
Recommended Approach
6 Specifying Static Behavior
What Is Behavior?
Java Services (Operations) That Affect the Behavior Specification
Techniques for Specifying Static Behavior
Techniques for Specifying Control
Techniques for Documenting Control
Activity Diagrams
Collaboration Diagram
Sequence Diagram
Techniques for Documenting Static Behavior
Pre-conditions and Post-conditions
Flowcharting
Data Flow Diagrams
Structured English
Recommended Approach
7 Dynamic Behavior
Introduction
Techniques for Identifying Dynamic Behavior
Common Lifecycle Forms
Models for Capturing Lifecycle
Identifying and Specifying Events
Use Case and Scenario
Sequence Diagram
Specifying Dynamic Behavior
Event List
State Transition Table
Documenting Dynamic Behavior
State Diagrams
Recommended Approach
8 Identifying Relationships
Accessing Another Object's Services
Relationships
Generalization
Identifying and Specifying Generalization/Specialization
Object Aggregation
Classification of Aggregation
Assembly-Parts (Component-Integral) Composition
Material-Object Composition
Portion-Object Composition
Place-Area Composition
Collection-Members Composition
Container Content (Member-Bunch) Composition
Member-Partnership Composition
Objects and Aggregation Relationships
Links Between Objects
Identifying and Specifying Links and Aggregations
Managing ,Relationships
Documenting Relationships
Recommended Approach
9 Rules
Introduction
Rules
Identifying Declarative Statements
Specifying and Documenting Rules
Mapping Rules to the Proper Object-Oriented Concepts
Documenting the Rules Using UML
Implementing Rules
Recommended Approach
10 The Model
Concepts
Concepts and Object-Oriented Model
Class
Interface
Association
Class Aggregation
Generalization/Specialization of Classes
Polymorphism
Instantiation
Documenting Concepts Using UML
Class Concept
Basic Class Construct
Parameterized Class and Bounded Class Construct
Interface Construct
Association
Class Aggregation
Generalization/Specialization of Class
Generalization/Specialization of Interface
Polymorphism
Instantiation
Refining the Model
Subsystems
Domain
Bridge
Organizing Subsystems
Horizontal Layers
Vertical Partitions
Combination
Identifying Subsystems
Documenting Subsystem
Recommended Approach
Subsystems
11 Design
Introduction
System Design
Subsystems
Architectural Frameworks
Software Control Within a Framework
Documenting System Design
Detailed Design
Class Design
Association Design
Generalization and Inheritance
Delegation
Orlando Treaty
Multiple Inheritance
Documenting Detailed Design
12 Java Fundamentals
Introduction to the Java Language
Example Statements
Unicode Character
Programming Elements
Comments
Reserved Words (Keywords)
Identifiers
Literals
Operators
Arithmetic Operators
Boolean Operators
Conditional and Relational Operators
Bitwise Operators
Class-Defined Operators
Punctuators
Primitive Data Types
Primitive Data Types
Constant Values
Symbolic Variables
Reference Variables
Constants
Class "Data Type"
What Is a Statement.9
Expressions
Null Statement
Assignment Statement
Service Request Statement
Block (Compound Statement)
Statement Flow Control
If Statement
If-Else Statement
For Statement
Switch Statement
While Statement
Do-While Statement
Branching Statements
The Break Statement
The Continue Statement
The Return Statement
Exception Handling
Throws and Try-Catch Block
Throwable Class
NameSpace
No Global Variables
Package and Imports
Packages of the Java API
Filenames and Directories
Access to Members of a Class
Public
Private
Protected
Package
Summary
Type Conversion
Casting Between Primitive Data Types
Casting Objects
Converting Primitive Data Types to Objects
Recommended Approach
13 Implementing Class and Interface
Components of a Class
Class Defnition
Class Body
Visibility
Data Variables
Instance Data Variables
Class Data Variables
Constants
Initialization of Member Variables
Other Attributes of a Class Member
Member Methods
Class Method
Details of Member Method Prototype
Abstract Class
Nested, Inner, and Anonymous Inner Classes
Nested Classes
Inner Class
Anonymous Inner Classes
Predefined Java Classes
String Data Type
String Concatenation
Conversion of an Object to a String Instance
Conversion from String to Integer and Vice Versa
Substrings
Length of String
Individual Characters in a String
Immutable Property
StringBuffer Data Type
Number Data Types
Array Data Type
Declaring a Variable to Hold an Array
Initialization of an Array
Access and Assignment by Position
Multidimensional Array
Interface
Interface Declaration
Interface Body
Using an Interface as a Data Type
Implementing the Interface
Why Can't I Just Use an Abstract Class?
Do Interfaces Provide for Multiple Inheritance?
What Can I Use Interfaces For?
Recommended Approach
14 Implementing Static Behavior
What Is a Service?
Method Definition
Method (Service) Prototype
Method Implementation
Return Type
Return Statement
Body
this
super
Local Variables
Service Argument List
Passing Arguments
Pass-By-Value
Pass-By-Reference (or Pointer)
Identifier's Scope
Polymorphism
Overriding Methods
Calling the Original Method
Creating Objects and Destroying Objects
Introduction
Constructor Methods
Calling Another Constructor
Overloading Constructors
Calling Sequence of Constructors
Visibility of Constructor
Finalizer Method
Constructor and Finalizer Coding Guidelines
Recommended Approach
15 Implementing Dynamic Behavior
Elements of Dynamic Behavior
Simple State Diagrams
Implement the Actions Performed by the Object
Adding State
Introduce Helper Methods for Managing State Entry and Exit Actions
Implement the Event Handlers (Methods) for Responding to Events
Nested State Diagrams
Implement the Actions Performed by the Object
Adding State
Introduce Helper Methods for Managing State Entry and Exit Actions
Implement the Event Handlers (Methods) for Responding to Events
Concurrent State Diagrams
Introduction
Changes to the Microwave Class
Creating a Parallel State Machine
Extending Thread Class
Implement the Actions Performed by the Object
Creating States
Introduce Helper Methods for Managing State Entry and Exit Actions
Implement the Event Handlers (Methods) for Responding to Events
16 Implementing Generalization/Specialization
Introduction
Java Inheritance Hierarchy
Generalization/Specialization Mapping to Inheritance
Inheritance
Derived Class and Base Class
Specifying a Derived Class
Inheriting from a Derived Class and Implementing Association
Adding Polymorphism
Abstract Class
Abstract Service (Method)
Implementing Generalization/Specialization
Interfaces
Aggregation with Delegation
The Object Class
Clone Method
Equals and HashCode Methods
Finalize Method
ToString Method
GetClass Method
Notify, NotifyAll, and Wait Methods
17 Implementin9 More Relationships
Introduction
Implementing Association
Implementing Attributes of an Association
Implementing Aggregation
References
Static Members
Implementing Association
Binary Association
Many-to-One Association
Many-to-Many Association
Implementing Aggregation
Buried Reference
Inner Classes
Implementing Static Members
Recommended Approach
A Unified Modeling Language
Introduction
What Is the Unified Modeling Language?
What UML Is Not
What Are the Goals of UML?
Why Use UML?
What Are the Diagrams of UML?
What Are the Most Important UML Diagrams?
UML Diagrams
Use-Case Diagram
Class Diagram
Sequence Diagram
Collaboration Diagram
Statechart Diagram
Activity Diagram
Component Diagram
Deployment Diagram
UML Glossary
B Java Language Summary
Reserved Words
Comments
Literals
Variable Declaration
Variable Assignment
Operators
Loops and Conditions
Class and Interface Definitions
Objects
Arrays
Method and Constructor Definitions
Packages and Importing
Exceptions and Synchronization
C How the Java Language Differs from C and C++
C Data Types Not Supported
Pointers
Struct and Union
Enumerated Data Types
Primitive Data Types
Operators
Arguments
Command Line
Method Arguments
Arrays
Java Strings
Memory Management
Miscellaneous
Bibliography
Index
鄂公网安备 42010302001612号 