PTG home
Catalog Search:
Search
Related Topics:
COMPUTING
Programming Languages
JAVA




 
Practical Object-Oriented Development with UML and Java 1/e

Richard C. Lee
William M. Tepfenhart

Published May 2002 by Prentice Hall
Copyright 2003, 468 pp., Paper
ISBN: 0-13-067238-6
List Price:
$56.00

Inventory Status:
In-Stock
   
Preface


Summary

If you're a busy professional software analyst or developer working on large systems, and you do not have the time to take a class, you can get up to speed on object-oriented (OO) technology using Unified Modeling Language and Java with this book. It is a self-teaching guide, written by two industry leaders, that helps you to understand the differences between OO analysis, OO design, and OO programming.

FEATURES
  • Offers a detailed discussion of the primary principles of object orientation from the perspective of a Java implementation.
  • Introduces Use Cases in depth as a means of developing a specification model.
  • Includes a broad range of analysis approaches that can be tailored to a specific organization and recommends the easiest approaches for novices.
  • Provides detailed material on capturing dynamic behaviors with considerable material on how to design and implement it.
  • Introduces the Java Standard Extension in sufficient detail, including programming examples, that a student can incorporate the high power classes provided with Java.
  • Covers how relationships are implemented in Java, including aggregation and associations.


Features

  • An introduction to the fundamental concepts of object-oriented programming with a practical approach to OO analysis, design, and programming.
    • Offers students and teachers the opportunity to implement a team project.

  • In-depth coverage of OO technology.
    • Shows students how to use objects, classes, relationships, and rules, and how they fit into the object paradigm.

  • Wide range of practical techniques—Explains why they are used.
    • Enables students to apply the methodology used in real-world development sites.

  • Theory balanced with application practices.
    • Introduces students to the key OO concepts and approaches that are valuable in solving real business problems.

  • Emphasis on reliability, maintainability, and flexibility—The most important technical aspects of software engineering.
    • Teaches students how to lower development cost and reduce time-to-market enhancements in real business situations.

  • End of chapter step-by-step guides—Recommended approaches and summaries for techniques described in the chapters.
    • Reinforces for students the techniques needed to implement OO technology using Java.

  • Suggestions for a class project—Challenges students to develop a game as they cover material in the text.
    • Encourages students to apply concepts as they follow the whole OOAD process; enables instructors to add another dimension to the class experience.

  • A usable set of UML notation for design and documentation.
    • Provides students with an understanding and mastery of the current generation of Software Engineering tools.

  • Shows how to apply Use Cases to develop software specifications.
    • Supplies students with ample guidelines for avoiding common mistakes when developing software specifications.

  • In-depth case studies—Show how to implement design models in Java using abstractions, relationships, aggregation, and class.
    • Allows students to understand how all of the concepts and methods fit together to assist in the development of an object-oriented application.



Author Bio

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



Introduction.

Object-Oriented Technology. Why Unified Modeling Language? Why Java? Our Approach to Object-Oriented Technology. Organization of the Book.



1. Managing Complexity with Abstraction.

Complex Systems. Abstraction Mechanisms. Service Activation Abstractions. Processing Control Abstractions. Relationships. Behavior. Rules.



2. The Object-Oriented Paradigm.

The Object-Oriented Paradigm. Principles of Object-Orientation. Object-Oriented Model of Computation.



3. Building a Specification Model.

Introduction to Use Cases. Documenting Use Cases. Guidelines for Developing Use Cases. Contracts. Recommended Approach.



4. Finding the Objects.

Object Oriented Analysis: Model of an Application Domain. Building the Object-Oriented Model. Identification of Objects, Classes, and Interfaces. Current Techniques. Traditional Techniques. Recommended Approaches.



5. Identifying Responsibilities.

What Is an Object? What Is an Attribute? 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. Techniques for Documenting Static Behavior. Recommended Approach.



7. Dynamic Behavior.

Introduction. Techniques for Identifying Dynamic Behavior. Identifying and Specifying Events. Specifying Dynamic Behavior. Documenting Dynamic Behavior. Recommended Approach.



8. Identifying Relationships.

Accessing Another Object's Services. Relationships. Generalization. Identifying and Specifying Generalization/Specialization. Object Aggregation. Classification of Aggregation. Links Between Objects. Identifying and Specifying Links and Aggregations. Managing Relationships. Documenting Relationships. Recommended Approach.



9. Rules.

Introduction. 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. Documenting Concepts Using UML. Subsystems. Organizing Subsystems. Identifying Subsystems. Documenting Subsystems. Recommended Approach.



11. Design.

Introduction. System Design. Detailed Design. Summary.



12. Java Fundamentals.

Introduction to the Java Language. Programming Elements. Primitive Data Types. What Is a Statement? Statement Flow Control. Branching Statements. Exception Handling. NameSpace. Type Conversion. Recommended Approach.



13. Implementing Class and Interface.

Components of a Class. Class Definition. Class Body. Nested, Inner, and Anonymous Inner Classes. Predefined Java Classes. Interface. Recommended Approach. Summary.



14. Implementing Static Behavior.

What Is a Service? Method Definition. Body. Passing Arguments. Identifiers Scope. Polymorphism. Creating Objects and Destroying Objects. Coding Guidelines. Recommended Approach.



15. Implementing Dynamic Behavior.

Elements of Dynamic Behavior. Simple State Diagrams. Nested State Diagrams. Concurrent State Diagrams.



16. Implementing Generalization/Specialization.

Introduction. Inheritance. Implementing Generalization/Specialization. The Object Class.



17. Implementing More Relationships.

Introduction. References. Static Members. Implementing Association. Implementing Aggregation. Implementing Static Members. Recommended Approach.



Appendix A: Unified Modeling Language.

Introduction. UML Diagrams. UML Glossary.



Appendix B: Java Language Summary.

Reserved Words. Comments. Literals. Variable Declaration. Variable Assignment. Operators. Loops and Conditions. Class and Interface Definitions. Objects. Arrays. Methods and Constructor Definitions. Packages and Importing. Exceptions and Synchronization.



Appendix C: How the Java Language Differs from C and C++.

C Data Types Not Supported. Primitive Data Types. Operators. Arguments. Arrays. Java Strings. Memory Management. Miscellaneous.



Bibliography.


Index.



back to top