Methods

Navigate Language Fundamentals topic: Statements Conditional blocks Loop blocks Boolean expressions Variables Primitive Types Arithmetic expressions Literals Methods String Objects Keywords Packages Scope Arrays Mathematical functions Large numbers Random numbers Unicode Comments

Methods are how we communicate with objects. When we invoke or call a method we are asking the object to carry out a task. We can say methods implement the behaviour of objects. For each method we need to give a name, we need to define its input parameters and we need to define its return type. We also need to set its visibility (private, package, or public). If the method throws an Exception, that needs to be declared as well. It is called a method definition. The syntax of method definition is:

class MyClass {
 ...
    public ReturnType methodName(ParamOneType param1,
                                 ParamTwoType param2)
    throws ExceptionName {
      ReturnType retType;
      ...
      return retType;
    }
 ...
}

We can declare that the method does not return anything using the void Java keyword. For example:

Code section 3.50: Method without returned data. private void methodName(String param1, String param2) { ... return; }

When the method returns nothing, the return keyword at the end of the method is optional. When the execution flow reaches the return keyword, the method execution is stopped and the execution flow returns to the caller method. The return keyword can be used anywhere in the method as long as there is a way to execute the instructions below:

Code section 3.51: return keyword location. private void aMethod(int a, int b) { int c = 0; if (a > 0) { c = a; return; } int c = c + b; return; int c = c * 2; }

In the code section 3.51, the return keyword at line 5 is well placed because the instructions below can be reached when a is negative or equal to 0. However, the return keyword at line 8 is badly placed because the instructions below can't be reached.

Test your knowledge

Question 3.9: Consider the following code:

Question 3.9: Compiler error. private int myMethod(int a, int b, boolean c) { b = b + 2; if (a > 0) { a = a + b; return a; } else { a = 0; } }

The code above will return a compiler error. Why?

Answer

Answer 3.9: Compiler error. private int myMethod(int a, int b, boolean c) { b = b + 2; if (a > 0) { a = a + b; return a; } else { a = 0; } }

The method is supposed to return a int but when a is negative or equal to 0, it returns nothing.

Parameter passing

We can pass any primitive data types or objects to a method but the two are not processed the same way.

Primitive type parameter

The primitive types are passed in by value. It means that as soon as the primitive type is passed in, there is no more link between the value inside the method and the source variable:

Code section 3.52: A method modifying a variable. private void modifyValue(int number) { number = number + 1; }

Code section 3.53: Parameter by value. int i = 0; modifyValue(i); System.out.println(i);

Output for Code section 3.53 0

As you can see in code section 3.53, the modifyValue() method has not modified the value of i.

Object parameter

The object references are passed by value. It means that:

• There is no more link between the reference inside the method and the source reference,
• The source object itself and the object itself inside the method are still the same.

You must understand the difference between the reference of an object and the object itself. A object reference is the link between a variable name and an instance of object:

Object obj ⇔ new Object()

An object reference is a pointer, an address to the object instance.

The object itself is the value of its attributes inside the object instance:

obj.firstName	⇒	"James"
obj.lastName	⇒	"Gosling"
obj.birthDay	⇒	"May 19"

Take a look at the example above:

Code section 3.54: A method modifying an object. private void modifyObject(Class1 anObject) { anObject.setName("Susan"); }

Code section 3.55: Parameter by reference. Class1 obj = new Class1(); obj.setName("Christin"); modifyObject(obj); System.out.println(obj.getName());

Output for Code section 3.55 Susan

The name has changed because the method has changed the object itself and not the reference. Now take a look at the other example:

Code section 3.56: A method modifying an object reference. private void modifyObject(Class1 anObject) { anObject = new Class1(); anObject.setName("Susan"); }

Code section 3.57: Parameter by reference. Class1 obj = new Class1(); obj.setName("Christin"); modifyObject(obj); System.out.println(obj.getName());

Output for Code section 3.57 Christin

The name has not changed because the method has changed the reference and not the object itself. The behavior is the same as if the method was in-lined and the parameters were assigned to new variable names:

Code section 3.58: In-lined method. Class1 obj = new Class1(); obj.setName("Christin"); // Start of the method Class1 anObject = obj; anObject = new Class1(); anObject.setName("Susan"); // End of the method System.out.println(obj.getName());

Output for Code section 3.58 Christin

Functions

In Java, functions (methods really) are just like in C++ except that they must be declared inside a class and objects are passed by value of reference pointing to that object. You cannot create pointers to a function but Java has events which really are function pointers under the hood for when you need that type of functionality.

Return parameter

So as we can see, a method may or may not return a value. If the method does not return a value we use the void Java keyword.

Same as the parameter passing, the method can return a primitive type or an object reference. So a method can return only one value. What if you want to return more than one value from a method. You can always pass in an object reference to the method, and let the method modify the object properties. The modified values can be considered as an output value from the method. However you can also create an Object array inside the method, assign the return values and return the array to the caller. You could have a problem however, if you want to mix primitive data types and object references as the output values from the method.

There is a better approach. Defines special return object with the needed return values. Create that object inside the method, assign the values and return the reference to this object. This special object is "bound" to this method and used only for returning values, so do not use a public class. The best way is to use a nested class, see example below:

Code listing 3.10: Multiple returned variables. public class MyObject { ... /** Nested object is for return values from getPersonInfoById method */ public static class ReturnObj { private int age; private String name; public void setAge(int val) { this.age = val; } public int getAge() { return age; } public void setName(String val) { name = val; } public String getName() { return name; } } // End of nested class definition /** Method using the nested class to return values */ public ReturnObj getPersonInfoById(int id) { int age; String name; ... // Get the name and age based on the ID from the database ... ReturnObj ret = new ReturnObj(); ret.setAge(age); ret.setName(name); return ret; } }

In the above example the getPersonInfoById method returns an object reference that contains both values of the name and the age. See below how you may use that object:

Code section 3.59: Retrieving the values. MyObject obj = new MyObject(); MyObject.ReturnObj person = obj.getPersonInfoById(102); System.out.println("Person Name=" + person.getName()); System.out.println("Person Age =" + person.getAge());

Test your knowledge

Question 3.10: Consider the following code:

Question 3.10: Compiler error. private int myMethod(int a, int b, String c) { if (a > 0) { c = ""; return c; } int b = b + 2; return b; }

The code above will return a compiler error. Why?

Answer

Answer 3.10: Compiler error. private int myMethod(int a, int b, String c) { if (a > 0) { c = ""; return c; } int b = b + 2; return b; }

The method is supposed to return a int but at line 4, it returns c, which is a String.

Special method, the constructor

The constructor is a special method called automatically when an object is created with the new keyword. Constructor does not have a return value and its name is the same as the class name. Each class must have a constructor. If we do not define one, the compiler will create a default so called empty constructor automatically.

Code listing 3.11: Automatically created constructor. public class MyClass { /** * MyClass Empty Constructor */ public MyClass() { } }

Static methods

A static method is a method that can be called without an object instance. It can be called on the class directly. For example, the valueOf(String) method of the Integer class is a static method:

Code section 3.60: Static method. Integer i = Integer.valueOf("10");

As a consequence, it cannot use the non-static methods of the class but it can use the static ones. The same way, it cannot use the non-static attributes of the class but it can use the static ones:

Code section 3.61: Static attribute. private static int count = 0; public static int getNewInteger() { return count++; }

You can notice that when you use System.out.println(), out is a static attribute of the System class. A static attribute is related to a class, not to any object instance, so there is only one value for all the object instances. This attribute is unique in the whole Java Virtual Machine. All the object instances use the same attribute:

Code listing 3.12: A static attribute. public class MyProgram { public static int count = 0; public static void main (String[] args) { MyProgram.count++; MyProgram program1 = new MyProgram(); program1.count++; MyProgram program2 = new MyProgram(); program2.count++; new MyProgram().count++; System.out.println(MyProgram.count); } }

Output for Code listing 3.12 4

Test your knowledge

Question 3.11: Visit the Oracle JavaDoc of the class java.lang.Integer.

How many static fields this class has?

Answer

4.

• int MAX_VALUE,
• int MIN_VALUE,
• int SIZE and
• Class<Integer> TYPE.

To learn how to overload and override a method, see Overloading Methods and Constructors.

External links

• Abstract methods, interactive Java Lesson