Hi my name is Zach, and I'm with Lucidchart.
Today I'll be teaching you about UML Class Diagrams.
We'll start with some of the basic characteristics.
Then we'll talk about relationships.
And we'll finish up by going through some examples together.
Alright, let’s talk about some of the basic characteristics of class diagrams.
To help explain these characteristics, I’m going to make up an example to help illustrate.
So let’s say we’re building a system for a zoo.
And, by the way, these examples I’m going to use probably wouldn’t ever find their
way into an actual program, but it’ll make all these concepts easier to understand.
So in our zoo, we’d want to describe the different things that are in the system.
You represent those things through classes, and a class is depicted with this shape here.
So what’s in a zoo?
Well there are a ton of animals.
So we could create a class for our animals.
To do that, you just write the name of the class in this top section.
If our class is Animal, an instance of that class would be a specific animal.
So the question is, how would you go about identifying each instance of that class?
You do that through attributes.
An attribute is a significant piece of data containing values that describe each instance
of that class.
They’re also known as fields, variables, or properties, and they go in the middle section here.
So for our animal class, we could create attributes like name, ID, and age.
That way we could identify a specific instance of the animal class.
Like Ruth, ID number 304, age 114.
These need to be formatted a certain way though.
You start with visibility, which we’ll talk about later. The name of the attribute beginning
with a lowercase letter.
Then you follow it with a colon and the data type.
For the name, we’d want to return a string.
And we can format the other attributes the same way, except that we’d want to return
an integer since these are numbers.
Now that we’ve got some attributes for our Animal class, we get to the bottom section here.
This is where you put methods, which are also known as operations or functions.
Methods allow you to specify any behavioral features of a class.
So we might ask ourselves, what are some different behaviors of this Animal class?
Maybe we’d want to be able to change our animals’ names.
Like Ruth should actually be called Rita.
So let’s create a function called Set Name.
We could also create a method for eating, since all of our animals eat.
Methods also need to be formatted a certain way.
You start with visibility (which we’ll talk about next), then the method beginning with
a lowercase letter.
Next you put parentheses to signify the function you’re going to program later.
You can also add variables and the data type in here, but in most cases, it’s not really necessary.
We’ll add visibility and parentheses to the eat method as well.
Now let’s talk about the visibility.
The visibility of an attribute or a method sets the accessibility for that attribute
or method.
So right now we have a minus sign for all of these, which indicates that each of these
attributes and methods are private.
They can’t be accessed by any other class or subclass.
The exact opposite is the plus sign, which means an attribute or method is public and
can be accessed by any other class.
Another visibility type is indicated by the hash,
which means an attribute or method is protected.
These can only be accessed by the same class or its subclasses.
And finally, there’s the tilde (or the squiggly as I like to call it).
This sets the visibility to package or default, which means it can be used by any other class
as long as it’s in the same package.
But that one is rarely ever used.
In most cases, your attributes are going to be Private or Protected, and methods are often Public.
Let’s quickly review these basics with another example.
Let’s make a class for Employee.
We could give an Employee attributes like name, employeeID, phone number, and department.
We’ll want all these attributes to be private.
And then we could create a simple method, like updating the phone number.
Which we’ll go ahead and set to public.
So you may have noticed that I'm using diagramming software to create these UML Class Diagrams.
The same principles apply if you're using pen and paper.
But a diagramming software makes it much easier.
The diagramming software I'm using today is Lucidchart.
And you can sign up for free by clicking on the link at the top right.
All it takes is an email address and then you'll be able to follow along as we make
these class diagrams.
So the next thing we’ll need to cover are the different relationships that exist between classes.
The first type of relationship that we’ll describe is inheritance.
And I’m gonna keep going with the zoo example because it makes it easy to understand the
logic of these relationships.
We’ll get to a more technical, real-world example later.
Okay, so inheritance.
Let’s say in our zoo, the only animals we have are tortoises, otters, and the lesser
known but nonetheless amazing slow loris.
In our system, we want to distinguish each of them as their own class.
So we make three new classes for Tortoise, Otter, and Slow Loris.
And I’ll make these a little smaller so you can see them better.
Now instead of duplicating attributes for name, ID, and age, we can make these classes
into subclasses of the animal class by drawing open arrows like this.
This is an inheritance relationship.
We’re saying that these subclasses inherit all the attributes and methods of the superclass.
You could also use the terms child and parent class.
So our Otter class is going to inherit the attributes of name, age, and ID.
And then we could add an attribute specific to Otter, like whisker length.
One of the advantages of inheritance is that if we wanted to change or add an attribute
for all animals, we wouldn’t have to go in and make that change to Tortoise, and then
Otter, and then Slow Loris.
We just make the change to the Animal class and it applies across all subclasses.
In this scenario, we also have what’s called abstraction.
Animal is an abstract class.
Because in our system, anytime we want to instantiate one of our classes, it’s going
to be a tortoise, otter, or slow loris.
We wouldn’t instantiate the animal class itself.
The animal class is just a way to simplify things and keep the code "dry"
so you don’t repeat yourself.
So to show that this is an abstract class, we’ll put the name in italics.
You could put the class name inside these things as well, but I prefer italics.
Okay another type of relationship is association.
So if we had a class for Sea Urchin we could draw an association, which is just depicted
by a simple line, between Otter and Sea Urchin.
And we could say Otter eats Sea Urchin.
There’s no dependency between them.
It’s just a basic association relationship and it’s pretty simple.
The next type of relationship is aggregation.
It’s a special type of association that specifies a whole and its parts.
So to continue with our zoo example...again, this is just to help explain the logic...let’s
create a new class for a group of tortoises.
A group of tortoises is called a creep, and that’s pretty cool.
So here’s our Creep class and it’s got a relationship with tortoise.
Any of our zoo’s tortoises could be part of a creep.
But they don’t have to be.
A tortoise could leave the creep at any point and still exist on its own.
That type of relationship, where a part can exist outside the whole, is aggregation and
we note it with an open diamond.
There’s also a relationship where the part can’t exist outside the whole.
It’s called composition.
To illustrate this, I’m going to create a few new classes.
Let’s just say we have several different visitor centers in our zoo.
And each of those visitor centers has a lobby and a bathroom.
Now if one of our visitors centers was torn down, the lobby and the bathroom of that visitor
center would be destroyed as well.
Those rooms couldn’t exist apart from the Visitor Center that they’re in.
That’s composition...when a child object wouldn’t be able to exist without its parent object.
We note a composition relationship with a closed diamond.
Another important concept when talking about relationships in UML class diagrams is multiplicity.
Multiplicity allows you to set numerical constraints on your relationships.
For example, let’s say we want to specify that our visitor centers are going to have
just one lobby.
We simply write the number one here, meaning there can be one and only one lobby per visitor center.
But for bathrooms, maybe we want to make it so that there’s at least one bathroom per
visitor center, but leave the option to have as many as you’d like.
We’d use this notation to denote one or many bathrooms.
Other types of multiplicity are zero to one, which is an optional relationship.
N, representing a specific amount, which in our example was one, but it could be any other
number depending on your use case.
Zero to many.
One to many.
Or a specific number range.
Hopefully our zoo examples have helped explain those concepts, but I want to show you what
a real world example would look like.
This is a UML class diagram for an online shopping cart, and if you want to look at
this diagram with me, just click the link in the top right corner.
You can see that this system has several classes and relationships, so let’s walk through
a couple of them.
We’ll start with the user class.
It’s got attributes for user ID, password, login status, and register date.
You’ve got the different return types on the right, and on the left, the visibility,
which are set to private.
You can see how the values returned by these attributes would specifically describe an
instance of the User class.
Down below we have a public method of verify login, returning a boolean.
And this makes sense, right?
Methods are behaviors of a class.
So if you were to log in to your user account, there’s a function in place that verifies
your login credentials.
Let’s move on to the Customer class.
This arrow tells us that Customer is a child of User.
So Customer inherits all the attributes and methods of the User class.
And same thing for the Administrator class.
Both of these inherit from User, but also have their own specific attributes and methods.
Like Administrator can update catalog, but Customer can’t.
Stemming from Customer, there are several lines with the closed-in diamond.
So if you recall, these are composition relationships which means that the parts cannot exist without
the whole.
If an instance of the Customer class, if that customer’s account was destroyed, his shopping
cart would be destroyed and his orders would be lost.
They can’t exist outside of the customer.
The same applies for Shipping Info and Order Details.
If there’s no order, there’s not going to be any order details or shipping info.
The last thing we’ll look at in this example is multiplicity.
You can see that a customer can have zero or many orders.
Makes sense, right?
You could create a customer account for an online store but never buy anything.
Or you could be a frequent customer and place several different orders.
And then on the flip side, an order can belong to only one customer.
It’d be pretty confusing if a specific order with a unique order ID was duplicated across
several different customers.
And here you can see a one-to-one relationship.
Each Order has one and only one Order Details.
And Order Details belongs to one and only one Order.
Thanks for watching this tutorial on UML Class Diagrams.
Be sure to subscribe to the channel and leave a comment below.
Lastly, don't forget to sign up for a free Lucidchart account by using this link.
And you'll be able to start making your own UML Class Diagrams in no time.