Parameter Passing Techniques in Java with Examples

There are different ways in which parameter data can be passed into and out of methods and functions. Let us assume that a function B() is called from another function A(). In this case A is called the “caller function” and B is called the “called function or callee function”. Also, the arguments which A sends to B are called actual arguments and the parameters of B are called formal arguments.

Types of parameters:

Formal Parameter : A variable and its type as they appear in the prototype of the function or method.
Syntax:
```
function_name(datatype variable_name)
```
Actual Parameter : The variable or expression corresponding to a formal parameter that appears in the function or method call in the calling environment.
Syntax:
```
func_name(variable name(s));
```

Important methods of Parameter Passing

Pass By Value: Changes made to formal parameter do not get transmitted back to the caller. Any modifications to the formal parameter variable inside the called function or method affect only the separate storage location and will not be reflected in the actual parameter in the calling environment. This method is also called as call by value.

Java in fact is strictly call by value.

Example:

// Java program to illustrate 
// Call by Value 
  
// Callee 
class CallByValue { 
  
    // Function to change the value 
    // of the parameters 
    public static void Example(int x, int y) 
    { 
        x++; 
        y++; 
    } 
} 
  
// Caller 
public class Main { 
    public static void main(String[] args) 
    { 
  
        int a = 10; 
        int b = 20; 
  
        // Instance of class is created 
        CallByValue object = new CallByValue(); 
  
        System.out.println("Value of a: " + a 
                           + " & b: " + b); 
  
        // Passing variables in the class function 
        object.Example(a, b); 
  
        // Displaying values after 
        // calling the function 
        System.out.println("Value of a: "
                           + a + " & b: " + b); 
    } 
} 

Output:

Value of a: 10 & b: 20
Value of a: 10 & b: 20

Shortcomings:

Inefficiency in storage allocation
For objects and arrays, the copy semantics are costly

Call by reference(aliasing): Changes made to formal parameter do get transmitted back to the caller through parameter passing. Any changes to the formal parameter are reflected in the actual parameter in the calling environment as formal parameter receives a reference (or pointer) to the actual data. This method is also called as <em>call by reference. This method is efficient in both time and space.

// Java program to illustrate 
// Call by Reference 
  
// Callee 
class CallByReference { 
  
    int a, b; 
  
    // Function to assign the value 
    // to the class variables 
    CallByReference(int x, int y) 
    { 
        a = x; 
        b = y; 
    } 
  
    // Changing the values of class variables 
    void ChangeValue(CallByReference obj) 
    { 
        obj.a += 10; 
        obj.b += 20; 
    } 
} 
  
// Caller 
public class Main { 
  
    public static void main(String[] args) 
    { 
  
        // Instance of class is created 
        // and value is assigned using constructor 
        CallByReference object 
            = new CallByReference(10, 20); 
  
        System.out.println("Value of a: "
                           + object.a 
                           + " & b: "
                           + object.b); 
  
        // Changing values in class function 
        object.ChangeValue(object); 
  
        // Displaying values 
        // after calling the function 
        System.out.println("Value of a: "
                           + object.a 
                           + " & b: "
                           + object.b); 
    } 
} 

Output:

Value of a: 10 & b: 20
Value of a: 20 & b: 40

Please note that when we pass a reference, a new reference variable to the same object is created. So we can only change members of the object whose reference is passed. We cannot change the reference to refer to some other object as the received reference is a copy of the original reference. Please see example 2 in Java is Strictly Pass by Value!

Attention reader! Don’t stop learning now. Get hold of all the important Java and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.

My Personal Notes

Recommended Posts: