Extend your training investment! Recorded sessions, free re-sits and after course support included with Every Course
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.
NOTE: This course is a fast-track subset of our five-day, more comprehensive TT1130 OOA&D using UML course.
The course includes coverage of the most effective techniques in use today, such as Use Case analysis, static and dynamic system modeling, responsibility driven design, Design Patterns, using UML to document designs, and much more. The focus of the course is to give a practical approach to producing high quality object-oriented software designs and to provide the knowledge and experience necessary to avoid the most common risks associated with building production systems. Properly assigning responsibilities to classes is one aspect of detailed design that is particularly important. This course pays special attention to that particular design activity, looking at GRASP (General Responsibility Assignment Software Patterns) patterns and how they can be applied to real design problems.
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
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.
Attendees can include systems and software analysts and designers, programmers who read and implement program designs, personnel involved in inspections and design/code walk-through, software project managers managing large (re-use) projects, and maintenance personnel involved in maintaining and re-engineering software products. This course is also highly beneficial for those who specify requirements and business rules for systems.
Attendees should have a working knowledge of developing software applications. Designing and analysis experience is also extremely beneficial. This is not a coding class.
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
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
Using Risk to Order the Process
Implementation Timetable
Reuse
Education and Mentoring
Training and Mentoring
Our course materials include more than a simple slideshow presentation handout. Each student will receive a comprehensive course Student Guide, complete with detailed course notes, code samples, software tutorials, diagrams and related reference materials and links. Our courses also include detailed our Student Workbook, with step by step hands-on lab instructions and project files (as necessary) and solutions, clearly illustrated for users to complete hands-on work in class, and to revisit to review or refresh skills at any time. Students will also receive the course set up files, project files (or code, if applicable) and solutions required for the hands-on work.
Live scheduled classes are listed below or browse our full course catalog anytime
Check out custom training solutions planned around your unique needs and skills.
Exclusive materials, ongoing support and a free live course refresh with every class.
Mix, Match & Master!
2FOR1: Two Courses, One Price!
Enroll in *any* two public courses (for 2023 *OR* 2024 dates!) by December 31, for one price! Learn something new, or share the promo!
Special Offers
Limited Offer for most courses.
SAVE 50%