UML与Java面向对象开发（影印版）

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