Object Oriented Analysis, Design & Programming with UML
4.4 (287 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,412 students enrolled

Object Oriented Analysis, Design & Programming with UML

Learn OO Analysis, Design & Programming using UML in C++, Java & C#
Bestseller
4.4 (287 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
2,412 students enrolled
Created by Umar Lone
Last updated 5/2020
English
English
Current price: $139.99 Original price: $199.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 10.5 hours on-demand video
  • 3 articles
  • 12 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Understand & use UML with your software development process
  • Understand what is object oriented analysis, design & programming
  • Understand how to analyze a problem using object oriented analysis
  • Implement OO design in Java, C++ & C#
Requirements
  • Basic knowledge of any programming language
  • Basic understanding of common C concepts like pointers, functions, arrays, macros, etc (for C++ programmers only)
Description

This Object Oriented Analysis, Design & Programming course is a unique course that teaches students how to use object-oriented techniques to build software. The course will start with requirements gathering & end with implementation. In the process, you'll learn how to analyze and design classes, their relationships to each other in order to build a model of the problem domain. You'll also use common UML diagrams throughout this process, such as use-case, class, activity & other diagrams. The diagrams will be created through a free tool. 

Lot of emphasis is placed on use cases to capture and manage requirements. Those are subsequently used to enforce OO concepts that produce a reusable design of the system that adapts to change. Finally, the design is implemented & programmed in three different programming languages - Java, C# & C++. During the implementation, you'll learn about the object-oriented concepts such as Abstraction, Encapsulation, Hierarchy, Polymorphism, interfaces, etc. All these concepts are explained with examples in all the three languages.

Finally, all the important concepts are applied in a textual game called Reckless Driver. Consequently, you'll have understood the entire process of Object Oriented Analysis, Design & Programming & you can implement these concepts in your own software.


Who this course is for:
  • Programmers who want to learn the Unified Modelling Language
  • Anyone who wants to learn OO analysis, design & programming
  • Anyone who wants to start with OO programming in C++, Java or C#
  • Students who want to understand the concepts of object oriented programming
  • Programmers new to object oriented programming
  • Software developers and designers looking to expand their existing knowledge of object oriented analysis & design
  • Anyone who wants to learn & apply UML to their sofware development process
Course content
Expand all 125 lectures 10:31:20
+ Introduction
5 lectures 07:48

Introduction of the course and the instructor

Preview 01:57

Learn how to install Eclipse of your machine

Installation of Eclipse for Java
01:51

Learn how to install Visual Studio on your machine

Installation of Visual Studio for C# & C++
03:10

Explains how to install software on other platforms

Installation For Other Platforms
00:41

Reckless driver source code.

Course Material
00:08
+ Basics
4 lectures 31:07

Learn & understand why software is complex.

Preview 06:23

You'll understand what is algorithmic decomposition & use it to resolve complexity of software.

Algorithm Decomposition
07:53

You'll understand what is object oriented decomposition & use it to resolve complexity of software. You'll also understand why this is better than algorithmic decomposition.

Object Oriented Decomposition
07:47

This lecture explains the basics of an object & its properties.

Preview 09:04
+ Object Oriented Analysis
14 lectures 01:11:02

In this lecture, you'll get introduced to Unified Modelling Language and understand why it is important.

UML Introduction
04:46

This lecture explains Kruchten's 4+1 model that describes the different types of UML diagrams.

View Model
03:31

You'll understand the three basic concepts of object model - analysis, design & programming

Object Model Concepts
07:10

This lecture introduces UML along with how to perform object oriented analysis with use cases.

Object Oriented Analysis with Use Cases
03:35

This lecture explains the format of a use case and how to use that format to write use cases.

Use Case Description
06:21

You'll learn how to use StarUML to create a use-case diagram.

Preview 07:40

You'll understand how to represent relationships between use cases

Use Case Relationships
07:31

You'll create relationship between use cases in StarUML

Use Case Relationships in StarUML
04:35

You'll learn about good practices of creating effective use cases.

Guidelines for Use Cases
04:25

You'll learn about Activity diagrams and how they're used to model a business process.

Activity Diagram
03:26

You'll learn how to create an Activity diagram in StarUML

Activity Diagram in StarUML
05:36

This lecture explains how to use the merge notation to merge two or more incoming flows.

Merge
03:40

In this lecture, you'll learn how to represent concurrent flows in the Activity diagram

Fork & Join
04:52

In this lecture, you'll learn how to create swimlanes in an Activity diagram, so that the actions can be associated with their corresponding participants.

Swimlanes
03:54
+ Object Oriented Design & Programming
27 lectures 01:58:03

This lecture explains the concepts of a class and how to represent it in UML using a class diagram.

Introduction to Classes & Class Diagram
06:08

You'll learn how to create a class diagram in StarUML

Class Diagram in StarUML
07:49

You'll understand the basics of Abstraction.

Abstraction
06:15

This lecture show how to create a class as an abstraction in Java

Abstraction in Java
02:16

This lecture show how to create a class as an abstraction in C#

Abstraction in C#
01:39

This lecture show how to create a class as an abstraction in C++

Abstraction in C++
03:56

You'll learn and understand the concept of encapsulation and why it is important for an abstraction to be encapsulated.

Encapsulation
03:52

Learn how to encapsulate a class in Java through access modifiers.

Encapsulation in Java - Part I
05:34

Learn how to initialize an object using a constructor.

Encapsulation in Java - Part II
06:47

Learn how to encapsulate a class in C# through access modifiers.

Encapsulation in C# - Part I
03:57

Learn how to initialize an object using a constructor.

Encapsulation in C# - Part II
04:54

Learn how to encapsulate a class in C++ through access modifiers.

Encapsulation in C++ - Part I
04:13

Learn how to initialize an object using a constructor.

Encapsulation in C++ - Part II
04:44

In this video, you'll learn how to represent access modifiers in a class diagram.

Class Diagram Revisited
04:00

Learn the concept of inheritance and how it can be used to reuse existing code in object oriented languages.

Inheritance
04:06

Learn how to use inheritance in Java.

Inheritance in Java
05:52

Learn how to use inheritance in C#.

Inheritance in C#
05:59

Learn how to use inheritance in C++.

Inheritance in C++
06:15

In this lecture, you'll learn how objects can be reused through containment. You'll also learn about the different types of containment.

Containment
02:55

Learn how to implement association and aggregation in various programming languages.

Aggregation & Association
04:19

Explains the concept of dependency and how to use it in various programming languages.

Dependency
02:56

You'll learn the concept of polymorphism and its types.

Polymorphism
03:28

This video explains implementation of polymorphism in Java.

Polymorphism in Java
03:07

This video explains implementation of polymorphism in C#.

Polymorphism in C#
02:38

This video explains implementation of polymorphism in C++.

Polymorphism in C++
02:31

You'll learn the concepts of an abstract class and its uses.

Abstract Class
02:58

In this video, you'll learn about the concept of interfaces and how they differ from abstract classes.

Interface
04:55
+ Reckless Driver Implementation
16 lectures 01:13:14

In this lecture, we'll revisit the design of the classes through the class diagram. This will prepare us for the implementation in the subsequent videos.

Overview of Design
02:40

In this lecture, we'll discuss the implementation of the GameObject class.

GameObject Class Implementation in Java
05:09

In this lecture, we'll discuss the implementation of the TrafficCar class. This class will be the base class of all traffic vehicles.

TrafficCar Class Implementation in Java
03:58

In this lecture, we'll discuss the implementation of the SideObject class. This class will be the base class of all side objects.

SideObject Class Implementation in Java
03:26

In this lecture, we'll implement the Player class.

Player Class Implementation in Java
05:31

In this lecture, we'll implement the GameManager class. You'll learn how this class ties up the other classes together.

GameManager Class Implementation in Java
06:05

In this lecture, we'll discuss the implementation of the GameObject class.

GameObject Class Implementation in C#
06:05

In this lecture, we'll discuss the implementation of the TrafficCar class. This class will be the base class of all traffic vehicles.

TrafficCar Class Implementation in C#
02:42

In this lecture, we'll discuss the implementation of the SideObject class. This class will be the base class of all side objects.

SideObject Class Implementation in C#
01:52

In this lecture, we'll implement the Player class.

Player Class Implementation in C#
06:30

In this lecture, we'll implement the GameManager class. You'll learn how this class ties up the other classes together.

GameManager Class Implementation in C#
04:53

In this lecture, we'll discuss the implementation of the GameObject class.

GameObject Class Implementation in C++
05:55

In this lecture, we'll discuss the implementation of the TrafficCar class. This class will be the base class of all traffic vehicles.

TrafficCar Class Implementation in C++
04:08

In this lecture, we'll discuss the implementation of the SideObject class. This class will be the base class of all side objects.

SideObject Class Implementation in C++
02:54

In this lecture, we'll implement the Player class.

Player Class Implementation in C++
06:06

In this lecture, we'll implement the GameManager class. You'll learn how this class ties up the other classes together.

GameManager Class Implementation in C++
05:20
+ Interaction Diagrams
21 lectures 02:12:14

This lecture starts off the discussion on interactions diagrams. We'll first discuss the communication diagram and you'll understand its importace and learn how to draw to represent interactions between objects of a use case.

Communication Diagram - Part I
07:57

This lecture continues with the discussion on communication diagram. You'll learn about the different types of conditional messages that can be sent between objects. Conditional messages are analogous to conditional statements (if-else, switch-case) in code.

Communication Diagram - Part II
04:39

In this lecture, we'll draw the communication diagram in StarUML.

Communication Diagram - Part III
06:49

This lecture continues the previous one. We'll complete the communication diagram of the gameplay use case in StarUML

Communication Diagram - Part IV
06:45

In this lecture, you'll learn about one of the most important diagrams in UML i.e. sequence diagrams. You'll first understand the basic notation of messages, lifelines & activation boxes and learn how to use them in various examples.

Sequence Diagram - Part I
08:09

This lecture explains the concept of fragments in sequence diagrams. You'll learn about different types of fragments and how to use them in your own sequence diagrams.

Sequence Diagram - Part II
05:37

Using the concepts that we learnt about the sequence diagrams, we'll implement one for the gameplay use case and draw it in Star UML

Sequence Diagram - Part III
07:49

This lecture finishes off the creation of sequence diagram in StarUML

Sequence Diagram - Part IV
06:02

This lecture explains the rationale behind addition of a new class called Scene. This class will represent the game scene (level) and will manage the scene objects(side objects, vehicles) and interactions between them. We'll also add this class to the class diagram.

Scene Class Discussion
05:22

We'll start with the implementation of the scene class and implement the generation of scene objects (side objects & traffic vehicles).

Scene Class Implementation in Java - Part I
06:22

We'll finish off the scene class by implementing collision between the player car and the NPCs.

Scene Class Implementation in Java - Part II
05:39

In this lecture, we'll implement the collision behavior in various side objects and traffic vehicles classes.

Collision Behavior Implementation in Java - Part I
06:04

We'll complete the collision implementation and also take care of a few related issues.

Collision Behavior Implementation in Java - Part II
05:10

We'll start with the implementation of the scene class and implement the generation of scene objects (side objects & traffic vehicles).

Scene Class Implementation in C# - Part I
05:42

We'll finish off the scene class by implementing collision between the player car and the NPCs.

Scene Class Implementation in C#- Part II
05:29

In this lecture, we'll implement the collision behavior in various side objects and traffic vehicles classes.

Collision Behavior Implementation in C# - Part I
04:54

We'll complete the collision implementation and also take care of a few related issues.

Collision Behavior Implementation in C# - Part II
06:08

We'll start with the implementation of the scene class and implement the generation of scene objects (side objects & traffic vehicles).

Scene Class Implementation in C++ - Part I
09:04

We'll finish off the scene class by implementing collision between the player car and the NPCs.

Scene Class Implementation in C++- Part II
05:58

In this lecture, we'll implement the collision behavior in various side objects and traffic vehicles classes.

Collision Behavior Implementation in C++ - Part I
06:58

We'll complete the collision implementation and also take care of a few related issues.

Collision Behavior Implementation in C++ - Part II
05:37
+ State Machine Diagram
24 lectures 02:07:17

State machine diagram files.

State Machine Diagram Files
00:03

We'll refactor our Java code so that it can be modified easily later.

Code Cleanup - Java
04:39

We'll refactor our C# code so that it can be modified easily later.

Code Cleanup - C#
06:47

We'll refactor our C++ code so that it can be modified easily later.

Code Cleanup - C++
05:57

Learn how to modify behavior of an object when its state changes through an example in Java.

State Changes in Java
02:53

Learn how to modify behavior of an object when its state changes through an example in C#.

State Changes in C#
03:44

Learn how to modify behavior of an object when its state changes through an example in C++.

State Changes in C++
02:55

This lecture introduces state machine diagram and some of its basic elements.

State Machine Diagram - I
07:23

Learn how to draw a state machine diagram in StarUML.

State Machine Diagram - II
02:50

In this lecture, we'll draw a basic state machine diagram of our game. We'll complete it in later lectures.

State Machine Diagram - III
03:53

We'll add states to Player class in Java, so that we can modify the behavior of the game based on the state.

Player States in Java
04:05

In this lecture, we'll add a powerup in our game that will modify the player health.

Healthkit Powerup in Java
05:35

In this lecture, we'll implement the behavior change based on the state of the player health.

State Behaviors in Java
04:21

This lecture demonstrates how we can add more powerups to the game.

More Powerups in Java
06:46

We'll add states to Player class in C#, so that we can modify the behavior of the game based on the state.

Player States in C#
06:06

In this lecture, we'll add a powerup in our game that will modify the player health.

Healthkit Powerup in C#
07:04

In this lecture, we'll implement the behavior change based on the state of the player health.

State Behaviors in C#
05:06

This lecture demonstrates how we can add more powerups to the game.

More Powerups in C#
06:11

We'll add states to Player class in C++, so that we can modify the behavior of the game based on the state.

Player States in C++
05:46

In this lecture, we'll add a powerup in our game that will modify the player health.

Healthkit Powerup in C++
06:57

In this lecture, we'll implement the behavior change based on the state of the player health.

State Behaviors in C++
04:39

This lecture demonstrates how we can add more powerups to the game.

More Powerups in C++
08:21

In this lecture, you'll learn about different types of pseuodstates.

State Machine Diagram - IV
09:26

In this lecture, we'll complete the state machine diagram of player with pseudostates.

State Machine Diagram - V
05:50
+ Refactoring
7 lectures 34:17

We'll improve the design of our code through refactoring. This lecture explains the design issues and how we can improve the design through refactoring.

Design Improvements
03:30

To reduce dependency on concrete classes of powerup hierarchy, we'll implement the factory method design pattern.

Powerup Factory in Java
03:59

We'll implement the factory method design pattern for SideObject hierarchy as well.

SideObject Factory in Java
06:46

To reduce dependency on concrete classes of powerup hierarchy, we'll implement the factory method design pattern.

Powerup Factory in C#
03:59

We'll implement the factory method design pattern for SideObject hierarchy as well.

SideObject Factory in C#
05:02

To reduce dependency on concrete classes of powerup hierarchy, we'll implement the factory method design pattern.

Powerup Factory in C++
04:03

We'll implement the factory method design pattern for SideObject hierarchy as well.

SideObject Factory in C++
06:58
+ More UML Diagrams
7 lectures 36:17

Learn about how package diagram can organize modules of your application.

Package Diagram - I
04:33

This lecture concludes package diagrams with a discussion on element visibility

Package Diagram - II
07:43

Components are reusable parts of your application that may contain classes or packages. This lecture talks about the notation used in component diagram.

Component Diagram - I
06:39

This lecture discusses various notations for showing interfaces in a component diagram

Component Diagram - II
03:44

This lecture discusses more elements of component diagram, such as ports & delegation connectors.

Component Diagram - III
04:51

This lecture explains how to represent the physical entities of your software & hardware through a deployment diagram.

Deployment Diagram - I
03:44

In this video, we'll learn about artifacts.

Deployment Diagram - II
05:03