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
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.
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
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
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.
OO Training Course Catalog.