Still unsure as to why this integer remains unmodified

Question

I am learning about References and Datatypes in Java and this particular code is still confusing me. I understand that all of the primitive types in Java are value types (byte, short, int, long, float, double, boolean, char), and when you're using a string or an object it's a reference type. When I was taught to declare and initialize a variable, I was told to think of it like creating a box. So if I create a variable "y" and give it a value of "5" it's like I've created a box called "y" that contained the value of 5. My teacher said that if I then try to call y in a method (check out the code below for more detail) the value will remain untouched because it's a primitive datatype so I'm only passing in 5, not the variable that CONTAINS 5. Well I'm confused because if I'm passing in the value of 5, why wouldn't the following method add one onto it.

public class ReferenceAndValueTypes {
    public static void main(String[] args) {

        int y = 5;
        addOneTo(y);

        System.out.println(y);

    }


    static void addOneTo(int number){
        number = number + 1;
    }
}

The output is 5 and that confuses me greatly. The teacher says it's because int is a value type so we're not passing the y variable in, and we're not operating on that variable but rather the value of that variable. However, the value of that variable is 5 and since the method adds one, shouldn't it be 6? Or, is it because y is a value type, the method cannot work with it so it just has to print out the initial value of y which was 5?

Answer 1

Java primitives (int, long, boolean, etc) are not references, they're actual values. When you have addOneTo(y);, addOneTo receives a copy of the value. That copied value is incremented by one, and then lost when the method exits.

As an analogy, when you see a primitive method parameter you can think of it as a photocopier. In contrast, an object reference is the same as passing a notepad with something written on it. The method will see the same object, not a copy of it, and so changes made to it will be present after the method exits.

Changing the name of the parameter can make this a little clearer

static void addOneTo(int numberA) {  // numberA is not the same as the int in the calling method, it's just an exact copy of it
    numberA = numberA + 1; // numberA is now incremented by one
    // method exits, numberA is lost
}

If you want to have a method that provides increment functionality, you can define one that returns the result.

public static void main(String[] args) {
    int x = 3;
    addOneTo(x); // x is still 3
    x = addOneTo(x); x is now 4
}

static int addOneTo(int number) {
    return number + 1;
}

Answer 2

Because primitive types in Java are passed by value, not reference. Inside addOne() i is treated as local variable that is copied from passed argument, so any changes in it don't change the variable that is passed by caller.

---

P.S. This also works for objects indeed. For example, this code snippet:

void changeString(String s) {
    s = new String("new");
}

String s = "old";
changeString(s);
System.out.println(s);  

prints "old", because in changeString(), s reference is copied, thus changing it inside method (assigning new reference) has no effect to caller's s variable.

Answer 3

As simple as it is, java is written as pass-by-value. If you increment the number in your addOneTo method then you are changing the value of the reference of your parameter number. by this the number does not refer to your original y variable anymore and hence does increment it. This doesn´t work on any primitive typ.

Answer 4

If a variable x holds a reference type, then it points to an object. If it holds a value type, then it points to the value. When you call some function f(x), the thing that is passed to f is the thing that x points to, not x itself.

So here, if you said something like

int y[] = new int[1]{5}

and then said

number[0] = number[0] + 1;

inside of addOneTo, then the value of y would be modified outside --- the thing that addOneTo is acting on is the array containing that number.

On the other hand, when int y = 5, then the thing you're acting on is the number. You're making a new name that points to the same value (5), and when you say

number = number + 1;

what you really mean is:

number2 = number + 1;
number = number2;

and then you throw away the result.

Answer 5

Your question has answer

int is a basic data type and they are passed by value and not by references so the value remain unchanged :)