Java value passing and reference passing details

When an object is passed as a parameter to a method, the method can change the properties of the object and return the result of the change, so is it passed by value or by reference?
A: value passing. The Java programming language only passes parameters by value. When an object instance is passed into a method as a parameter, the value of the parameter is a reference to a copy of the object. Pointing to the same object, the content of the object can be changed in the method being called, but the reference to the object (not a copy of the reference) is never changed.

The Java parameter, whether the original type or the reference type, is passed as a copy (there is another way of saying pass value, but it is better to say pass value, which is usually relative to the address).

If the parameter type is the original type, then a copy of the parameter is passed, which is the value of the original parameter, which is the same as the original value. If you change the value of the copy in the function, you will not change the original value.

If the parameter type is a reference type, a copy of the reference parameter is passed, and the copy holds the address of the parameter. If the address of the copy is not changed in the function, but the value in the address is changed, then the change in the function will affect the parameters passed in. If the address of the copy is changed in the function, such as new1, then the copy points to a new address. At this time, the parameter passed in still points to the original address, so the value of the parameter is not changed.

Ex. :

public class ParamTest {
  public static void main(String[] args){
   /**
    * Test 1: Methods can't modify numeric parameters
    */
   System.out.println("Testing tripleValue:");
   double percent = 10;
   System.out.println("Before: percent=" + percent);
   tripleValue(percent);
   System.out.println("After: percent=" + percent);
 
   /**
   * Test 2: Methods can change the state of object parameters
   */
   System.out.println("\nTesting tripleSalary:");
   Employee harry = new Employee("Harry", 50000);
   System.out.println("Before: salary=" + harry.getSalary());
   tripleSalary(harry);
   System.out.println("After: salary=" + harry.getSalary());
 
   /**
   * Test 3: Methods can't attach new objects to object parameters
   */
   System.out.println("\nTesting swap:");
   Employee a = new Employee("Alice", 70000);
   Employee b = new Employee("Bob", 60000);
   System.out.println("Before: a=" + a.getName());
   System.out.println("Before: b=" + b.getName());
   swap(a, b);
   System.out.println("After: a=" + a.getName());
   System.out.println("After: b=" + b.getName());
  }
 
  private static void swap(Employee x, Employee y) {
   Employee temp = x;
   x=y;
   y=temp;
   System.out.println("End of method: x=" + x.getName());
   System.out.println("End of method: y=" + y.getName());
  }
 
  private static void tripleSalary(Employee x) {
   x.raiseSalary(200);
   System.out.println("End of method: salary=" + x.getSalary());
  }
 
  private static void tripleValue(double x) {
   x=3*x;
   System.out.println("End of Method X= "+x);
  }
 }

Display results:

Testing tripleValue:
Before: percent=10.0
End of Method X= 30.0
After: percent=10.0

Testing tripleSalary:
Before: salary=50000.0
End of method: salary=150000.0
After: salary=150000.0

Testing swap:
Before: a=Alice
Before: b=Bob
End of method: x=Bob // The copies of the visible references are exchanged 
End of method: y=Alice
After: a=Alice // The reference itself is not exchanged 
After: b=Bob