Passing Data to Java Methods: Call by Value Explained

// Demonstrates that every Java argument is passed by value.
public class CallByValueDemo {
    // A mutable object, so mutation is visible to the caller
    public static class Person {
        String name;
        public Person(String name) {
            this.name = name;
        }
    } // An immutable value, which behaves like a primitive
    public record Money(long amountInCents) {
    } private static final int TEN = 10;
    private static final long BASE_AMOUNT = 100L;
    private static final int NINETY_NINE = 99;
    private static final int ONE = 1;
    private static final int TWO = 2;
    private static final int THREE = 3;
    private static final String ALICE = "Alice";
    private static final String BOB = "Bob";
    private static final String EVE = "Eve";
    private static final String ADDED_INSIDE = "added inside";
    private static final String REPLACED_INSIDE = "replaced inside";
    // MUTATION is shared. REASSIGNMENT is not.
    public static void modifyValues(int count, Person person) {
        count = NINETY_NINE;
        // local copy changes, caller unaffected
        person.name = BOB;
        // shared object changes, caller sees it
        person = new Person(EVE);
        // local reference changes, caller unaffected
    } // Arrays follow the object rules exactly
    public static void modifyArray(int[] values) {
        values[0] = NINETY_NINE;
        // shared array, caller sees it
    } public static void replaceArray(int[] values) {
        values = new int[] {
            ONE, TWO, THREE
        };
        // local reference only, caller unaffected
    } // A mutable collection behaves the same way
    public static void addToList(java.util.List<String> items) {
        items.add(ADDED_INSIDE);
        // shared list, caller sees it
    } public static void replaceList(java.util.List<String> items) {
        items = new java.util.ArrayList<>();
        // local reference only
        items.add(REPLACED_INSIDE);
        // into a list the caller cannot reach
    } // An immutable value behaves like a primitive
    public static void mutateInteger(Integer count) {
        count = count + ONE;
        // unboxes, adds, boxes a NEW object
    } public static void mutateMoney(Money amount) {
        amount = new Money(amount.amountInCents() + ONE);
        // records cannot change
    } // RETURNING is the explicit mechanism the caller controls
    public static int doubled(int value) {
        return value * TWO;
    } public static void main(String[] args) {
        int original = TEN;
        Person person = new Person(ALICE);
        modifyValues(original, person);
        System.out.println("primitive after: " + original);
        // 10,  unchanged
        System.out.println("person after:    " + person.name);
        // Bob,  changed
        int[] data = {
            ONE, TWO, THREE
        };
        modifyArray(data);
        System.out.println("array after:     " + data[0]);
        // 99,  changed
        java.util.List<String> items = new java.util.ArrayList<>();
        items.add(ALICE);
        addToList(items);
        replaceList(items);
        System.out.println("list after:      " + items.size());
        // 2, only the add landed
        Integer boxed = TEN;
        mutateInteger(boxed);
        System.out.println("Integer after:   " + boxed);
        // 10,  unchanged
        Money amount = new Money(BASE_AMOUNT);
        mutateMoney(amount);
        System.out.println("record after:    " + amount.amountInCents());
        // unchanged
        // RETURNING is visible at the call site
        original = doubled(original);
        System.out.println("returned value:  " + original);
        // 20
        // THESE ARE ALL COMPILE ERRORS AND ARE SHOWN AS COMMENTS
        //
        // assigning to a final parameter
        // public static void finalParam(final int value) {
        //     value = NINETY_NINE;   // cannot reassign a final parameter
        // }
        //
        // trying to mutate an immutable value
        // public static void mutateString(String text) {
        //     text.concat(" more");   // returns a new String, changes nothing
        // }
        //
        // expecting the reassignment of a parameter to reach the caller
        // public static void noEffect(String text) {
        //     text = REPLACED_INSIDE;   // the caller keeps its own value
        // }
    }
}/*
    ACTUAL OUTPUT:

        primitive after: 10
        person after:    Bob
        array after:     99
        list after:      2
        Integer after:   10
        record after:    100
        returned value:  20

    THE NINE THINGS TO REMEMBER
    1) JAVA IS PASS BY VALUE, ALWAYS. There is no pass by reference in
       the language, and objects are not an exception.
    2) WHEN YOU PASS AN OBJECT, THE REFERENCE IS COPIED. Both names
       point at the same object, but they are separate variables.
    3) MUTATION IS SHARED. Assigning THROUGH the reference, such as
       person.name, changes the object both names see.
    4) REASSIGNMENT IS NOT SHARED. Assigning TO the parameter, such as
       person = new Person(), moves only the method copy.
    5) ARRAYS ARE OBJECTS, so they follow the same rules. Mutating an
       element is visible; assigning a new array to the parameter is not.
    6) Integer IS IMMUTABLE, so count plus one unboxes, adds, then
       boxes a brand new object. The caller sees the original value,
       exactly as with a primitive. String and records behave the same.
    7) A FINAL PARAMETER ONLY BLOCKS REASSIGNMENT of that local name.
       It does not change how the argument is passed, and it does not
       stop the method mutating the object behind it.
    8) TO LET THE CALLER KEEP A DIFFERENT VALUE, RETURN IT. Assigning at
       the call site makes the change obvious to every reader.
    9) FOR DATA THAT MUST NOT SURPRISE ANYONE, PASS IMMUTABLE VALUES.
       A String or a record gives a method no way to change what the
       caller holds, which removes a whole class of bugs.
*/