Methods were designed to:

• Increase the readability of the program

• Increase the ability to debug a program

• Reduce the redundancy of code

• Incorporate the concept of Separation of Duties/Divide and conquer

Examples of these methods are:

• println()

• nextLine()

• nextInt()

• charAt()

• length()

• split()

• toUpperCase()

• hasNext()

In reality, methods support the idea of the divide-and-conquer technique, which consists of breaking the problem into sub-problems and solving them independently to solve a larger problem.

There are two concepts that you need to understand for methods

1.  Method definition

2.  Method call (invocation)

Once the methods are defined, the code of your traditional classes will change:

When you define, a class method MUST be inside the class's scope but outside of the primary method.

Before Methods:

public class Whatever{

public static void main(String [] args){

     //... all your code is in the main

     //...

}

}

Methods use the divide and conquer technique. The divide and conquer technique means that the problem is broken into "small pieces" and each piece performs specific operations/tasks. For example, an example of a divide and conquer strategy is to break the main method into different methods and then call each method to perform specifics. Consider the code Whatever.java from the previous section now a skeleton of the class might look like this:

public class Whatever{

public static void main(String [] args){

      // method calls belong here

}

m1()

{

   // ...

}

m2()

{

   // ...

}

// …

}

Method calls

Here is a list of methods that you have been using for the past 8 weeks.

• next()

• nextLine()

• nextInt()

• nextDouble()

• println(a String)

• pow(an int, an int)

• sqrt(int)

• toUpperCase()

• toLowerCase()

• compareTo(String)

• equals(String)

• equalsIgnoreCase(String)

• charAt(int)

• length()

• showMessageDialog(null, String)

What is common in all method calls?

1. In order to make it work, you need the "." at the beginning of each method

2. Parenthesis/arguments. All of them have parenthesis. However, there are two types.

a. (): they are called empty arguments. This means that there are no arguments for this method

b. (data type): inside the parenthesis, you can provide arguments. You need to specify each argument data type.

3. Camel case style. The name of the methods follows the format of the camel case.

How do you call/invoke your methods?

Depending on your program's context, you can call the methods that you define in the previous section. Usually, the methods are called from the main.

1. Call the method with an actual value. Do not provide the data type in the parameters

public static void main(String [] args){

f(2);  

}

2. Anticipate the data type you will receive from the method call. You can find out the data type by checking the return type of the method definition

public class MethodExample01{

public static void main(String [] args){

   int solution = f(2);

}

public static int f(int x){

   // .. code omitted

}

}

3. Report intermediate steps from the main.  In this particular example, notice that the variable solution in the main now contains the result obtained by calling the method.

public class MethodExample01{

public static void main(String [] args){

   int solution = f(2);

System.out.println("The solution is: "+solution);

}

Why are argument identifiers different from the variables in the main?

Whatever happens under the scope of the method lives and stays there. Once the method returns the value that is specified in the method header, that operation expires.

For example, in our case, notice that we call the variable in the main that will hold the value solution AFTER the method f is called with the value 2. In the method f, the variable result holds the quick calculation of the function f. Once it hits the return, all the variables (including the result) disappear.