 So, one of the things you may have noticed when we did say the collision detection assignment is it was kind of annoying. We had to copy and paste the distance formula. We had to make more variables that way I had, you know, a's and b's and a x's and b x's and c x's. It was really annoying, even though it was kind of fun. Well, that's an issue, you know, the annoyance factor. I don't want to have to copy and paste constantly, you know, that's not why I became a programmer. You know, I don't like to do things. I like to do them once and they're done. I'm a lazy programmer. And that's actually where we introduce this idea of something known as methods. Now, how a method operates is basically it takes anything that we were working on, any kind of code and it makes it reusable. Now instead of me having to copy and paste and make more variables and yada, yada, yada, yada, yada, it takes it and it turns it into its own tiny little program, tiny little program inside our big program, inside of our big program that we, you know, write and then we give to someone and make millions of dollars with. And we see that we've got a little bit of a structure to it, but let's actually kind of take this into more of that practical sense. So when we start to design out a method, one of the things that you see is we have something known as the access modifier. We've been using this actually since beginning of class. Think about the public static void main method, the public static, you know, that's the first thing we write, public static, well what does it mean? Public static refers to the fact that there's only one and it's accessible to everyone, which is what we want because, you know, I want to make my millions of dollars. But then we get into this return type. This needs to be some form of a data type. Now I know that in our main method we talk about void a lot, you see that we do void. We'll talk about void a little later, but this is telling sort of Java and me, the developer, what is going to be the end result of this tiny little program, the end result, you know, instead of printing, instead of printing something, I want this to live on in infamy, if we want to think of it that way. The reason why is because when I build out this entire tiny little program, it only exists in its tiny little world. Notice how I have something called calc inside here. Calc only exists within these two curly braces. As soon as this method is done, as soon as I hit this guy, guess what, calc goes away completely. So what we have to do is we have to say what we're going to be returning out of this. And next we get our name. Again, if we think we've been doing public static void main, well, that's all we're doing is we're saying I need to give this method this tiny little program a name. So in this case, I'm just adding two numbers together. So I just called it the sum method. And then we have a list of parameters. Now these parameters, again, if we look at sort of the difference between, say for example, a method and a for loop, a method has variables and a for loop has variables. A for loop has access to any sort of variable that was created above it. And it's don't because again, they're tiny little programs that live in their own tiny little world. So you know, here's my main method and here's main. Here's my sum, you know, it has a little bit more of a geographical location. But these guys don't talk to each other at all. Notice that, you know, there, here's this guy, here's this guy, you know. So what do we do? Well, these parameters, what they're doing is they're actually kind of creating a bridge, bridge between my main method and my sum method. And so you see this little graphic over here on the edge, what's actually going on is when I design out this entire method, instead of it just being like a variable like soaring the number five in here and that's, you know, zero zero zero one, you know, it's just binary. What's actually going on is that I'm going to take this entire method and that's what gets stored inside, there we are, that's what gets stored inside of memory. So I have access to it multiple times and this is actually known as invoking the method. And we think about that sum method we just built. It is going to return a data type. It's going to return, if we look at this, return I1 plus I2. Okay, well, what's I1 plus I2? That refers to these parameters that are being passed. Now, if you notice, we've got five and seven. So that suddenly gets renamed to I1, that suddenly gets renamed to I2. We know what goes on inside of sum, some adds those together, stores it in calc. And before my sum method goes away, it is going to return, it's going to return this. This becomes 12, then left to right association kicks in and I'm going to take 12 and put it here. Now the same kind of thing can go on with more variables, again, sort of the way we can think about a parameter is it's just a placeholder, placeholder. Because if I make two variables, say I make an X and I make a Y, again, okay, well, I'm going to be using I1 and I2 inside of sum, X and Y, what's going on here? All that happens is X and Y get renamed into I1 and I2. The same calculations happen, you know. I would replace this within my five, I would replace this then with my seven. And again, this would calculate out to 12, that gets stored into another value.