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
鄂公網(wǎng)安備 42010302001612號(hào) 