BC054

OBJECT ORIENTED SYSTEM DESIGN with

C++

UNIT 1 Introduction

SYLLABUS

Introduction: The meaning of Object Orientation, object identity,

Encapsulation, information hiding,polymorphism, generosity,
importance of modelling, principles of modelling, object-oriented
modelling, Introduction to UML, conceptual model of the UML,
Architecture.
The meaning of Object Orientation
Object-Oriented Programming or OOPs refers to languages that use objects in
programming. Object-oriented programming aims to implement real-world entities like
inheritance, hiding, polymorphism, etc in programming. The main aim of OOP is to bind
together the data and the functions that operate on them so that no other part of the code can
access this data except that function.
OOPs Concepts:
•Class
•Objects
•Data Abstraction
•Encapsulation
•Inheritance
•Polymorphism
•Dynamic Binding
•Message Passing

1. Class
A class is a user-defined data type. It consists of data members and member functions, which
can be accessed and used by creating an instance of that class. It represents the set of
properties or methods that are common to all objects of one type. A class is like a blueprint for
an object.

For Example:Consider the Class of Cars. There may be many cars with different names and
brands but all of them will share some common properties like all of them will have 4 wheels,
Speed Limit, Mileage range, etc. So here, Car is the class, and wheels, speed limits, mileage are
their properties.

2. Object
It is a basic unit of Object-Oriented Programming and represents the real-life entities. An Object
is an instance of a Class. When a class is defined, no memory is allocated but when it is
instantiated (i.e. an object is created) memory is allocated. An object has an identity, state, and
behavior. Each object contains data and code to manipulate the data. Objects can interact
without having to know details of each other’s data or code, it is sufficient to know the type of
message accepted and type of response returned by the objects.

For example “Dog” is a real-life Object, which has some characteristics like color, Breed, Bark,
Sleep, and Eats.

3. Data Abstraction
Data abstraction is one of the most essential and important features of object-oriented
programming. Data abstraction refers to providing only essential information about the data to
the outside world, hiding the background details or implementation. Consider a real-life
example of a man driving a car. The man only knows that pressing the accelerators will
increase the speed of the car or applying brakes will stop the car, but he does not know about
how on pressing the accelerator the speed is increasing, he does not know about the inner
mechanism of the car or the implementation of the accelerator, brakes, etc in the car. This is
what abstraction is.

4. Encapsulation
Encapsulation is defined as the wrapping up of data under a single unit. It is the mechanism
that binds together code and the data it manipulates. In Encapsulation, the variables or data of
a class are hidden from any other class and can be accessed only through any member
function of their class in which they are declared. As in encapsulation, the data in a class is
hidden from other classes, so it is also known as data-hiding.

Consider a real-life example of encapsulation, in a company, there are different sections like
the accounts section, finance section, sales section, etc. The finance section handles all the
financial transactions and keeps records of all the data related to finance. Similarly, the sales
section handles all the sales-related activities and keeps records of all the sales. Now there
may arise a situation when for some reason an official from the finance section needs all the
data about sales in a particular month. In this case, he is not allowed to directly access the
data of the sales section. He will first have to contact some other officer in the sales section
and then request him to give the particular data. This is what encapsulation is. Here the data of
the sales section and the employees that can manipulate them are wrapped under a single
name “sales section”.

5. Inheritance:
Inheritance is an important pillar of OOP(Object-Oriented Programming). The capability of a
class to derive properties and characteristics from another class is called Inheritance. When we
write a class, we inherit properties from other classes. So when we create a class, we do not
need to write all the properties and functions again and again, as these can be inherited from
another class that possesses it. Inheritance allows the user to reuse the code whenever
possible and reduce its redundancy.

6. Polymorphism
The word polymorphism means having many forms. In simple words, we can define
polymorphism as the ability of a message to be displayed in more than one form. For example,
A person at the same time can have different characteristics. Like a man at the same time is a
father, a husband, an employee. So the same person posses different behavior in different
situations. This is called polymorphism.

7. Dynamic Binding
In dynamic binding, the code to be executed in response to the function call is decided at
runtime. Dynamic binding means that the code associated with a given procedure call is not
known until the time of the call at run time. Dynamic Method Binding One of the main
advantages of inheritance is that some derived class D has all the members of its base class B.
Once D is not hiding any of the public members of B, then an object of D can represent B in any
context where a B could be used. This feature is known as subtype polymorphism.

8. Message Passing
It is a form of communication used in object-oriented programming as well as parallel
programming. Objects communicate with one another by sending and receiving information to
each other. A message for an object is a request for execution of a procedure and therefore will
invoke a function in the receiving object that generates the desired results. Message passing
involves specifying the name of the object, the name of the function, and the information to be
sent.

Why do we need object-oriented programming

•To make the development and maintenance of projects more effortless.
•To provide the feature of data hiding that is good for security concerns.
•We can solve real-world problems if we are using object-oriented programming.
•It ensures code reusability.
•It lets us write generic code: which will work with a range of data, so we don’t have to write
basic stuff over and over again.
Object Identity
1.Object identity: An object retains its identity even if some or all of the values of variables or definitions of
methods change over time.

This concept of object identity is necessary in applications but doe not apply to tuples of a relational database.

2.Object identity is a stronger notion of identity than typically found in programming languages or in data
models not based on object orientation.
3.Several forms of identity:
•value: A data value is used for identity (e.g., the primary key of a tuple in a relational database).
•name: A user-supplied name is used for identity (e.g., file name in a file system).
•built-in: A notion of identity is built-into the data model or programming languages, and no user-
supplied identifier is required (e.g., in OO systems).
4.Object identity is typically implemented via a unique, system-generated OID. The value of the OID is not
visible to the external user, but is used internally by the system to identify each object uniquely and to create
and manage inter-object references.
5.There are many situations where having the system generate identifiers automatically is a benefit, since it
frees humans from performing that task. However, this ability should be used with care. System-generated
identifiers are usually specific to the system, and have to be translated if data are moved to a different database
system. System-generated identifiers may be redundant if the entities being modeled already have unique
identifiers external to the system, e.g., SIN#

Encapsulation in C++ is defined as the wrapping up of data and information in a single unit. In
Object Oriented Programming, Encapsulation is defined as binding together the data and the
functions that manipulate them.

Consider a real-life example of encapsulation, in a company, there are different sections like
the accounts section, finance section, sales section, etc. Now,
•The finance section handles all the financial transactions and keeps records of all the data
related to finance.
•Similarly, the sales section handles all the sales-related activities and keeps records of all the
sales.
Now there may arise a situation when for some reason an official from the finance section
needs all the data about sales in a particular month.
In this case, he is not allowed to directly access the data of the sales section. He will first have
to contact some other officer in the sales section and then request him to give the particular
data.
This is what Encapsulation is. Here the data of the sales section and the employees that can
manipulate them are wrapped under a single name “sales section”.

Two Important property of Encapsulation

1.Data Protection: Encapsulation protects the internal state of an object by keeping its data
members private. Access to and modification of these data members is restricted to the class’s
public methods, ensuring controlled and secure data manipulation.

2.Information Hiding: Encapsulation hides the internal implementation details of a class from
external code. Only the public interface of the class is accessible, providing abstraction and
simplifying the usage of the class while allowing the internal implementation to be modified
without impacting external code.
For example if we give input , and output should be half of input
#include <iostream>
using namespace std;
class temp{
int a;
int b;
public:
int solve(int input){
a=input;
b=a/2;
return b;
}
};

int main() {
int n;
cin>>n;
temp half;
int ans=half.solve(n);
cout<<ans<<endl;

Features of Encapsulation
Below are the features of encapsulation:
1.We can not access any function from the class directly. We need an object to access that
function that is using the member variables of that class.

2.The function which we are making inside the class must use only member variables, only
then it is called encapsulation.
3.If we don’t make a function inside the class which is using the member variable of the class
then we don’t call it encapsulation.
4.Encapsulation improves readability, maintainability, and security by grouping data and
methods together.
5.It helps to control the modification of our data members.

Encapsulation also leads to data abstraction. Using encapsulation also hides the data, as in
the above example, the data of the sections like sales, finance, or accounts are hidden from
any other section.To understand how to implement encapsulation effectively in C++, check out
the C++ Course, which provides detailed explanations and examples.
Simple Example of C++:
#include <iostream>
#include <string>

using namespace std;

class Person {
private:
string name;
int age;
public:
Person(string name, int age) {
this->name = name;
this->age = age;
}
void setName(string name) {
this->name = name;
}
 string getName() {
return name;
}
void setAge(int age) {
this->age = age;
}
int getAge() {
return age;
}
};

int main() {
Person person("John Doe", 30);

cout << "Name: " << person.getName() << endl;

cout << "Age: " << person.getAge() << endl;

person.setName("Jane Doe");
person.setAge(32);

cout << "Name: " << person.getName() << endl;

cout << "Age: " << person.getAge() << endl;

return 0;
}

utput
Name: John Doe
Age: 30
Name: Jane Doe
Age: 32

In C++, encapsulation can be implemented using classes and access modifiers.

Example:
// C++ program to demonstrate
// Encapsulation
#include <iostream>
using namespace std;

class Encapsulation {
private:
// Data hidden from outside world
int x;

public:
// Function to set value of
// variable x
void set(int a) { x = a; }

// Function to return value of

// variable x
int get() { return x; }
};

// Driver code
int main()
{
Encapsulation obj;
obj.set(5);
 cout << obj.get();
return 0;
}

Output
5
Explanation: In the above program, the variable x is made private. This variable can be
accessed and manipulated only using the functions get() and set() which are present inside the
class. Thus we can say that here, the variable x and the functions get() and set() are bound
together which is nothing but encapsulation.

#include <iostream>
using namespace std;

// declaring class
class Circle {
// access modifier
private:
// Data Member
float area;
float radius;

public:
void getRadius()
{
cout << "Enter radius\n";
cin >> radius;
}
void findArea()
{
area = 3.14 * radius * radius;
cout << "Area of circle=" << area;
}
};
int main()
{
// creating instance(object) of class
Circle cir;
cir.getRadius(); // calling function
cir.findArea(); // calling function
}
Output
Enter radius
Area of circle=0
Role of Access Specifiers in Encapsulation
Access specifiers facilitate Data Hiding in C++ programs by restricting access to the class
member functions and data members. There are three types of access specifiers in C++:
•Private: Private access specifier means that the member function or data member can only
be accessed by other member functions of the same class.
•Protected: A protected access specifier means that the member function or data member
can be accessed by other member functions of the same class or by derived classes.
•Public: Public access specifier means that the member function or data member can be
accessed by any code.
By default, all data members and member functions of a class are made private by the
compiler.
 Points to Consider
As we have seen in the above example, access specifiers play an important role in
implementing encapsulation in C++. The process of implementing encapsulation can be sub-
divided into two steps:
1.Creating a class to encapsulate all the data and methods into a single unit.
2.Hiding relevant data using access specifiers.

What is Data hiding?

Data hiding is a technique of hiding internal object details, i.e., data members. It is an object-oriented programming
technique. Data hiding ensures, or we can say guarantees to restrict the data access to class members. It maintains data
integrity.

Data hiding means hiding the internal data within the class to prevent its direct access from outside the class.

If we talk about data encapsulation so, Data encapsulation hides the private methods and class data parts,
whereas Data hiding only hides class data components. Both data hiding and data encapsulation are essential concepts
of object-oriented programming. Encapsulation wraps up the complex data to present a simpler view to the user,
whereas Data hiding restricts the data use to assure data security.

Data hiding also helps to reduce the system complexity to increase the robustness by limiting the interdependencies
between software components. Data hiding is achieved by using the private access specifier.

Example: We can understand data hiding with an example. Suppose we declared an Account class with a data
member balance inside it. Here, the account balance is sensitive information. We may allow someone to check the
account balance but won't allow altering the balance attribute. So, by declaring the balance attribute private, we can
restrict the access to balance from an outside application.

Now, let's discuss the access specifiers to understand the data hiding. Access specifiers define how the member's
functions and variables can be accessed from outside the class. So, there are three access specifiers available within a
class that are stated as follows:

Private members/methods: Functions and variables declared as private can be accessed only within the same class,
and they cannot be accessed outside the class they are declared.

Public members/methods: Functions and variables declared under public can be accessed from anywhere.

Protected members/methods: Functions and variables declared as protected cannot be accessed outside the class
except a child class. This specifier is generally used in inheritance.

Now let's see an example of data hiding in C++.

Example
In this example, there is a class with a variable and two functions. Here, the variable "num" is private so, it can be
accessed only by the members of the same class, and it can't be accessed anywhere else. Hence, it is unable to access
this variable outside the class, which is called data hiding.

1. #include<iostream>
2. using namespace std;
3. class Base{
4.
5. int num; //by default private
6. public:
7.
8. void getData();
9. void showData();
10.
11. };
12. void Base :: getData()
13. {
14. cout<< "Enter any Integer value" <<endl;
15. cin>>num;
16.
17. }
18. void Base :: showData()
19. {
20. cout<< "The value is " << num <<endl;
21. }
22.
23. int main(){
24. Base obj;
25. obj.getData();
26. obj.showData();
27. return 0;
28. }
Output

Enter any Integer value

2
The value is 2
Now, you would have understood the data hiding and how to implement it in C++

The word “polymorphism” means having many forms. In simple words, we can define polymorphism as the ability of a
message to be displayed in more than one form. A
real-life example of polymorphism is a person
who at the same time can have different
characteristics. A man at the same time is a father,
a husband, and an employee. So the same person
exhibits different behavior in different situations.
This is called polymorphism. Polymorphism is
considered one of the important features of
Object-Oriented Programming.

Types of Polymorphism
•Compile-time Polymorphism
•Runtime Polymorphism

To master polymorphism and other OOP principles, our Complete C++ Course offers in-depth tutorials on advanced
object-oriented concepts.
1. Compile-Time Polymorphism
This type of polymorphism is achieved by function overloading or operator overloading.
A. Function Overloading
When there are multiple functions with the same name but different parameters, then the functions are said to
be overloaded, hence this is known as Function Overloading. Functions can be overloaded by changing the number of
arguments or/and changing the type of arguments. In simple terms, it is a feature of object-oriented programming
providing many functions that have the same name but distinct parameters when numerous tasks are listed under one
function name. There are certain Rules of Function Overloading that should be followed while overloading a function.
Below is the C++ program to show function overloading or compile-time polymorphism:

// C++ program to demonstrate

// function overloading or
// Compile-time Polymorphism
#include <bits/stdc++.h>

using namespace std;

class Geeks {
public:
// Function with 1 int parameter
void func(int x)
{
cout << "value of x is " << x << endl;
}

// Function with same name but

// 1 double parameter
void func(double x)
{
cout << "value of x is " << x << endl;
}

// Function with same name and

// 2 int parameters
void func(int x, int y)
{
cout << "value of x and y is " << x << ", " << y
<< endl;
}
};

// Driver code
int main()
{
Geeks obj1;

// Function being called depends

// on the parameters passed
// func() is called with int value
obj1.func(7);

// func() is called with double value

obj1.func(9.132);

// func() is called with 2 int values

obj1.func(85, 64);
return 0;
}

Output
value of x is 7
value of x is 9.132
value of x and y is 85, 64
Explanation: In the above example, a single function named function func() acts differently in
three different situations, which is a property of polymorphism. To know more about this, you
can refer to the article – Function Overloading in C++.
B. Operator Overloading
C++ has the ability to provide the operators with a special meaning for a data type, this ability
is known as operator overloading. For example, we can make use of the addition operator (+)
for string class to concatenate two strings. We know that the task of this operator is to add two
operands. So a single operator ‘+’, when placed between integer operands, adds them and
when placed between string operands, concatenates them.
Below is the C++ program to demonstrate operator overloading:
// C++ program to demonstrate
// Operator Overloading or
// Compile-Time Polymorphism
#include <iostream>
using namespace std;

class Complex {
private:
int real, imag;

public:
Complex(int r = 0, int i = 0)
{
real = r;
imag = i;
}

// This is automatically called

// when '+' is used with between
// two Complex objects
Complex operator+(Complex const& obj)
{
Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}
void print() { cout << real << " + i" << imag << endl; }
};

// Driver code
int main()
{
Complex c1(10, 5), c2(2, 4);

// An example call to "operator+"

Complex c3 = c1 + c2;
c3.print();
}

Output
12 + i9
Explanation: In the above example, the operator ‘+’ is overloaded. Usually, this operator is
used to add two numbers (integers or floating point numbers), but here the operator is made to
perform the addition of two imaginary or complex numbers. To know more about this one, refer
to the article – Operator Overloading.
2. Runtime Polymorphism
This type of polymorphism is achieved by Function Overriding. Late binding and dynamic
polymorphism are other names for runtime polymorphism. The function call is resolved at
runtime in runtime polymorphism. In contrast, with compile time polymorphism, the
compiler determines which function call to bind to the object after deducing it at runtime.
A. Function Overriding
Function Overriding occurs when a derived class has a definition for one of the member
functions of the base class. That base function is said to be overridden.

Function overriding Explanation

Runtime Polymorphism with Data Members

Runtime Polymorphism cannot be achieved by data members in C++. Let’s see an example
where we are accessing the field by reference variable of parent class which refers to the
instance of the derived class.
// C++ program for function overriding with data members
#include <bits/stdc++.h>
using namespace std;

// base class declaration.

class Animal {
public:
string color = "Black";
};

// inheriting Animal class.

class Dog : public Animal {
public:
string color = "Grey";
};

// Driver code
int main(void)
{
Animal d = Dog(); // accessing the field by reference
// variable which refers to derived
cout << d.color;
}
Output
Black
We can see that the parent class reference will always refer to the data member of the parent
class.
B. Virtual Function
A virtual function is a member function that is declared in the base class using the keyword
virtual and is re-defined (Overridden) in the derived class.
Some Key Points About Virtual Functions:
•Virtual functions are Dynamic in nature.
•They are defined by inserting the keyword “virtual” inside a base class and are always
declared with a base class and overridden in a child class
•A virtual function is called during Runtime
Below is the C++ program to demonstrate virtual function:

// C++ Program to demonstrate

// the Virtual Function
#include <iostream>
using namespace std;

// Declaring a Base class

class GFG_Base {

public:
 // virtual function
virtual void display()
{
cout << "Called virtual Base Class function"
<< "\n\n";
}

void print()
{
cout << "Called GFG_Base print function"
<< "\n\n";
}
};

// Declaring a Child Class

class GFG_Child : public GFG_Base {

public:
void display()
{
cout << "Called GFG_Child Display Function"
<< "\n\n";
}

void print()
{
cout << "Called GFG_Child print Function"
<< "\n\n";
}
};

int main()
{
// Create a reference of class GFG_Base
GFG_Base* base;

GFG_Child child;

base = &child;

// This will call the virtual function

base->display();

// This will call the non-virtual function

base->print();
}
Output
Called GFG_Child Display Function

Called GFG_Base print function

Example 2:

// C++ program for virtual function overriding

#include <bits/stdc++.h>
using namespace std;

class base {
public:
virtual void print()
{
 cout << "print base class" << endl;
}

void show() { cout << "show base class" << endl; }

};

class derived : public base {

public:
// print () is already virtual function in
// derived class, we could also declared as
// virtual void print () explicitly
void print() { cout << "print derived class" << endl; }

void show() { cout << "show derived class" << endl; }

};

// Driver code
int main()
{
base* bptr;
derived d;
bptr = &d;

// Virtual function, binded at

// runtime (Runtime polymorphism)
bptr->print();

// Non-virtual function, binded

// at compile time
bptr->show();

return 0;
}
Output
print derived class
show base class

generosity in c++

Importance of modelling in oops

Intention of object oriented modeling and design is to learn how to apply object -oriented
concepts to all the stages of the software development life cycle.Object-oriented modeling and
design is a way of thinking about problems using models organized around real world concepts.
The fundamental construct is the object, which combines both data structure and behavior.

Purpose of Models:
1.Testing a physical entity before building it
2.Communication with customers
3.Visualization
4.Reduction of complexity
Types of Models:
There are 3 types of models in the object oriented modeling and design are: Class Model, State
Model, and Interaction Model. These are explained as following below.
1.Class Model:
The class model shows all the classes present in the system. The class model shows the
attributes and the behavior associated with the objects.
The class diagram is used to show the class model.The class diagram shows the class name
followed by the attributes followed by the functions or the methods that are associated with
the object of the class.Goal in constructing class model is to capture those concepts from
the real world that are important to an application.

2.State Model:
State model describes those aspects of objects concerned with time and the sequencing of
operations – events that mark changes, states that define the context for events, and the
organization of events and states.Actions and events in a state diagram become operations on
objects in the class model. State diagram describes the state model.

3.Interaction Model:
Interaction model is used to show the various interactions between objects, how the objects
collaborate to achieve the behavior of the system as a whole.
The following diagrams are used to show the interaction model:
•Use Case Diagram
•Sequence Diagram
•Activity Diagram

*principles of
modelling*
* object-oriented
modelling*
What is UML?
Unified Modeling Language (UML) is a standardized visual modeling language that is a
versatile, flexible, and user-friendly method for visualizing a system’s design. Software system
artifacts can be specified, visualized, built, and documented with the use of UML.
•We use UML diagrams to show the behavior and structure of a system.
•UML helps software engineers, businessmen, and system architects with modeling, design,
and analysis.
The International Organization for Standardization (ISO) published UML as an approved
standard in 2005. UML has been revised over the years and is reviewed periodically.
2. Why do we need UML?
We need UML (Unified Modeling Language) to visually represent and communicate complex
system designs, facilitating better understanding and collaboration among stakeholders. Below
is why we need UML:
•Complex applications need collaboration and planning from multiple teams and hence require
a clear and concise way to communicate amongst them.
•Businessmen do not understand code. So UML becomes essential to communicate with non-
programmers about essential requirements, functionalities, and processes of the system.
•A lot of time is saved down the line
when teams can visualize
processes, user interactions, and
the static structure of the system.
3. Types of UML Diagrams
UML is linked with object-oriented
design and analysis. UML makes
use of elements and forms
associations between them to form
diagrams. Diagrams in UML can be
broadly classified as:

4. Structural UML Diagrams

Structural UML diagrams are visual representations that depict the static aspects of a system,
including its classes, objects, components, and their relationships, providing a clear view of the
system’s architecture. Structural UML diagrams include the following types:
4.1. Class Diagram
The most widely use UML diagram
is the class diagram. It is the
building block of all object oriented
software systems. We use class
diagrams to depict the static
structure of a system by showing
system’s classes, their methods and
attributes. Class diagrams also help
us identify relationship between
different classes or objects.
4.2. Composite Structure Diagram
We use composite structure diagrams to represent the internal structure of a class and its
interaction points with other parts of the system.
•A composite structure diagram represents relationship between parts and their configuration
which determine how the classifier (class, a component, or a deployment node) behaves.
•They represent internal structure of a structured classifier making the use of parts, ports, and
connectors.
•We can also model collaborations using composite structure diagrams.
•They are similar to class diagrams except they represent individual parts in detail as compared
to the entire class.
4.3. Object Diagram
An Object Diagram can be referred to as a
screenshot of the instances in a system
and the relationship that exists between
them. Since object diagrams depict
behaviour when objects have been
instantiated, we are able to study the
behaviour of the system at a particular
instant.
•An object diagram is similar to a class
diagram except it shows the instances of
classes in the system.
•We depict actual classifiers and their
relationships making the use of class diagrams.
•On the other hand, an Object Diagram represents specific instances of classes and
relationships between them at a point of time.

4.4. Component Diagram

Component diagrams are used to represent how the physical
components in a system have been organized. We use them for
modelling implementation details.
•Component Diagrams depict the structural relationship between
software system elements and help us in understanding if functional
requirements have been covered by planned development.
•Component Diagrams become essential to use when we design and
build complex systems.
•Interfaces are used by components of the system to communicate with each other.

4.5. Deployment Diagram

Deployment Diagrams are used to
represent system hardware and its
software. It tells us what hardware
components exist and what
software components run on them.
•We illustrate system architecture as distribution of software artifacts over distributed targets.
•An artifact is the information that is generated by system software.
•They are primarily used when a software is being used, distributed or deployed over multiple
machines with different configurations.
4.6. Package Diagram
We use Package Diagrams to depict
how packages and their elements
have been organized. A package
diagram simply shows us the
dependencies between different
packages and internal composition of
packages.
•Packages help us to organise UML
diagrams into meaningful groups and
make the diagram easy to
understand.
•They are primarily used to organise class and use case diagrams.
5. Behavioral UML Diagrams
Behavioral UML diagrams are visual representations that depict the dynamic aspects of a
system, illustrating how objects interact and behave over time in response to events.
5.1. State Machine Diagrams
A state diagram is used to represent the condition of the system or part of the system at finite
instances of time. It’s a behavioral diagram and it represents the behavior using finite state
transitions.
•State diagrams are also referred to as State machines and State-chart Diagrams
•These terms are
often used
interchangeably.
So simply, a
state diagram is
used to model
the dynamic
behavior of a
class in response
to time and changing external stimuli.

5.2. Activity Diagrams

We use Activity Diagrams to illustrate the
flow of control in a system. We can also use
an activity diagram to refer to the steps
involved in the execution of a use case.
•We model sequential and concurrent
activities using activity diagrams. So, we
basically depict workflows visually using an
activity diagram.
•An activity diagram focuses on condition of flow and the sequence in which it happens.
•We describe or depict what causes a particular event using an activity diagram.

5.3. Use Case Diagrams

Use Case Diagrams are used to
depict the functionality of a
system or a part of a system.
They are widely used to illustrate
the functional requirements of the
system and its interaction with
external agents(actors).
•A use case is basically a diagram
representing different scenarios
where the system can be used.
•A use case diagram gives us a high level view of what the system or a part of the system does
without going into implementation details. ‘

5.4. Sequence Diagram

A sequence diagram simply depicts
interaction between objects in a
sequential order i.e. the order in which
these interactions take place.
•We can also use the terms event
diagrams or event scenarios to refer to
a sequence diagram.
•Sequence diagrams describe how and
in what order the objects in a system
function.
•These diagrams are widely used by
businessmen and software developers
to document and understand
requirements for new and existing
systems.
5.5. Communication Diagram
A Communication Diagram (known as
Collaboration Diagram in UML 1.x) is
used to show sequenced messages
exchanged between objects.
•A communication diagram focuses
primarily on objects and their
relationships.
•We can represent similar information using Sequence diagrams, however communication
diagrams represent objects and links in a free form.
5.6. Timing Diagram
Timing Diagram are a special form of Sequence diagrams which are used to depict the behavior
of objects over a time frame. We use them to show time and duration constraints which govern
changes in states and behavior of objects.
5.7. Interaction Overview Diagram
An Interaction Overview Diagram (IOD) is a type
of UML (Unified Modeling Language) diagram
that illustrates the flow of interactions between
various elements in a system or process. It
provides a high-level overview of how
interactions occur, including the sequence of
actions, decisions, and interactions between
different components or objects.

6. Object-Oriented Concepts Used in UML Diagrams

Examples of object-oriented concepts in UML diagrams include classes, objects, inheritance,
abstraction, encapsulation, and polymorphism. These concepts improve modularity and clarity
by offering an orderly way to show complex systems.
•Class: An object’s structure and behavior are defined by its class, which serves as a blueprint.
•Objects: We may divide complex systems into smaller, more manageable components by
using objects. Because of its modularity, we can concentrate on easily understood components
and develop the system gradually.
•Inheritance: Child classes can inherit the characteristics and functions of their parent classes.
•Abstraction: The main characteristics of a system or object are highlighted in UML
abstraction, while extraneous details are ignored. Stakeholder communication and
understanding are improved by this simplification.
•Encapsulation: Encapsulation is the process of integrating data and restricting external
access in order to maintain the integrity of the data.
•Polymorphism: Flexibility in their use is made possible by polymorphism, the capacity of
functions or entities to take on multiple forms.
6.1. Additions in UML 2.0
•Software development methodologies like agile have been incorporated and scope of original
UML specification has been broadened.
•Originally UML specified 9 diagrams. UML 2.x has increased the number of diagrams from 9 to
13. The four diagrams that were added are : timing diagram, communication diagram,
interaction overview diagram and composite structure diagram. UML 2.x renamed statechart
diagrams to state machine diagrams.
•UML 2.x added the ability to decompose software system into components and sub-
components.
7. Tools for creating UML Diagrams
There are several tools available for creating Unified Modeling Language (UML) diagrams, which
are commonly used in software development to visually represent system architecture, design,
and implementation. Here are some popular UML diagram creating tools:
•Lucidchart: Lucidchart is a web-based diagramming tool that supports UML diagrams. It’s
user-friendly and collaborative, allowing multiple users to work on diagrams in real-time.
•Draw.io: Draw.io is a free, web-based diagramming tool that supports various diagram types,
including UML. It integrates with various cloud storage services and can be used offline.
•Visual Paradigm: Visual Paradigm provides a comprehensive suite of tools for software
development, including UML diagramming. It offers both online and desktop versions and
supports a wide range of UML diagrams.
•StarUML: StarUML is an open-source UML modeling tool with a user-friendly interface. It
supports the standard UML 2.x diagrams and allows users to customize and extend its
functionality through plugins.
8. Steps to create UML Diagrams

Creating Unified Modeling Language (UML) diagrams involves a systematic process that
typically includes the following steps:
•Step 1: Identify the
Purpose:
Decide on the
objective for which the
UML diagram is being
made. Among the
many applications for
the many types of
UML diagrams are
requirements
collection, system architecture development, and class relationship documentation.
•Step 2: Identify Elements and Relationships:
Choose which crucial elements—classes, objects, use cases, etc.—should be included
in the diagram, along with their relationships.
•Step 3: Select the Appropriate UML Diagram Type:
Select the type of UML diagram that best suits your modeling requirements. Class
diagrams, use case diagrams, sequence diagrams, activity diagrams, and more are
examples of common forms.
•Step 4: Create a Rough Sketch:
A basic sketch on paper or a whiteboard can be useful before utilizing a UML modeling
tool. This can assist you in seeing how the elements are arranged and related to one
another.
•Step 5: Choose a UML Modeling Tool:
Choose a UML modeling tool based on your needs. Numerous offline and online
applications are available with features for making and modifying UML diagrams.
•Step 6: Create the Diagram:
Create a new project or diagram using the UML modeling tool of your choice. Start by
adding components to the diagram, such as actors, classes, and use cases, and then
link them together with the proper relationships, such as dependencies and
associations.
•Step 7: Define Element Properties:
Give each diagram element the appropriate qualities and attributes. Use case
specifics, class characteristics and methods, and any other information unique to the
diagram type may be included.
•Step 8: Add Annotations and Comments:
By using annotations, remarks, and clarifying notes, you can improve the diagram’s
readability.
•Step 9: Validate and Review:
Check the diagram for completeness and accuracy. Make that the elements,
limitations, and linkages appropriately depict the system or process that is intended.
•Step 10: Refine and Iterate:
Refine the diagram based on feedback and additional insights. UML diagrams are often
created iteratively as the understanding of the system evolves.
Note: Remember that the specific steps may vary based on the UML diagram type and the
tool you are using.
9. UML Diagrams Best Practices
System design can be visually represented and documented with the help of the Unified
Modeling Language (UML). Best practices must be followed in order to produce UML diagrams
that are both useful and significant. UML best practices include the following:
•Understand the Audience: Consider who will view your UML diagrams as you create them.
Whether your audience consists of developers, architects, or stakeholders, make sure the type
and degree of detail of the diagram meet their needs.
•Keep Diagrams Simple and Focused: Make sure your diagrams are as simple as possible.
Each one need to draw attention to a certain aspect of the system or illustrate a particular link.
•Use Consistent Naming Conventions: Use clear and consistent names for classes, objects,
attributes, and methods. Good naming helps everyone understand the diagrams better.
•Follow Standard UML Notations: Stick to standard UML symbols and notations. This
consistency makes it easier for anyone familiar with UML to understand your diagrams.
•Keep Relationships Explicit: Clearly define and label how different elements are connected.
Use the right arrows and notations to show the nature of relationships between classes,
objects, or use cases.
10. When to Use UML Diagrams
Use UML Diagrams:
•When a system’s general structure needs to be represented, UML diagrams can help make it
clearer how various parts work together, which facilitates idea sharing between stakeholders.
•When collecting and recording system requirements, UML diagrams, such as use case
diagrams, can help you clearly grasp user demands by showing how users will interact with the
system.
•If you’re involved in database design, class diagrams are great for illustrating the relationships
among various data entities, ensuring your data model is well-organized.
•When working with team members or clients, UML diagrams act as a shared language that
connects technical and non-technical stakeholders, improving overall understanding and
alignment.
11. UML and Agile Development
Although Agile development and UML (Unified Modeling Language) are two distinct approaches
to software development, they can work well together. This is how they are related:
11.1. UML in Agile Development
•Visual Communication: System behavior and design are demonstrated with the help of UML
diagrams. Agile emphasizes the need of clear communication, and these diagrams help all
parties involved—team members, stakeholders, and even non-technical individuals—
understand what is happening.
•Capturing User Stories: Use case diagrams in UML can help capture user stories, showing
how users will interact with the system. This helps everyone understand the user’s perspective
better.
•Building in Steps: Agile development is all about working in small steps, and UML can adapt
to this by allowing models to be created and updated as the project evolves.
•Simplifying Requirements: Techniques like user story mapping can go hand-in-hand with
UML, making it easier to visualize what needs to be done without overwhelming
documentation.
11.2. Balancing Modeling with Agility
•Smart Modeling: Use UML as much as needed to help with communication, focusing on
delivering useful software rather than getting bogged down in paperwork.
•Empowering the Team: Give the team the freedom to decide how much modeling is
necessary. They should feel comfortable using UML without feeling pressured to create too
many diagrams
12. Common Challenges in UML Modeling
Below are the common challenges in UML Modeling:
•Accurately representing complex system requirements can be difficult, leading to either
oversimplification or overwhelming detail.
•Team members may interpret the model differently, resulting in inconsistencies and
misunderstandings about its purpose.
•Keeping UML diagrams current as the system evolves can be time-consuming, risking outdated
representations if not managed effectively.
•Agile promotes teamwork, but sometimes UML diagrams are complicated and only a few
people understand them. It can be hard to make sure everyone can contribute to and use the
diagrams effectively.
13. Benefits of Using UML Diagrams
Below are the benefits of using UML Diagrams:
•Developers and stakeholders may communicate using a single visual language thanks to
UML’s standardized approach to system model representation.
•Developers, designers, testers, and business users are just a few of the stakeholders with
whom UML diagrams may effectively communicate.
•UML diagrams make it easier to see the linkages, processes, and parts of a system.
•One useful tool for documentation is a UML diagram. They offer an ordered and systematic
method for recording a system’s behavior, architecture, and design, among other elements.
•

Conceptual model of the UML

The Unified Modeling
Language (UML)

is a standard visual language for

describing and modelling software
blueprints. The UML is more than
just a graphical language. Stated
formally, the UML is for:
Visualizing, Specifying,
Constructing, and Documenting.
The artifacts of a software-
intensive system (particularly
systems built using the object-
oriented style).
Understanding UML is essential
for system architects and developers. It aids in visualizing the architecture and design of
complex systems. To explore more about system design and the role of UML in software
development, consider the System Design Course, which covers UML diagrams and their
applications in various design scenarios.
Three Aspects of UML:

Figure –
Three Aspects of UML
Note –
Language, Model, and Unified are the important aspect of UML as described in the map above.
1. Language:
•It enables us to communicate about a subject which includes the requirements and the
system.
•It is difficult to communicate and collaborate for a team to successfully develop a system
without a language.
2. Model:
•It is a representation of a subject.
•It captures a set of ideas (known as abstractions) about its subject.
3. Unified:
•It is to bring together the
information systems and technology
industry’s best engineering
practices.
•These practices involve applying
techniques that allow us to
successfully develop systems.
A Conceptual Model:
A conceptual model of the language underlines the three major elements:
• The Building Blocks
• The Rules
• Some Common Mechanisms
Once you understand these elements, you will be able to read and recognize the models as
well as create some of them.

Figure –
A Conceptual Model of the UML
Building Blocks:
The vocabulary of the UML encompasses three kinds of building blocks:
1.Things: Things are the abstractions that are first-class citizens in a model; relationships tie
these things together; diagrams group interesting collections of things. There are 4 kinds of
things in the UML:
1. Structural things
2. Behavioral things
3. Grouping things
4. Annotational things
These things are the basic object-oriented building blocks of the UML. You use them to write
well-formed models.

2.Relationships: There are 4 kinds of relationships in the UML:

1. Dependency
2. Association
3. Generalization
4. Realization
These relationships are the basic relational building blocks of the UML.

3.Diagrams: It is the graphical presentation of a set of elements. It is rendered as a connected

graph of vertices (things) and arcs (relationships).
1.Class diagram
2.Object diagram
3.Use case diagram
4.Sequence diagram
5.Collaboration diagram
6.Statechart diagram
7.Activity diagram
8. Component diagram
9. Deployment diagram
Rules:
The UML has a number of rules that specify what a well-formed model should look like. A well-
formed model is one that is semantically self-consistent and in harmony with all its related
models. The UML has semantic rules for:
1.Names – What you can call things, relationships, and diagrams.
2.Scope – The context that gives specific meaning to a name.
3.Visibility – How those names can be seen and used by others.
4.Integrity – How things properly and consistently relate to one another.
5.Execution – What it means to run or simulate a dynamic model.
Common Mechanisms:
The UML is made simpler by the four common mechanisms. They are as follows:
1. Specifications
2. Adornments
3. Common divisions
4. Extensibility mechanisms

UML- Architecture
Software architecture is all about how a software system is built at its highest level. It is needed
to think big from multiple perspectives with quality and design in mind. The software team is
tied to many practical concerns, such as:

•The structure of the development team.

•The needs of the business.
•Development cycle.
•The intent of the structure itself.
Software architecture provides a basic design of a complete software system. It defines the
elements included in the system, the functions each element has, and how each element
relates to one another. In short, it is a big picture or overall structure of the whole system, how
everything works together.

To form an architecture, the software architect will take several factors into consideration:

•What will the system be used for?

•Who will be using the system?
•What quality matters to them?
•Where will the system run?
The architect plans the structure of the system to meet the needs like these. It is essential to
have proper software architecture, mainly for a large software system. Having a clear design of
a complete system as a starting point provides a solid basis for developers to follow.

Each developer will know what needs to be implemented and how things relate to meet the
desired needs efficiently. One of the main advantages of software architecture is that it
provides high productivity to the software team. The software development becomes more
effective as it comes up with an explained structure in place to coordinate work, implement
individual features, or ground discussions on potential issues. With a lucid architecture, it is
easier to know where the key responsibilities are residing in the system and where to make
changes to add new requirements or simply fixing the failures.

In addition, a clear architecture will help to achieve quality in the software with a well-designed
structure using principles like separation of concerns; the system becomes easier to maintain,
reuse, and adapt. The software architecture is useful to people such as software developers,
the project manager, the client, and the end-user. Each one will have different perspectives to
view the system and will bring different agendas to a project. Also, it provides a collection of
several views. It can be best understood as a collection of five views:
Use case view

•It is a view that shows the functionality of the system as perceived by external actors.
•It reveals the requirements of the system.
•With UML, it is easy to capture the static aspects of this view in the use case diagrams,
whereas it?s dynamic aspects are captured in interaction diagrams, state chart
diagrams, and activity diagrams.

Design View

•It is a view that shows how the functionality is designed inside the system in terms of
static structure and dynamic behavior.
•It captures the vocabulary of the problem space and solution space.
•With UML, it represents the static aspects of this view in class and object diagrams,
whereas its dynamic aspects are captured in interaction diagrams, state chart diagrams,
and activity diagrams.

Implementation View

•It is the view that represents the organization of the core components and files.
•It primarily addresses the configuration management of the system?s releases.
•With UML, its static aspects are expressed in component diagrams, and the dynamic
aspects are captured in interaction diagrams, state chart diagrams, and activity
diagrams.

Process View

•It is the view that demonstrates the concurrency of the system.

 •It incorporates the threads and processes that make concurrent system and
synchronized mechanisms.
•It primarily addresses the system's scalability, throughput, and performance.
•Its static and dynamic aspects are expressed the same way as the design view but
focus more on the active classes that represent these threads and processes.

Deployment View

•It is the view that shows the deployment of the system in terms of physical
architecture.
•It includes the nodes, which form the system hardware topology where the system will
be executed.
•It primarily addresses the distribution, delivery, and installation of the parts that build
the physical system.