O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Java™ Design: Objects, UML, and Process

Book Description

Software designers, developers, and architects are constantly confronted with the same confounding problem: how to design software that is both flexible and resilient amid change. To accomplish this tall task, practitioners must utilize the best available technologies to the fullest.

Java™ Design relies on a combination of best practices and best-of-breed technologies to create a clear and concise guide to building high-quality, lasting software designs. In particular, the author provides unique insight into using the Unified Modeling Language (UML) to develop Java applications.

The first half of the book focuses on the software process and how UML, Java technology, and object-oriented programming can be used effectively. The advantages of each technology are enumerated, highlighting common principles. Also included are in-depth discussions of design patterns, the Unified Process, and Extreme Programming.

The second half of the book describes how these complementary technologies can be used together as a system of checks and balances to ensure successful creation of high-quality software. You'll also find details on modeling strategies, a phased approach to adopting each of the technologies outlined, and the design of subsystems.

Key topics include:

  • Object-oriented principles and patterns

  • UML and the role of modeling

  • UML and the software process, including best practices and lifecycle development

  • Modeling strategies and requirements

  • Behavioral modeling

  • Architectural modeling

  • Designing subsystems

  • Refactoring

  • Armed with a fresh perception of current design tools, this book will give you a deeper understanding of how to design cleaner Java applications using UML. Learn how you can expand your developer's toolkit using existing technologies in new ways--and create better software.


    Table of Contents

    1. Copyright
    2. PREFACE
    4. OO Principles and Patterns
      1. Principles, Patterns, and the OO Paradigm
      2. Class Principles
      3. Package Principles
      4. Patterns
      5. Conclusion
    5. Introduction to the UML
      1. The UML Defined
      2. Origin
      3. Role of Modeling
      4. Benefits
      5. Conclusion
    6. Fundamental UML
      1. Models and Views
      2. Core Diagrams
      3. Fundamental Elements
      4. Annotations
      5. Extensibility Mechanisms
      6. Introduction to Diagrams
      7. Conclusion
    7. The UML and Software Process
      1. Process Defined
      2. Best Practices
      3. Development Lifecycle and the UML
      4. The Full Lifecycle
      5. Conclusion
    8. Modeling Strategies
      1. Integration Goals
      2. Integration Factors
      3. Integration Strategy
      4. Conclusion
    9. Requirements Modeling
      1. Notation
      2. Requirements Modeling
      3. Conclusion
    10. Problem Analysis
      1. Notation
      2. Identifying Initial Concepts
      3. Software Specification
      4. Establishing Architecture
      5. Allocating Classes
      6. Conclusion
    11. Behavioral Modeling
      1. Notation
      2. Use Case Realizations
      3. Responsibility Allocation
      4. Model Structure
      5. Conclusion
    12. Structural Modeling
      1. Notation
      2. Coupling and Cohesion
      3. Useful Class Diagrams
      4. Identifying Structure
      5. Model Structure
      6. Conclusion
    13. Architectural Modeling
      1. Defining Architecture
      2. Establishing Architecture
      3. Architectural Mechanisms
      4. Views of Architecture
      5. Frameworks and Class Libraries
      6. Component Architectures
      7. Conclusion
    14. Designing Subsystems
      1. Defining Subsystems
      2. Subsystems in Java
      3. Subsystem Specification
      4. Subsystem Identification
      5. Subsystem Development
      6. Subsystems as Frameworks
      7. Conclusion
    15. Rational Unified Process (RUP) and Extreme Programming (XP)
      1. Rational Unified Process (RUP)
      2. Extreme Programming (XP)
      3. Similarities and Differences
      4. Conclusion
    16. J2EE and the UML
      1. J2EE: A Brief Overview
      2. Designing with J2EE
      3. Conclusion
    17. Code Listing for UML Exercise
    18. Bibliography
      1. Bibliodiv
      2. Additional Resources