Live Chat
Monday - Friday 8am - 6pm EST Chat Now
Contact Us
Monday - Friday 8am - 8pm EST 1-800-268-7737 Other Contact Options

Cart () Loading...

    • Quantity:
    • Delivery:
    • Dates:
    • Location:


Fast Track to Object Oriented Analysis and Design (OOAD) (TT1110)

Core OO development essentials for application developers

GK# 8736

Course Overview


Fast Track to Object Oriented Analysis & Design with UML is a three-day, fast-paced hands-on course that provides students with a solid foundation to move into an OO programming environment.  This course takes advantage of several of the latest features in UML and incorporates several of the newest techniques and approaches for improving OOAD. This course focuses on the advantages of the OO paradigm and domain modeling in reducing the representational gap between a target domain and the software application itself.  Minimizing this gap leads to more effective solutions that are both flexible and robust.


  • Delivery Format:
  • Date:
  • Location:
  • Access Period:


What You'll Learn


Working in an engaging group exercise and hands-on “thinking and drawing” environment, students will:

  • Learn the three pillars of building a system; The Model, The Process, The Best Practices
  • Have a good, working definition of object-oriented programming
  • Understand the object-oriented model, including types, objects, encapsulation, abstraction, messaging, protocols, inheritance, polymorphism, relationships, and coupling, strengths and weaknesses
  • Understand the concept of representational gap between an application and its targeted domain
  • Relate how Domain Modeling minimizes the representational gap between domain and application
  • Learn how to read and create the most important UML diagrams
  • Recognize the difference between analysis and design
  • Be able to produce a requirements analysis
  • Know how to create Use Cases, recognizing and avoiding bad use cases
  • Effectively perform object discovery using such tools as category lists and use cases to harvest candidate objects
  • Learn how to create a static conceptual model of your system
  • Learn how to create a dynamic behavioral model of your system
  • Understand how to move from analysis to design
  • Effectively identify relationships amongst objects, understanding when to show those relationships and when not to
  • Effectively assign responsibilities using the patterns and principles of GRASP (General Responsibility Assignment Software Patterns)
  • Understand Design Patterns and their importance
  • Learn how to apply Design Patterns to refine your model
  • Understand the uses of inheritance, where it is appropriate, and where it is not
  • Recognize the abuse of inheritance
  • Understand the importance and use of interfaces
  • Recognize rich versus anemic domain models
  • Understand how to move from design to implementation

If your team requires different topics or tools, additional skills or custom approach, this course may be easily adjusted to accommodate.  We offer additional software development, programming and design courses which may be blended with this course for a track that best suits your development objectives. Our team will collaborate with you to understand your needs and will target the course to focus on your specific learning objectives and goals.


Viewing outline for:

Virtual Classroom Live Outline

Session: Introduction to OO Analysis & Design


Lesson: Introduction to Modeling and UML

  • Three Object-Oriented Themes
  • Building Models
  • Why Build a Model?
  • Notation
  • What is UML?
  • Domains
  • The Process of OO Analysis and Design
  • OOAD Process: Requirements Capture; Analysis; Domain Design; Detailed Design; Architectural Design
  • OOAD Developer Activities
  • Activities: Requirements; Object Discovery; Object Relationships; Object Interactions; Object State; Object Activities; Packaging of Objects; Components and Deployment
  • Granularity; Levels of Detail
  • Requirements Document
  • Typical Requirements Document Example


Lesson: Classes and Objects

  • Objects
  • Objects Provide a Service
  • Rendering Objects
  • Abstractions
  • Responsibilities and Operations
  • Operations
  • Rendering Operations
  • Messages and Public Interfaces
  • Instances
  • Classes
  • Instantiation
  • UML Class and Instance Icons
  • Encapsulation
  • Discovering Abstractions


Lesson: Relationships

  • Introduction to Relationships
  • Static Relationships
  • Dependencies
  • Drawing Dependencies
  • Associations
  • Class Associations
  • Associations are Bi-Directional
  • Navigability
  • Multiple Associations between Two Classes
  • Discovering Associations
  • Whole/Part Associations
  • Composition
  • Discovering Whole/Part Relationships
  • Generalization/Specialization Relationships
  • Terminology
  • Generalizations Hierarchies
  • What Gets Inherited?
  • Inheritance of Methods and Method Overriding
  • Using the Overridden Method's Implementation
  • Inheriting Associations
  • Abstract Classes
  • Multiple Inheritance
  • Lab Generalization/Specialization Diagram
  • Dynamic Relationships
  • Sequence Diagrams
  • Property of Sequence Diagrams
  • Sequence Diagrams Example
  • Creating a UML Sequence
  • Diagram
  • Communication Diagrams
  • Communication Diagram Details
  • Creating a Communication Diagram


Lesson: UML Diagrams

  • Introduction
  • Class Diagram
  • Use Case Diagrams
  • Interaction Diagrams
  • Sequence Diagrams
  • Communication Diagrams
  • State Machine Diagrams
  • Activity Diagram
  • Implementation Diagrams
  • Session: Object-Oriented Analysis


Lesson: Use Cases

  • Where We Are
  • Useful Systems
  • Discovering the Use Cases
  • The Use Case View
  • Actors
  • Use Case
  • Caveats!
  • Extending Use Cases
  • Including additional Use Cases
  • Generalizations
  • Discovering Use Cases


Lesson: Use Case Scenarios

  • Scenarios
  • Primary and Secondary Scenarios
  • Essential and Real Scenarios
  • Ranking Use Cases
  • Documenting Use Cases and Scenarios
  • Summary of Requirements Capture Steps
  • Use Case Benefits
  • Discovering Use Case Scenarios


Lesson: Conceptual Modeling

  • Where We Are
  • Introduction to the Analysis Model
  • Introduction to the Analysis Model II
  • Conceptual Modeling
  • Concepts
  • Concept Category List
  • Identifying Concepts
  • Mapmaking Principles
  • Attributes versus Concepts
  • Some Rules of Thumb
  • More Rules of Thumb
  • Specification or Description
  • Worked Example: Concepts
  • Concepts for the Withdrawal Use Case
  • Associations
  • Common Association List
  • Worked Example
  • Withdrawal Concepts Diagram
  • Adding Attributes
  • Worked Example
  • Updating the Project Dictionary
  • Conceptual Modeling


Lesson: Domain Behavior Modeling

  • Where We Are
  • Domain Behavior Modeling
  • System Sequence Diagrams
  • System Sequence Diagram: Details
  • Worked Example
  • Analysis State Machine Diagrams
  • Contracts
  • Creating Contracts
  • Session: Object Oriented Design


Lesson: Discovering Potential Objects  using CRC Cards

  • Discovering Objects
  • Brainstorming for Classes
  • CRC cards
  • Sample Set of CRC Cards
  • Completing the Analysis
  • Creating a Project Dictionary
  • Using CRC Cards


Lesson: Static Design Concepts

  • Introduction
  • Visibility of Attributes and Operations
  • Multiplicity of Objects
  • Interfaces and Components
  • Design Complex Systems from Components
  • Identifying "Good" Classes
  • Multiplicity of Associations
  • Ternary Relationships
  • Alternatives to Ternary Relationships
  • Constraints in Associations
  • Role and Role Names
  • Association Qualification
  • Association Class
  • Whole/Part Associations
  • Extensibility Mechanisms: Constraints
  • Extensibility Mechanisms:Tagged Values
  • Extensibility Mechanisms: Stereotypes
  • Common Extensibility Mechanisms: Notes
  • Generalization/Specialization - Abstracting Down
  • Generalization/Specialization - Abstracting Up
  • Abstract Classes
  • Multiple Inheritance
  • Types and Substitutability
  • Polymorphism
  • Specialization is not Always Appropriate!
  • Organizing Classes into Packages
  • Packages
  • Using Packages
  • Component Diagrams
  • Interfaces
  • Deployment Diagrams


Lesson: Dynamic Design Concepts

  • Introduction
  • Interaction Diagrams
  • Sequence Diagram Example
  • Communication Diagram Details
  • State Machine Diagrams and Business Rules
  • Business Rules
  • Verifying Completeness
  • Advanced States and Transitions
  • Superstates and Substates
  • Concurrent States
  • Creating a Sophisticated State Machine Diagram
  • Activity Diagrams: Swimlanes
  • Creating an Activity Diagram


Lesson: Domain Design

  • Where We Are
  • Conclusion of the Analysis Phase
  • Starting the Design Phase
  • Iterative Development
  • Domain Design
  • Detailed Design
  • Forming the Architectural vision
  • Describing Real Use Cases
  • Real Use Case: Worked Example
  • Review of the Conceptual Model
  • Responsibilities
  • Golden Rules
  • Low Coupling Examined
  • Authenticate Use Case: Possible solution
  • Creating the Domain Design Model
  • Using Risk to Order the Process
  • Implementation Timetable
  • Reuse


Lesson: Detailed Design

  • Where We Are
  • Design Overview
  • Detailed Design Steps
  • Steps in the Process
  • Steps in Checking for Completeness
  • Detailed Design Activities
  • Class Design
  • Class Design Example
  • Class Design: Data Dictionary
  • Class Design: Attributes and Operations
  • Ensuring Low Coupling
  • Patterns In Design
  • Model/View/Controller Pattern
  • Factory Pattern
  • Proxy Pattern
  • Representing Patterns
  • Mapping to Databases
  • Mapping to User Interfaces
  • About Frameworks
  • Applying Frameworks
  • Legacy Data
  • Designing Components and Interfaces
  • Creating the Domain Detailed Design


Session: Summary & Conclusion

  • Usage of OO Technology
  • Methodologies and Notation
  • Management Issues
  • The Unified Software Development Process
  • Education and Mentoring
  • Training and Mentoring



Attendees should have a working knowledge of developing software applications.  Designing and analysis experience is also extremely beneficial.  This is not a coding class.

Who Should Attend


This is a beginner level programming course, designed for developers or technical managers who specify, design and develop software and applications using traditional/formal/structured methods and want to learn to use an object-oriented approach. Ideally students should have some working knowledge of a procedural programming language and syntax, such as C.

Course Delivery

This course is available in the following formats:

Virtual Classroom Live

Experience expert-led online training from the convenience of your home, office or anywhere with an internet connection.

Duration: 3 day

Request this course in a different delivery format.