uCertify

Object-Oriented Analysis, Design and Implementation

Master Object-Oriented Analysis, Design, and Implementation. Build robust, scalable software systems using proven methodologies and practical application.

(OODESGN-IMPLMT.AU1)
Lessons
Lab
AI Tutor (Add-on)
Get A Free Trial

About This Course

This Object-Oriented Analysis Design Implementation course provides a brutally honest, integrated approach to building complex software. You'll move beyond theory, learning to gather requirements, model systems, and implement designs effectively. We tackle the trade-offs and common failure points in object-oriented analysis design training, ensuring you understand not just how but why. With 16 virtual labs and extensive practice, this Object-Oriented Analysis, Design online course prepares you for real-world challenges, evaluating software design and applying the paradigm with confidence. Expect to build, break, and rebuild, mastering the entire lifecycle.

Skills You’ll Get

  • System Modeling Mastery: Develop the ability to choose and construct appropriate UML diagrams (user interface, logical, interaction) to accurately represent complex object-oriented systems, understanding their inherent limitations.
  • Robust Design Implementation: Learn to assign responsibilities, design classes for safety and security, and evaluate software design quality, recognizing that perfect design is a myth, and trade-offs are inevitable.
  • Reusable Code Architecting: Master strategies for designing for reuse through generic implementations, inheritance hierarchies, and composition, critically assessing the importance of substitutability and its practical constraints.
  • Interactive System Development: Gain expertise in applying the Model-View-Controller (MVC) architectural pattern to analyze, design, and implement interactive systems, understanding the complexities of separating concerns.
Download Course Outline

1

 Preface

2

Introduction

  • What Is the Object-Oriented Paradigm?
  • Key Concepts of Object-Oriented Design
  • Other Related Concepts
  • Benefits of the Paradigm
  • Dealing with Drawbacks of the Paradigm
  • History
  • Discussion and Further Reading
3

Basics of Object-Oriented Programming

  • The Basics
  • Implementing Classes
  • Creating and Working with Related Classes
  • Defining and Working with Collections
  • Interfaces
  • Abstract Classes
  • Dealing with Run-Time Errors
  • Inheritance
  • Design Patterns
  • Run-Time Type Identification
  • The Object Class
  • An Introduction to Generics in Java
  • Discussion and Further Reading
4

Modeling Object-Oriented Systems

  • A First Example
  • Choosing the Diagrams to Describe an Object-Oriented System
  • Building a User Interface Model
  • Building a Logical Model
  • Modeling the Interaction Between Entities
  • Modeling the Behavior of a System
  • Discussion
5

Analyzing a System

  • Gathering the Requirements
  • Building the User Interaction Model
  • Defining Conceptual Classes and Relationships
  • Using the Knowledge of the Domain
  • Discussion and Further Reading
6

Designing a System

  • Initiating the Design Process
  • Assigning Responsibilities to the Classes
  • Designing the Classes
  • Designing for Safety and Security
  • Evaluating the Quality of the Software Design
  • Discussion and Further Reading
7

Implementing a System

  • Organization of UserInterface and Library
  • Populating the Database
  • Modifying Relationships Between Objects
  • Removing Objects
  • Displaying Transactions
  • Other Requirements
  • Discussion and Further Reading
8

Designing for Reuse

  • Reusing Through Generic Implementations
  • Using Reusable Types to Obtain Reusable Implementations
  • Building an Inheritance Hierarchy
  • Combining Inheritance and Composition
  • The Importance of Substitutability for Reuse
  • Discussion and Further Reading
9

Modeling with Finite State Machines

  • A Simple Example
  • Requirements Analysis Using Finite State Modeling
  • A First Solution to the Microwave Problem
  • Critiquing the Simple Solution
  • Using the State Pattern
  • Communicating the Timing Events
  • Replacing Event Conditionals with Polymorphism
  • Employing the FSM Model for Other Types of Applications
  • Discussion and Further Reading
10

Interactive Systems and the Model–View–Controller Architecture

  • The Model–View–Controller Architectural Pattern
  • Analyzing a Simple Drawing Program
  • Detailed Use Cases for the Drawing Operations
  • Designing the Drawing Program
  • Implementation
  • Pattern-Based Solutions
  • Discussion and Conclusion
11

A Deeper Look Into Inheritance

  • Applications of Inheritance
  • Inheritance: Some Limitations and Caveats
  • Working with Inheritance
  • Transmitting Complex Properties Using Inheritance
  • Using LSP to Verify Substitutability*
  • Multiple Inheritance*
  • Discussion and Further Reading
A

Appendix: Java Essentials

  • A.1 Language Basics
  • A.2 A Simple Java Program
  • A.3 Primitive Data Types
  • A.4 Relational Operators
  • A.5 A Note on Input and Output
  • A.6 Selection Statements
  • A.7 Loops
  • A.8 Methods
  • A.9 Arrays

1

Basics of Object-Oriented Programming

  • Using a Constructor and AutoCloseable
  • Creating and Using a Class
  • Using LinkedList in a Class
  • Using an Interface
  • Using an Abstract Class
  • Implementing Class Inheritance
  • Using Utility Methods
  • Using Generics in Class
2

Modeling Object-Oriented Systems

  • Building a Basic UI Model in Java
  • Building a Logical Model for a College Registration System
3

Analyzing a System

  • Building a Basic Library System
4

Designing for Reuse

  • Using the Java Thread Class
5

Modeling with Finite State Machines

  • Implementing the State Pattern
  • Generating and Handling Timing Events
  • Modeling a GUI using FSM
6

A Deeper Look Into Inheritance

  • Implementing Object Cloning

Any questions?
Check out the FAQs

  Want to Learn More?

Contact Us Now

This course focuses on the complete lifecycle of object-oriented software development: from initial requirements gathering and system analysis to robust design, implementation, and evaluation. It's about building functional, maintainable systems, not just theoretical concepts.

While it covers foundational concepts, a basic understanding of programming logic is beneficial. The course is structured to guide you step-by-step, but it quickly dives into advanced topics like modeling with finite state machines and architectural patterns.

The course primarily uses Java for implementation examples and practical exercises, including an "Appendix: Java Essentials" chapter to ensure foundational understanding. This allows for concrete application of object-oriented principles.

We explicitly discuss drawbacks, common failure points, and trade-offs inherent in object-oriented design. Chapters like "Designing for Safety and Security" and "Evaluating the Quality of the Software Design" prepare you for the imperfect realities of software engineering.

The course is packed with practical resources: 16 hands-on labs, 45 practice exercises, 150 practice quizzes, and 8 video lessons totaling over 19 hours. These are designed for active learning and application, not just passive consumption.

Related Courses

All Courses
We use cookies for improving site experience and analytics. Learn More