Hello there, and welcome back to this Java development course. So last time we went over modifier types you guys want to do your job was to create one of every single modifier type that we went over a variable with the every single modifier type that we went over in the last lesson. So here is essentially what should have done. So here I have first of all a private integer A equals one. This means that it will only be visible inside this class, then I have a default integer B, which is equal to two, which means that this will only be visible inside this package, then I have a protected integer C, which is equal to three. This means that it will only be visible inside this package and in other packages, but only in other packages with classes that extend this class.

And it can only be accessed using the super keyword. Then we have public and deep which essentially means it can be accessed anywhere, anywhere you want. Have a static int E, which means that we can refer to it without creating an instance of this class without doing new classes and objects. And then finally have a final int F, which just makes this variable constant, meaning it cannot be changed. So the only thing to note here very quickly is that we can actually have multiple modifier types. So we can have final static, so they don't interfere at all.

And then we can also have public final static. So we can have, there's three things. This is an access modifier. And then final and then static. There's sort of different, different in different leagues, but we can't have public and then private as well. So we can't have public private, so you can only have one access modifier.

All right, so that is essentially how we work with modifiers. Now really, the important thing about last lesson to understand was this private modifier here. Since today, we're going to be going over encapsulation and encapsulation heavily utilizes this private modifier. So let's take a look at exactly how that works. Alright, so before, the way we would do things is we would have a classifier, right, and we would have a number of eyes attribute inside that class spider. So as we have here, there we go, we have public int, number of eyes.

And I changed up the code a little bit here, just to make it a little bit less confusing. And just for demonstration purposes, so a little bit different. But yeah, so that's actually how we would do things without encapsulations just have public and number of eyes, and then we just refer to it by doing our DOT number of eyes, and then equals 56, or something like that. Now, encapsulation, on the other hand, would utilize something called getters and setters, form getter and setter methods. They're also called getter setter methods anyway. So what are they?

Well, they're essentially methods that we use to get and set an attribute of a class. So let's take a look here. So remember how we went over the private modifier? Well, that's actually what we're going to be utilizing. So we're going to do private Number of eyes Alright, so only this class can now refer to it directly. So here now we can't utilize this.

And now what we do is we generate getters and setters. So we do public void set. Number of eyes. All right? public void set number of eyes, it's going to take in an int, number of eyes, right? All right, and the inside we're going to do this DOT number of eyes.

There we go. Equals number of eyes. All right, there we go. So that is what we call a setter method. Then we're going to do the same thing for get number of eyes. So we're going to do public int, get number of eyes.

All right. Then we're going to do return number of eyes. And there we go. Alright, so now how would we actually refer or get the number of eyes? Well, you would do it using our dot set number of eyes 56 and then system dot out, dot print ln r dot get number of eyes. And there we go.

And now if we run this it appears that there is an error somewhere. Let me just take a look as everywhere there is an error. In project one or thematic operators, right, let's remove this. Okay. There we go. All right now, everything should work.

There we go. So now if you run classes and objects, we get 56. So you'll see how we refer to the number of eyes attribute inside spider, not directly so not by doing our DOT number of eyes. But by using the getter and setter methods, so that is essentially the very basis on what encapsulation is built. And technically, that is encapsulation itself. So there are actually a number of benefits that come along with encapsulation.

So first of all, we have complete control over what exactly is set. So, for example, let's just say that we wanted to know, a spider to have a maximum number of eyes. So clearly 56 eyes is a pretty crazy number. So I don't think a single spider has 36 eyes. So let's say that there's a limit of like 11. For example, we could go ahead and put in, put in sort of a barrier so we can do if number of eyes is less than or no is yeah is less than 11 or so.

Just as an example, then we only do it and if it isn't less than that, we just don't set it. So Now when we do this, it will go ahead and return zero since we don't set it. All right, and then that is one of the benefits. Another benefit is that we can make fields read only or write only. So let's say that we wanted number of eyes to be read only. So we can read it, but we cannot set it, all we would have to do is just remove this set number of eyes method.

Just remove that. And now we can read it. So we can use get number of eyes, but we cannot use set number of eyes. So if we go ahead and actually in here, we can't use it since doesn't exist. So we would have to not set it so we cannot set it vantage of using Oh, Andre advantage of using encapsulation. And then the final advantage is that we can actually change how we set or get variables inside the class.

But we don't necessarily need to change any of the code that uses the given class. So let's just for example, let's have a, for example here, let's just return back our set number of eyes method, right? And so alright, so we have, you know, set number of eyes, we're doing it, we're using it, everything is working, okay? But then all of a sudden, we say, you know what, we want to set the number of eyes as a string. So it's going to be, you know, a number, but it's going to be a string instead of an integer. So if we refer to it using the old method, without encapsulation, we would do our DOT number of eyes.

Right? Right, right, right. Who did that have to do this make this public? Make it default just totally matter. Okay? r dot number of eyes equals six, right?

But now we want to make this a string, right? So we change this into two string. So now in results, we get an error. So we get an error. We have to put a string here, but we have an integer. So now we have to change our code.

So the client that's using the class has to change this code, right? But if we had encapsulation on the other hand, we can simply do private string. And then inside the method to get the setter method, we would just do this DOT number of eyes equals a string plus number of eyes will just convert this integer to a string. And then and then for get number of eyes, you would just do public string, get number of eyes and then we're actually no it will be public int get number of eyes, it would be it actually, we would have to actually have to use integer dot parse int to convert a string to an integer. There we go. So this is a method inside the class integer which is a built in class.

So this will just return return a string as an integer, so it'll find an integer in the string and then return that. So there we go. So now since we are using encapsulation, so our dot set number of eyes to 56. There we go. Since we are using encapsulation, we can now change the data type without actually modifying any of the code that is actually using the class. So in this case, let's say that we want to change it back to integer at this point.

So right now you'll see, change it back to integer, or better, better yet, let's just actually float. So what if you want to change it from string? Now for floats, we would just do float number of eyes, right? Then here, what we would do it would be number of eyes. Yeah, just number of eyes. And then here, all we would do is return number of eyes, right?

But castering so just int number of eyes and remember this just cast a float down to an int. There we go. And so yeah, that's all we have to do. So we cannot change the data type. And in here, nothing actually changes we can keep on using the same exact code. So that is the third advantage of using encapsulation.

So encapsulation in general is actually one of the four fundamental concepts of object oriented programming. So they are actually abstraction, encapsulation, polymorphism and inheritance. So we've already gone over inheritance, which is just a class extends another class. And then we've also gone over encapsulation. So all we have left now to understand is abstraction, and polymorphism. So there are another two things, they're also pretty simple to understand.

That's actually what we're going to be going over in the following lessons in the final two lessons. Now, encapsulation, so encapsulation, it's generally a pretty important part of Java in general. Pretty much all code that you're going to be writing or all class you're going to be writing are going to use encapsulation. So it's important that you understand the concept. calculation is just a different way of writing class, and it's stead of actually referring to a variable directly. So doing our dot variable name equals 56.

It's just the practice of using getter and setter methods on a attributes of a class. And that's all that it is. So nothing difficult there. All right, now let's assign you some homework. Alright, so homework is very simple. Just take the insect class that we already have, and go ahead and encapsulate it.

So encapsulate everything as well as the spider class. I mean, I encapsulated to get in the lesson just now. But go ahead and calculate the insect class as well. So very simple homework should probably take like two minutes if you understand the calculation. And the more important part is to actually understand the calculation. So make sure you do that.

And you're good to go. So next time, we're going to be going over polymorphism, which has a very sort of weird name. I would say perhaps it's not I mean, I personally found it weird, but you'll notice In the next lesson what I'm talking about and yeah, so yeah, encapsulate insect and spider if you haven't done that already and I'll see you next time