699 Windsong Trail
Austin, Texas 78746
(512)-328-9660

Course Name: Object-Oriented  Analysis and Design Using the Unified Modeling Language.

Course Overview:  To conduct effective object-oriented analysis and design, you must be proficient in at least three areas.  First, you must understand basic object-oriented concepts and, assuming you intend to document the design, a notation for describing those concepts.  Second, you must command a set of approaches that you can employ to transform a problem into a model or design.  Finally, you must have a set of guidelines and tactics that you can apply to compare two competing designs, or to improve an existing design.  This five-day course leads attendees through a complete object-oriented analysis and design method using the UML as the design notation.  The course demonstrates a set of approaches for identifying use cases, classes, and behaviors, and it explains various guidelines and heuristics that produce more extensible and reusable models and designs.

Course Audience: This course is beneficial to individuals and projects using or about to use object-oriented analysis and object-oriented design. Students will learn the UML notation, as well as how to design reusable and extensible object-oriented programs.

Course Prerequisites: None. No knowledge of object-oriented concepts or of object-oriented development is assumed.

Course Outline:

Introduction:  A discussion of basic object-oriented concepts.  The object-oriented development process and its benefits.  Object-oriented design principles such as coupling and cohesion.

Use Case and Activity Diagrams:  Describing system functional requirements with use case diagrams and activity diagrams.  Relationships between use cases in use case diagrams.  Describing temporal sequencing of use cases with activity diagrams.

Basic Concepts and Notation for Class Diagrams:  Basic concepts and notations for class modeling and design.  Classes, attributes, and methods.  Associations, aggregation, and composition.  Class specialization, inheritance, type promotion, and polymorphism.  Forms of class specialization.

Advanced Concepts and Notation for Class Diagrams:  Association roles and qualified associations.  Association classes.  Dependencies and refinements.

Class Modeling and Design Approaches:  Three approaches for identifying classes, class relationships, etc.  Comparison of approaches.  Using combinations of approaches.

Flexibility Guidelines for Class Design:  Guidelines and heuristics that lead to more extensible and reusable class designs.  Coupling and cohesion in object-oriented programs.  Class normalization for cohesion.  Guidelines for the use of inheritance.  Using aggregation versus using inheritance.

UML Extension Mechanisms:  The use of properties, constraints, and stereotypes to extend the UML notation.  Standard stereotypes, including interfaces.  The use of interfaces to define roles.

Concepts and Notation for Interaction Diagrams:  The concepts and notations for collaboration and sequence diagrams.  Denoting iteration, branching, and object creation and destruction in each type of diagram.  The relationship of interaction diagrams to the class diagram.

Concepts and Notation for State Transition Diagrams:  When to use state transition diagrams.  The notation for the diagrams, including composite states, history states, and concurrent state machines.

Behavioral Design Approaches:  The "top-down" versus the "bottom-up" approaches to designing class behaviors.  Use cases revisited:  three approaches for identifying a problem's use cases.  The top-down process of identifying required scenarios, then turning those scenarios into interaction diagrams, object methods, and state machines.  The bottom-up approach of concentrating on class responsibilities.

Flexibility Guidelines for Behavioral Design:  Guidelines for allocating and designing behaviors that lead to more flexible designs.  Coupling revisited.  Avoiding centralized control.  The overuse of accessor methods.  Trading off extensibility versus reuse.

System Architecture:  Layered architectures.  The package concept and its UML notation.  Defining layers and subsystems as packages.  How to decompose a system into subsystems.  The UML component diagram.

Concurrency and Synchronization:  Threads and processes.  Managing concurrent access to objects.  Scheduling approaches.  Introducing concurrency in UML interaction diagrams.

Distribution and Persistence:  Physical distribution and the UML deployment diagram.  Superimposing distribution on top of UML interaction diagrams.  An introduction to object request brokers.  Flat files versus relational databases versus object-oriented databases for persistence.

An Introduction to Object-Oriented Programming:  A short introduction to Java or C# as an example of an object-oriented programming language.

Low-Level Design Idioms:  Guidelines for designing class interfaces.  Idioms for the low-level design of class attributes, associations, and operations.

Frameworks and Design Patterns:  An introduction to reuse through class libraries, frameworks and design patterns.  A look at some design patterns.

Return to OO Training Course Catalog.