Class Diagram Video Lecture | Embedded Systems (Web) - Computer Science Engineering (CSE)

In this session we will try to understand what are basically class diagrams.We will try to understand fundamentals of it
Will try to see
different types of classes like Abstract class or interfaces. How can they be represented using class diagrams
See the same how we can implement them into the technical documents
Class diagrams basically
form one of the very basic
entities for technical documents
As I said previously some of the diagrams are compulsory
and very much needed
to describe
any technical architecture
Like one of the diagram which we discussed previously was a Use Case diagram
which is very building block
to
gather requirements
In the same way class diagrams are basically very useful
to understand the static part of a project
When we look at any technical architecture design
There are two ways of viewing it
One is the dynamic part of the project
and one is the static part of the project
or the static architecture of a project and the dynamic architecture of a project
To give a better understanding of the static architecture and dynamic architecture
we will try to map the same with the real example
When any civil engineer builds up a architecture
he can
define the static architecture saying this will be the pillars, this will be the beam, this will be the
rooms, the sizes, the lengths etc
What happens if people start living inside it
and then people start
staying inside the building or they start
travelling over the bridge or whatever kind of design
for which it is made for
In the sense that is a dynamic part of the project
When actually it comes into creation
One is a static architecture of a project and one we can say dynamic architecture of a project
Both of these
views are very important when we write a technical documen
If you have already done object oriented programming you don't need to look into this
In case not we will revise the basic definitions. It is basically prototype which help us to create objects
Its like a data type
and by using the data type we can create a objects
As I said previously they define the static part of a project
and from that blue print objects are created
In UML
the UML notation to define a class diagram basically by
defining a simple rectangle as I shown
in the above video
And then dividing this rectangle into three parts
The first part is where you define the class name
of
the class name. For example like here the class is clscustomer. I'll define it as clscustomer
That is the class name for the
class
what you are trying to defining
using class diagrams
The second
section consists of properties for the classes
I have two properties here
CustomerCode and CustomerName
Also I can define the data type
The third one
has the method names
I have a add customer here
and the add customer returns a boolean value
There are three sections, the top most section is represents a class name
second section represent the attributes
and third section represents the method
Whenever you draw the class diagram in your document or whenever you try to express your class diagram in your design document this is the UML way of notation or UML way of defining the class diagram by the three sections
The other important part in class diagrams are basically how are the entities like either the properties or the methods expose to the external world
That represents by using
the + sign
the #
and the - sign
+ sign indicates that any client who creates a object of this class like clscustomer which I have shown in the current example
will be able to see the customer code method
He will be able to see the customer code property
and
the add customer method
Because they are public methods
The + sign indicates that the property or the method is public
The # sign indicates that its a protected property means
the classes which inherit the clscustomers
will only be able to view those properties and the methods
It is protected
You can only see these properties and methods when you are inheriting the class
The protected methods and properties are only viewed in the inheritance change
The final
property
Now we have understood the fundamentals of how to represent a class diagram in UML
by using the three sections where we defined in the first section the
class name the second section the property and the third section
the method name
How do we represent these entities i.e a properties
the methods
as public, private or protected
In order to
express these methods or express there
visibility outside the class to the client world
we use some notations
For instance
a + notation before
the
property or before the method name
indicates that this is a public method
or this is a public property
If any client creates a object of
the clscustomer
he will be able to call the customer code property
or he will be able to set or get the customer code property depending on how the property expose
or he will be able to call the add customer method
The - sign
before the property or the method indicates that this is a private
entity
or this is a private property or a private method
Clients who creates objects of clscustomer
will not be able to view
the net profit property
It is encapsulated
and it is protected from the outside world
The in between property i.e
in between visibility is
called as a protected visibility
The protected visibility
is defined by using the #
symbol
If you define
the property or the method using the # symbol
it can only be viewed
by classes who inherit
from these classes
If I want to use the discount
property
then I need to inherit from clscustomer then only i will be able to view the discount property
or else I won't be able to view the discount property
If you want to ensure that you want to
make visible your entity and the methods
only in the inheritance hierarchy
or only through the generalization specialization relationship
At those moments only you will use a protective property
The + indicates the public property
The - indicates that its a private property or a private method depending on where you show the notation in the class diagram
and the # indicates a protective property
That means only the inherited classes or the child classes who inherit from this class can access the
protective property
A single class cannot represent the whole module in a project
If its a customer maintenance project
then only customer class own do
Its possible that the customer interact with the invoice
or customer interact with the printer object
One of the important thing is
a single class cannot represent the whole module in a project
For example we have defined the customer class
definitely the customer class has to interact with other classes
to fulfill the functionality
Its possible that
In the video I have shown order class which interacts with the payment class
to achieve the full functionality saying that
once you place the order
it will us the payment class to do the payment
A class itself cannot represent the system
Its basically the interaction between these classes represents a system
When you design your technical document and you write your technical document
you will need to show interaction between the classes
And this interaction in UML will show by using the arrow key