Arsthbt

I am a beginner in java. When developing a program, I created an object with a constructor with variables as arguments. But when I change the value of the variable after creating the object, my object has the second value instead of the first one. I don't want my object to change the value. What do I do?

public class Person 

public Person(int[] arrayTest) 
 this.arrayTest = arrayTest;

public int[] getArray() 
 return this.arrayTest;

public boolean canHaveAsArray(int[] arrayTest) 
 return true;

private int[] arrayTest = new int[2];

public static void main(String[] args) 
 int[] array = new int[] 5, 10;
 Person obj1 = new Person(array);
 array[0] = 20;
 System.out.println(Arrays.toString(obj1.getArray()));
 
 

My output should be [5, 10], but instead, I am getting [20,10]. I need to get [5,10] even when I change an element of the array as shown above. What should I do?

Array is passed by reference in Java. If you pass the original array to the constructor of Person, you are just passing the reference to the original array and the changes in original array will reflect in Person instance.

So if you don't want to change the value of array in Person so don't pass the original array, instead just send a copy of original array like below:

Person obj1 = new Person(java.util.Arrays.copyOf(array, array.length));

You can also modify the code in Person constructor to achieve the same results:

public Person(int[] arrayTest) 
 this.arrayTest = java.util.Arrays.copyOf(arrayTest, arrayTest.length);

There is no such thing as immutable (unchangeable) array in Java. The Java language does not support this, and neither does the JVM. You can't solve this at the language level.

In general, the only way to prevent changes to an array is to not share the reference to the array with other code that might change it.

In your case, you have what is known as a "leaky abstraction". You are passing an array to your Person class, and keeping a reference to that array so that you can change it. To solve this, you can:

• copy the array, and pass a reference to the copy, or


• have the constructor (or a setter for the array attribute) make the copy.

See answer https://stackoverflow.com/a/55428214/139985 for example code.

The second alternative is preferable from an OO perspective. The Person class should be responsible for preserving its own internal state from interference ... if that is your design requirement. It should not rely on the caller to do this. (Even if the caller is technically part of the same class as is the case here.)