CodeGym/Help with Java Tasks/A very basic question.

Level 41

Olympus Mons

12.05.2021
598views
12comments

A very basic question.

Resolved

So I've been trying to figure this out, I know that CodeGym actually provided a material into this, but I just forgot to save it, and can't seem to find it within a reasonable time. So my question is: Why is this possible?

public class Main {
    public static void main(String[] args) {
        int something [] = {0, 1, 2, 3};
        changeArray(something);
        for(int i : something)
            System.out.println(i);
    }

    static void changeArray(int[] array){
        array[1] = 99;
    }
}

But not this?

public class Main {
    public static void main(String[] args) {
        int something = 1;
        change(something);
        System.out.println(something);
    }

    static void change(int someInteger){
        someInteger = 99;
    }
}

Something about passing by value or by reference, which I still don't completely understand. I can understand why the second one is not possible, as it copies the value into parameter, but I don't get why it's possible with the first example, as it would seem (at least for me) that it's not too different from the second example, where the array gets passed by value instead of reference. Edit: If you remember which CodeGym page/article it was, I'd be very grateful if you can post it. Sorry if the terms I'm using are wrong.

Comments (12)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

12 May 2021, 14:07

"Something about passing by value or by reference" Correct. Objects passed to methods are passed by reference. A variable is not an object but just an address that points to the object in memory. Java doesn't allow pointer manipulation like some other languages, but it still uses them under the hood while abstracting them away from us. I mention this because when you pass a non-primitive variable to a method you are actually passing the memory address to the method of the actual object. Because it is the actual memory address of the object you are working with, any changes are reflected outside of the method. Think of objects like balloons and variables like handles. When you create a variable and set an object to it think of it like attaching a handle to a balloon with a line. Now when you pass that object to a method all you are doing is attaching another handle to the balloon (the variable parameter in the method). Objects can have as many variables referencing them, only limited by the available memory in the computer, however variables can only reference one object. So: This is not possible: Object1 → variable ← Object 2 This you can do: variable1 → Object ← variable2 The primitives are: byte short int long float double boolean char None of these will be passed by reference. Excluding String, which is not a primitive but behaves like a one for this purpose, everything else is passed by reference.

Naughtless

Level 41 , Olympus Mons, Mars

19 May 2021, 13:50

Wow, thankyou for your comprehensive answer. I understand this with much more clarity now. You mentioned String is excluded, but when I tested this out with the non-primitive "Integer" (instead of "int"), it behaves identically. So are types like Integer, Double, Byte, etc. behave the same as primitives when used as a variable? (i.e. String myName = "Naughtless";)

Guadalupe Gagnon

Level 37 , Tampa, United States

19 May 2021, 14:20

Yes. I forgot to mention that classes that wrap primitives, like the ones you mention, also behave as primitives. Actually the thing they all have in common is they are immutable classes. You will eventually learn more about the topic. A quick description is that once the state of an immutable object is set it can not be changed. Take the String you used as an example, String myName = "Naughtless"; if I were to change the value from "Naughtless" to "Guadalupe" the result would be that the value would be "Guadalupe", however behind the scenes it doesn't just overwrite the initial value to the new value but grabs a whole new block of memory for "Guadalupe" and the variable name will be set to point to that new block of memory. All immutable classes do that. Here is a quick example of why that is an important difference:

Guadalupe Gagnon

Level 37 , Tampa, United States

19 May 2021, 14:20

solution

You can run this code and see what the results are. An explanation is in the next post below:

/* create a custom mutable class for testing */
class MyString{
    String name;

    public MyString(String name) {
        this.name = name;
    }
}


public class Solution {

    public static void main(String[] args) {
        /* create 2 objects with the name "Naughtless" */
        MyString name1 = new MyString("Naughtless");
        MyString name2 = new MyString("Naughtless");

        /* output to show that the names are set as such */
        System.out.println("Value of name1 '" +name1.name+"' -- Value of name2 '" + name2.name + "'\n");

        System.out.println("Passing to method to change values");
        testMethod(name1, name2);
        System.out.println("Method complete, here are the results:\n");

        /* output results of method */
        System.out.println("Value of name1 '" +name1.name+"' -- Value of name2 '" + name2.name + "'");

    }

    private static void testMethod(MyString testName1, MyString testName2) {
        testName1.name = "Guadalupe"; // change the name variable in the object
        testName2= new MyString("Guadalupe"); // create a new object with name changed
    }
}

Guadalupe Gagnon

Level 37 , Tampa, United States

19 May 2021, 14:32

In this example I created a quick class that is mutable. I then create 2 objects of that class, lines 15 and 16, and set the initial state of both to "Naughtless". I printed this on line 19 to show that it had been done. Then I pass both of those to the testMethod to change the name of each from the initial value to the new value of "Guadalupe". On line 31 I just change the state of testName1, which has the same reference as the name1 variable in main (they both point to the same exact object in memory), to "Guadalupe". This means that the actual object has its state changed and when line 26 is reached it outputs "Guadalupe" for name1 instead of "Naughtless". Now, remember how I described immutable classes work when a value is changed, it doesn't change the actual state of the value but creates a whole new object and then points to that instead of the old one. On line 32, inside the method, I did the same thing. The testName2 variable has a new object assigned to it and it now points to that new object instead of the old one. That means the object that name2, in the main method, points to is still the original one as that reference has not change. When line 26 is reached, and outputs the result of the method, you can see that name1.name has successfully been changed but name2.name is still the same. When working with immutable classes you have to remember that when state is changed, behind the scenes a whole new object is created. That means if you pass the object to a method and expect the method to change the value in the way a mutable class can have value changed, you will not get the expected results.

Naughtless

Level 41 , Olympus Mons, Mars

21 May 2021, 09:18

Oh wow. These two specific lines explained it best:

testName1.name = "Guadalupe"; // change the name variable in the object
testName2 = new MyString("Guadalupe"); // create a new object with name changed

So what happened to testName1 is similar to what happens when passing by reference. And what happened to testName2 is similar to what happened when I tried to pass by value. What happened to testName 2 is that you created a new Object, but nothing points to it and it becomes unused garbage. Right? Thankyou again, you have no idea how much time and effort your clear explanation saved me. Might have taken me a whole dang month or more to figure this out with my schedule.

Guadalupe Gagnon

Level 37 , Tampa, United States

21 May 2021, 13:51

useful

There are a few things discussed in this thread: - variables are not objects but references to memory locations that store objects think of them sort of like handles and objects sort of like balloons - variables can only reference one object a piece, however objects can have many different variables referencing them - you can set what object a variable will reference with the equals '=' operator - three types of objects/constructs (in this thread, there are some more later on) 1) a primitive: variables for these get their own memory location when declared, this means that they are passed by value. 2) an object: variables for these only store references to the memory location of the object it references. They pass the actual reference to methods so that the method variables actually change the object directly. 3) an immutable object: variables still store references to the object, however once an object is created it can not change. Any changes result in a new object being created in memory and the variable will then reference that new object.

Guadalupe Gagnon

Level 37 , Tampa, United States

21 May 2021, 13:51

It sounds like you have a good grasp of those concepts. Here is just one more demonstration for you:

public static void main(String[] args) {
   System.out.println("Creating 2 new unique int arrays:" );
   int[] temp1 = {1, 2, 3}; // new array creation
   int[] temp2 = {1, 2, 3}; // new array creation

   // when passed to toString(), the arrays print their physical address in memory
   System.out.println("Address of temp1 = '" + temp1 + "'" );
   System.out.println("Address of temp2 = '" + temp2 + "'" );

   temp1[1] = 5023; // change one value

   // use Arrays.toString() to get them to print their values
   System.out.println("Values of temp1 = " +Arrays.toString(temp1));
   System.out.println("Values of temp2 = " +Arrays.toString(temp2));

   System.out.println();
   System.out.println("Creating one new array and setting both variables to reference it");

   temp1 = new int[] {1, 2, 3}; // new array creation
   temp2 = temp1; // set temp2 to reference same object as temp 1

   // print address's again, notice they are the same this time
   System.out.println("Address of temp1 = '" + temp1 + "'" );
   System.out.println("Address of temp2 = '" + temp2 + "'" );

   temp1[1] = 99999; // change one value

   // print values. Once again they are the same because they are the same object
   System.out.println("Values of temp1 = " +Arrays.toString(temp1));
   System.out.println("Values of temp2 = " +Arrays.toString(temp2));
}

Naughtless

Level 41 , Olympus Mons, Mars

23 May 2021, 12:28

Thanks! But what about immutable objects? I understand how primitives and objects work (in general, at least), but not immutable objects. From briefly reading descriptions around google, it seems that using as many immutable objects as possible is good, but how does it work exactly? What would be an example of an immutable object?

Guadalupe Gagnon

Level 37 , Tampa, United States

24 May 2021, 13:39

useful

"it seems that using as many immutable objects as possible is good" Not true. There are cases where immutable objects are a better option, but it is a case by case basis. The difference between an immutable object and just a normal one is that immutable objects can't have their state changed after initialization. If you change the state of an immutable object then you are getting a whole new object in return. More code:

public static void main(String[] args) {
   String brk = "****************************";

   System.out.println("\nRegular Class\n" + brk);
   {
      int[] x = {12355};
      int[] y = x;

      System.out.println("Value of x = '" + Arrays.toString(x) + " - Value of y = '" + Arrays.toString(y) + "'");
      System.out.println("Multiplying 'x[0]' by 5");
      x[0] = x[0] * 5;
      System.out.println("Value of x = '" + Arrays.toString(x) + " - Value of y = '" + Arrays.toString(y) + "'\n" + brk);
   }

   System.out.println("Immutable Class\n" + brk);
   {
      Integer x = 12355;
      Integer y = x;

      System.out.println("Value of x = '" + x + " - Value of y = '" + y + "'");
      System.out.println("Multiplying 'x' by 5");
      x = x * 5;
      System.out.println("Value of x = '" + x + " - Value of y = '" + y + "'\n" + brk);
   }
}

An example of using a normal class (an int[] array) and an immutable class (integer). In both examples I create an object for 'x' and set 'y' to point to that same object, and print them to show they are same. In both cases they point to the same object. Next I change the value of 'x' by multiplying it by 5. I finally output the results of the operation. If you compare the outputs you will see with the immutable class that the state of 'y' did not change like the normal object did. Once again, this is because immutable objects can't have their state changed.

Guadalupe Gagnon

Level 37 , Tampa, United States

24 May 2021, 13:43

useful

One last example:

public static void main(String[] args) {
   Integer x = 12355;
   Integer y = x;
   System.out.println(x == y); // outputs true

   y = 12355; // change y's state to equal x's state
   System.out.println(x == y); // outputs false
}

Here 'x' and 'y' are first set to point to the same object. When checking equality between objects instead of primitives, the equality operator '==' checks that the 2 objects are the same, not that their state is the same. The first output indicates that both 'x' and 'y' are referencing the same object. I then change the state of 'y' to 12355, which is the exact state that 'x' is. The next output, checking equality, outputs 'false' because changing the value of 'y' created a whole new object and now the objects that 'x' reference and 'y' reference are not the same.

Naughtless

Level 41 , Olympus Mons, Mars

25 May 2021, 03:50

This explains it perfectly. Thanks!

System.out.println("\nRegular Class\n" + brk);
{
   int[] x = {12355};
   int[] y = x;

   System.out.println("Value of x = '" + Arrays.toString(x) + " - Value of y = '" + Arrays.toString(y) + "'");
   System.out.println("Multiplying 'x[0]' by 5");
   x[0] = x[0] * 5;
   System.out.println("Value of x = '" + Arrays.toString(x) + " - Value of y = '" + Arrays.toString(y) + "'\n" + brk);
}

System.out.println("Immutable Class\n" + brk);
{
   Integer x = 12355;
   Integer y = x;

   System.out.println("Value of x = '" + x + " - Value of y = '" + y + "'");
   System.out.println("Multiplying 'x' by 5");
   x = x * 5;
   System.out.println("Value of x = '" + x + " - Value of y = '" + y + "'\n" + brk);
}