So in the previous set of videos we had a discussion about and
learned about inheritance.
It's time now to talk about composition.
Composition is another component of object orientated programming and
is very useful in day to day programming, but just as a refresher, I'm gonna start
off and just go over inheritance very briefly before we move into composition.
Best way to do that would be in examples.
So let's create two quick classes.
First ones going to be vehicle.
And vehicle is going to be very simple, it's gonna have one field.
Private String name and it's gonna have a constructor.
Pretty simple, concept of the vehicle.
Let's also create another class, call it Car.
We're going to stem from vehicle and add a couple of fields.
So the number of doors, private int, engine capacity.
set up a constructor and there we go.
Very simple little example.
So, the car stems from vehicle.
It's got a Isa relationship with vehicle.
Isa meaning that a car is a vehicle, so that's the relationship between the two.
So you can quite correctly say the car is a vehicle and
that's essentially what inherency is.
The composition deals with something different, and
that deals with a relationship.
And the best way to do this is to go through an example, so
let's look at the scenario of a computer.
So a computer has a motherboard, a case, and
a monitor, three example things that it's got with it.
So the motherboard, the case, and the monitor And not computers
in the same sense that a car is a vehicle but a computer has a motherboard.
A computer has a case and a computer has a monitor.
So that's what composition is is actually modelling parts if you will,
parts of the greater whole.
So this case, we're going to model the computer and
we're going to model the has A relationships of the motherboard.
The case and the monitor.
So let's start off by actually creating those three classes- the motherboard,
the case, and the monitor.
So now we start with the motherboard.
New, Java class, motherboard.
We're going to create some fields.
String Model.
Private string manufacturer.
It's manufacturer of the motherboard.
Private_int the number of RAM slots of motherboard's got.
And the number of card slots for video cards and so on.
And lastly just the name of the bios.
Just some typical things that you would find in a motherboard.
So I'm going to create our public instructor.
Which will be just all the fields.
We're going to create getters for all of our fields because we don't need setters.
What we're going to do is add one public method which
we're going to call a low program.
I'm going to pass a parameter which will be the program name And
we're just going to print out that the program, the program name is now loading.
So that's our motherboard class.
Pretty straightforward as you can see, nothing particularly complicated there.
So let's now move on to our monitor class.
Create another new class.
Monitor is the name.
It's also got some fields.
We're going to start with the private string for the model.
Private string manufacturer.
Private int size.
That will be the size of the screen.
And let's go with another one which is going to be the native resolution.
we're going to call that a resolution, native resolution.
Resolution is going to be a class.
We're going to create a constructor, like so.
And we're going to fix up that resolution class in a minute.
We're going to create that class And
what we're going to do here is we're going to create a public method.
Draw pixel at.
That's going to have an X, Y location, and let's say a color.
And we'll just do our, a simple message that says drawing pixel.
At x, the xy position
in color, color.
A very simple method, and then we'll just create some guesses as well.
Just to get us for this class.
So next we need to create the resolution class.
And with the resolution class, that's going to be the native resolution.
So, what is the width and height and maximum width and height of a monitor.
How many pixels wide and how many pixels down so to speak.
So, we can go for width and height Let's just keep it simple there.
So that would be the resolution instructors.
And some getters.
So that's our resolution.
So going back now to the monitor.
Find that the arrow's now gone away.
So this is an early example, we're gonna talk more about this shortly, but
this is composition.
So the resolution class is part of a monitor,
so the monitor isn't a resolution, but it has a resolution.
So this is what composition is so
we're saying the resolution is a component of a monitor.
A monitor has a resolution which is the native resolution.
More on that shortly.
So next we need to create a class for case.
New class, case, and we're going to have model,
private string.
Manufacturer, private string power supply.
And let's also have a dimension Dimensions.
New class we're gonna create.
It's gonna be the dimensions, the width,
height and depth of the actual case itself.
This is the case that contains all the components.
Okay and so the constructor is going to have to accept those parameters.
Like so. We're going to create a function called
press power button.
And we're going to have a simple print line that says, power Button pressed.
Like so, and we'll just do our [INAUDIBLE] as we normally do.
Okay so making good progress now.
So the last thing we [INAUDIBLE] implement before we can start seeing how some of
this works, is of course the dimensions class.
And that's gonna have a width, a height, and a depth.
So let's create that.
We'll say dimensions.
Int width, height, depth.
Create a constructor for the three of them and lets create a getter as well.
Oops.
Like so.
Sometimes I have to mention so now if i go back to case the hour goes away.
So the case has got a model, a manufacturer and a power supply.
A case has got dimensions.
The dimensions which are to the width, the height and the depth.
That is what our dimensions use.
So of course the case has got all these things.
It has got a model.
Has got a manufacturer, has got a power supply, and
of course, it does have dimensions.
And that's what we're doing here again, with our composition, we're
actually creating something, in this case, another object that is part of the case.
So, now we get to the fun part, where we actually create
a class that is comprised of the case, the monitor, and the mother board.
So, let's create yet another new class.
We're gonna call that PC.
This'll be our personal computer.
And instead of using extends, we're going to type private Case theCase.
I have to use the word theCase there, by the way,
because if I just type case, as you know by now,
case is actually a reserved keyword, so we'll actually get an error.
So we need to put case.
You can call it something else, but that will do.
I'll call it the case and a piece it has got a case.
It has got a monitor.
We'll just call these monitors.
And of course motherboard, motherboard, motherboard.
And we create a constructor like we normally do.
This time we're creating a constructor that's gonna accept three objects.
Three different objects.
And let's create getter as well.
So this is composition again.
So we've created a new class called pc.
It has a case, so
that's the case variable, which is the field that we've defined.
It has a monitor, a field monitor and a field cord monitor and, of course,
it has a motherboard, which in this case, is a field cord motherboard.
And you can see the obvious advantage here,
because if you're using the extends option to inherit, you can only, in Java,
inherit from one class at a time So you can see that we run into difficulties
are running to limitations quite quickly, if we're using standard Java inheritance
like we used the last few videos where we can only extend from one class.
In this case what we said is, the PC comprises of these three other classes
only the case the monitor and the motherboard.
So the PC has, in this case is going to have, the objects that
we create a off this class We'll have an object Case monitor and
motherboard in each instance that we create.
So let's actually run some code now and see how it would use this in reality.
So what we want to do first is create a Case.
So you put Case theCase = new Case.
So that actually needs the model number so let's start with 220b.
Manufacturer, let's use Dell, for want of a better name.
Power supply we'll say 240.
And lastly it wants the dimensions,
so it actually wants to know what the dimensions are.
So we can just dimensions in there.
And, of course, what we'll need to do is create a new dimensions class.
So I could put.
So the dimensions, let's go with a width of 20 A height of 20 and
a depth of five that would be our case.
Weird size case, but for this example it'll be fine.
So that's our definition for case now.
Remembering that when we create the PC which we're going to be doing shortly,
it needs to know what the case is.
And think of that as putting a PC together.
A PC generally can't be put together without a case.
So what we're doing here is creating the case.
So next we need to create a monitor.
Create the monitor.
You can view monitor.
And the parameters for this one, it's a model so
we'll call it the 27 inch beast manufacturer,
let's try it.
Acer, size we'll go 27 for 27 inch and it also needs a native resolution.
You want to create that, so
we'll need to create that class, and let's do that a different way.
I want to show you another way of creating a class on the fly.
If you don't need to create a variable.
You're not going to use it for anything else.
You only want to pass it to a method.
If you just type new resolution(2540, 1440) which is the size of my monitor.
So that's created a class without using a variable which we don't need in this case.
And I'll just fix that typo.
That's monitor.
So we've now got a Case and
a monitor that ultimately are gonna be used to create our PC.
Of course we now need a motherboard, so let's create a motherboard.
So motherboard.
Motherboard = new motherboard.
And we need a model.
We do at 200, and let's go with Asus.
The number of RAM slots, well there's four RAM slots on this one.
Number of card slots, let's just say there's six.
And bios, let's say it's version 2.44, so there's our motherboard.
So now we're at the stage where we can create our PC.
Let's put our PC together.
How do we do that?
Well we type PC, the PC equals a new PC, And of course it then needs the case.
The case, the motor, and the motherboard.
They're the three parameters that will collectively make up our PC.
So we've now created The PC class by passing those three other objects to it.
Now of course you've seen in previous videos with inheritance we were able to
use a method name,
that is part of the basic class, the super class in other words.
But how do we get access to it?
For example,
if I wanna draw something using the monitor, how do I access this method?
So of course we've got the method draw pixel at but how do we access that?
How do we access that from our PC,
cuz of course the PC has got getters, but it hasn't got any access that.
We're not overriding a method or anything like that.
So how do we access it?
Well, one way of using it, we could type the PC.
Dot get monitor dot draw pixel at.
We could do it that we could do draw pixel at 1500, 1200 in red.
That's one way of accessing it.
So what that is is just using the getter function from here, which is returning
The monitor which is the class that has already been initialized.
The object which has been created in this class,
returning that to the calling process.
And from their we're then calling the method draw pixel at which is from that
object that's stored within the PC class itself in the PC object,
the instance that we've actually created, and that's invoking that method for us.
So likewise we could put the PC, get mother board, dot load program.
How would we load the program?
Windows 1.0. We're doing the same thing there.
We're getting the class, the object that's being created.
And we credit the piece in class so we're accessing it within the PC object,
and we're getting it to load, to call the method load program
which is in that object, which of course, is in the PC object that we've created.
But of course for our personal case the PC dot get the case, .pressPowerButton.
We could do the same thing there.
So now we're accessing ultimately these functions
that are in these base classes and not the case, the motherboard,
and the monitor, but accessing them via the PC object.
So this is what composition is.
This is the difference that inheritance, the PC object that we've created here.
So what we did to call the PC object was we created our case, our monitor, and
our motherboard.
And in reality when you're putting a computer together, that's what you'd be
doing, you'd go away and you'd actually buy the case, you'd buy the monitor, and
you'd buy the motherboard, you're then putting it together to build the PC.
So, in this case, what we're doing is we're passing these to the constructor,
which essentially is giving those items and
putting them together, which forms our PC.
So, the PC has a case, has a motherboard.
It has a monitor.
So this is the way when you're thinking of whether to use inheritance or composition.
Think about what you're trying to do here.
In this case we're trying to build a computer.
And we need to access the case, the monitor, the motherboard.
We know that these things.
The computer has got a case.
It has got a monitor.
It has a motherboard.
So therefore composition is probably a great way to go.
But of course a case by itself isn't a computer.
A case isn't, a monitor isn't a computer and
of course the motherboard isn't a computer.
They're part of a computer, but not actually the whole computer
which is why we're using composition here instead of inheritance.
So, I'm gonna end this video here,
we'll continue on talking about composition in the next video.