What are methods in programming? -Kalle Tech (2023)

What are methods in programming? how to use them Why should I care? Today I will answer all these questions. Let's see what methods are in programming. Methods are one of the things that make your code really powerful. And that is also an important part of what is called"Object-Oriented Programming" (OOP). It's a concept that needs to be understood. Don't worry though, by the end of this article you will have a much better understanding of what they are and how to use them.

What methods are there?:

There are three main types of methods; Interface methods, constructor methods and implementation methods. Today we focus on implementation methods. What is the main way to use the methods. Once you understand this, you will automatically understand the other two. So for now, don't worry about learning the other types. Also, you may have heard of "functions" in programming. A function is the same as a method. Just a different name. I wanted to address this upfront, in case you're wondering.

Here is an example of what a method might look like:

String getMyName() { return "Kalle Hallden";}

What does this method do? Let's break it down. This method contains four important parts:

Methodensignatur

getMyName()

Method body, everything inside the curly braces {}

{regress "Kalle Hallden";}

return type

line

Return Policy

Devolve "Kalle Hallden";

Methodensignatur:

What this method does when explained in natural language is that it gets a name. Specifically, it gets my name. This is the first clue as to what the name of the method should be. This means; What is the method supposed to do? You can name your method anything you like.
Example:

String getMyFirstnameAndMyLastNameBecauseIFeelLikeIt() { return "Kalle Hallden";}

However, for cleaner, more readable code, it is common practice to give it a name that is as short as possible. As much readability as possible is retained. To choose a name, you first need to figure out what you want the method to do. Ideally, everyone should be able to just read your method name and understand what it's doing.

This has two purposes. First, it helps you understand what you've written in the past. Beyond you dived into the code. Because beyond you everything makes sense. Future you has been working on ten new projects in four more languages. Future you doesn't remember any of these codes. If you've created good method names in the past, maybe you'll understand how your code works in the future. The second purpose is that when writing human-readable method names, you should constrain what the method should do. If you try to make the method do too many things, your method name will become so long that it becomes unreadable. That means you should probably split your method into two separate methods. For example, the method name “getMyFirstnameAndMyLastNameBecauseIFeelLikeIt” written above. What is this method supposed to do? It should contain my first and last name. We could improve the method name by shortening it to "getMyFirstAndLastName". But it's still quite long. It works but it's a bit too long. Beyond that, it's clear that it does two things. So we could improve this further by splitting it into two methods:

getMyFirstName()getMyLastName()

This improves our code in three ways. The two we just discussed increase readability and reduce what each method is supposed to do. Each method is responsible for getting only part of my name. The third improvement is that it allows us to get just my first name or just my last name. That's great if we don't want the full name in the future. Before that we would have to call the getMyFirstAndLastName method and then remove my last name from what we get, which is super complicated and unnecessary. This is often referred to as increased reusability, which is one of the main benefits of OOP. The ideal is to write clean and reusable code. Whatclean codersWe don't want to have to type anything twice. Keeping the scope (what it's supposed to do) of your method as small as possible ensures that the code you create is as clean and easy to understand as possible.

method body:

That's everything between the parentheses. For example, you can create new ones herevariables, perform calculations, call other methods, etc.

{ String newVariable = "Hello"; int calculation = 10 * 2; Call another method ();}

This would be called the scope of our method. Everything that is done within this framework is therefore only available to us within the framework of the method. This wouldn't work:

{ String myName = "Kalle";}myName = "New Name";

The reason for this is that we created the variable myName inside the scope of our method, so we can't access it outside of the scope of our method. However, as part of our method, we can access things that are out of scope. As long as the things we want to access are not in another area. So this would work:

String myName = "Kalle";{ myName = "New Name";}

Return type and return statement:

String getMyName() { return "Kalle Hallden"; }

The last part of each method is in the return statement. Here we are returning the value we want to return. This can be anything as long as it matches the return type of our method.

In our case, the return type is a string. Return type means that what this method returns to us must be a variable of type String. When we call getMyName() in our code, we know we're getting a string. Calling a method means every time we use the method signature in our code. When we write methodName() we call this method. The correct call to our getMyName() method would be as follows:

String meinName = getMyName();

The reason this is the correct way to call this method is because the method returns a string. Since it returns a string, let's access that string. So we want to store it in a variable. After calling our method like this, we can access what we get from our getMyName() simply by using our myName variable. The variable myName is now equal to what our method returns:

String getMyName() { return "Kalle Hallden"; }String myName = getMyName(); // myName is now equal to "Kalle Hallden"

There are as many return types as there are variable types. Our method could return an int, double, string, bool, etc. But there is also another kind of return here. That's called emptiness. If a method has a void return type, it means that the method does not return anything. Empty methods are mainly used to set things. That is, if we have a variable called myName that doesn't already have a value. A void method can then be used to assign a specific value to that variable. I like this:

String myName;void setMyName() { myName = "Kalle Hallden"; }

As you can see, there is no return statement. In this case, calling the method would look like this:

setMyName();

super easy. Because the method doesn't return a value, we don't need to and can't store what it returns. Because it doesn't return anything.

More on the method signature:

Alright, I hope you now have a good understanding of how to use the methods. The last thing I want to show you is the cool part about method signatures. As you may have noticed, we always end our method names with parentheses. This also has some pretty powerful abilities. Because we can add so-called input parameters to the signature of our method. What looks like this:

String getMoneyAfterTaxes(doble salario) { return salario * 0.6; }

As you can see we added two things to our method signature. Inside the brackets you can declare input parameters. In this case we are declaring that this method 'takes' a variable of type double as input. And you can access it inside the method by calling Salary. This means that when we call this method, we can also provide input. What would look like this:

Double moneyAfterTaxes = getMoneyAfterTaxes(555.5);

So now our method calculates salary * 0.6. And the salary was set at 555.5. Because that's what we gave as input. Within the parentheses of our method, we declare variables. Then when we call our method, we set the value of that variable by putting a value in the brackets. Another example would be:

void printEntries(String inputOne, String inputTwo, String inputThree) { print(entryOne + inputTwo + inputThree); }

You can add as many input parameters as you want. But then again, the convention is “less is more”. You should always use the smallest amount possible. To preserve readability.

Conclusion: