In Java, how are parameters passed?

The most common question asked by beginner programmers is how parameters are passed in Java. Typically, programming languages ​​use pass-by-value and pass-by-reference to pass parameters to methods. However, Java does not support these two methods and instead uses pass-by-value to pass primitive and reference type values. In this article, we will learn about passing parameters by value through a sample program.

Passing parameters to methods in Java

Let us start the discussion by understanding Java's storage mechanism. The names of reference variables, methods, and classes are stored on the stack, and their values ​​are stored on the heap. However, primitives and their values ​​are stored directly in stack memory.

As mentioned before, Java only supports value passing of basic types and reference types, which means that when a method is called, a copy of each parameter value is passed to the method

For basic types such as int, double and Boolean, the value of the parameter is the same as the original value of the variable. For example, if we have a variable "x" with a value of 10, and we pass "x" as an argument to a method, the method receives a copy of the original value 10 as its argument.

Since reference variables are stored on the stack, for reference types such as arrays, objects, and strings, the value of the parameter is the reference or address of the given variable. For example, if we have an array 'arr' with elements {1, 2, 3} and pass 'arr' as parameter to a method, then the method will receive a reference or a copy of the address of 'arr' as its parameter.

Let’s discuss some terms related to parameter passing in Java

User-defined method

Methods are blocks of code that can be reused multiple times to perform a single operation. It saves us time and also reduces code size.

grammar

accessSpecifier nonAccessModifier return_Type method_Name(Parameters) {
   // Body of the method
}

here,

accessSpecifier - used to set the accessibility of a method. It can be public, protected, default, and private.

nonAccessModifier - It shows additional functionality or behavior of a method such as static and final.

return_Type - The data type that the method will return. We use void keyword when a method does not return anything.

Parameter vs Parameter

Parameters - are named variables passed during method definition and used as placeholders for parameters. They actually import the parameters into the specified method. They allow methods to be generalized. Here, generalization means that we can reuse a single method on various data as needed.

Parameters - are the actual values ​​passed when the method is called. They must match the parameter types passed in the method definition.

Value passing method

By passing parameters this way, a copy of the parameter value is passed to the given method. This method can modify the copy but cannot affect the original value of the parameter.

Pass by reference

With this method of passing parameters, the reference or address of the parameter is passed to the given method. This method can modify the original value of the parameter by reference

Java program displays parameter passing

method

• Define two user-defined methods. The "changeVal()" method is used to modify the original type, and the "changeAray()" method is used to modify the reference type.

• In the main() method, declare and initialize an integer type value and a reference type value.

• Now, call these user-defined methods to perform the operation and exit

Example

import java.util.*;
public class ParameterPassing {
   public static void changeVal(int n) {
      n = n * 2; // modifying value
      System.out.println("Inside method: n = " + n);
   }
   public static void changeAray(int[] a) {
      a[0] = a[0] * 2; // modifying value
      System.out.println("Inside method: a = " + Arrays.toString(a));
   }
   public static void main(String[] args) {
      // for the Primitive type
      int val1 = 10;
      System.out.println("Before calling changeVal method: val1 = " + val1);
      changeVal(val1); // calling the method
      System.out.println("After calling changeVal method: val1 = " + val1);
      
      // for Reference type
      int[] aray = {1, 2, 3};
      System.out.println("Before calling changeAray method: arr = " + Arrays.toString(aray));
      changeAray(aray); // calling the method
      System.out.println("After calling changeAray method: arr = " + Arrays.toString(aray));
   }
}

Output

Before calling changeVal method: val1 = 10
Inside method: n = 20
After calling changeVal method: val1 = 10
Before calling changeAray method: arr = [1, 2, 3]
Inside method: a = [2, 2, 3]
After calling changeAray method: arr = [2, 2, 3]

As you can see in the output, for primitive type "val1", its value does not change after calling the "changeVal" method. For reference type "arr", its value will change after calling the "changeAray" method.

in conclusion

In this article, we learned about user-defined methods and discussed how to pass method parameters in Java through an example. Passing a value of a reference type as a parameter is not the same as a primitive type. Java only supports passing references to non-primitive types to modify their state, not their identity.

The above is the detailed content of In Java, how are parameters passed?. For more information, please follow other related articles on the PHP Chinese website!