Object Oriented Analysis, Design & Programming with UML

Learn & understand why software is complex.

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

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.

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

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

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

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

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

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

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

You'll understand how to represent relationships between use cases

You'll create relationship between use cases in StarUML

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

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

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

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

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

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.

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

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

You'll understand the basics of Abstraction.

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

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

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

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

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

Learn how to initialize an object using a constructor.

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

Learn how to initialize an object using a constructor.

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

Learn how to initialize an object using a constructor.

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

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

Learn how to use inheritance in Java.

Learn how to use inheritance in C#.

Learn how to use inheritance in C++.

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

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

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

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

This video explains implementation of polymorphism in Java.

This video explains implementation of polymorphism in C#.

This video explains implementation of polymorphism in C++.

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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.

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.

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

This lecture finishes off the creation of sequence diagram in StarUML

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.

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

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

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

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

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

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

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

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

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

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

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

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

State machine diagram files.

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

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

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

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

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

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

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

Learn how to draw a state machine diagram in StarUML.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

This lecture concludes package diagrams with a discussion on element visibility

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

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

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

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

In this video, we'll learn about artifacts.