Develop Reference

Java is always pass by value so why am I getting reference when using Array.get(index)? [duplicate]

This question already has answers here:
What's the difference between passing by reference vs. passing by value?
(18 answers)
Is Java "pass-by-reference" or "pass-by-value"?
(93 answers)
Closed 2 years ago.
I was working on this bug in my application and saw something very weird:
selectedService = dataResponse.getServices().get(position);
selectedService.setPrice(3000);
dataResponse.getServices().get(position).getPrice(); // Returns 3000 which should be 0
Shouldn't the get method copy the object into selectedService? If not how to copy it?

No, it shouldn't.
Java is always pass-by-value, but that value itself is a reference. So if you call a method which alters data of that particular object, it is reflected to all methods retrieving data from that particular object.
A possible solution to this problem is to make immutable types. There are classes which already implement this, for instance, all classes from the java.time package are immutable. All 'setters' of those classes return a fresh copy of the instance, with the specified value set. An example may be LocalDate::plusDays.
Here is a little example of the difference between pass-by-value and pass-by-reference.
Take a look at this code.
void main() {
Dog myLittleDog = new Dog("Brutus");
change(myLittleDog);
System.out.println(myLittleDog.getName());
}
void change(Dog aDog) {
aDog = new Dog("Jack");
}
What happens here? We pass our dog named "Brutus" to the change method. Within this method, we replace Brutus with a new Dog named "Jack". If we print the name of myLittleDog, what will be his name? Will it be "Jack"?
The answer is no. The value of the reference to the dog is copied, and is available within the change method under the name aDog. Both myLittleDog and aDog are referring to the same actual dog object in memory. But now the change method reassigns aDog with a new object. At this moment, the variables myLittleDog and aDog both refer to distinct objects. Once the change method exits, the variable aDog is unreachable and Jack is garbage collected. myLittleDog is still called "Brutus".
Conversely, this wouldn't be the case if Java was pass-by-reference. Then reassignment of aDog would also mean reassignment of myLittleDog.
See also: What's the difference between passing by reference vs. passing by value?
But then why is my selectedService still mutated?
Although values of references are copied when they are passed to methods, doesn't that mean that objects cannot change (that is, be modified). Suppose I give you a copy of my house key. You access my house and move the couch to the kitchen. Then if I enter my house, I will see that the couch has been moved. The reference value is copied, but everyone accessing the referenced object (the house), will see modifications to it.

selectedService here is a reference variable which points to whatever object you assign to it. While assigning dataResponse.getServices().get(position) to selectedService it appears as if you're assigning an object to it, however, what you're actually assigning is the reference to the original object.
As quoted on https://www.geeksforgeeks.org/clone-method-in-java-2/
Unlike C++, in Java, if we use assignment operator then it will create a copy of reference variable and not the object
To create a copy of the object
Use the clone() method to create a copy of the object as in
selectedService = (SelectedServiceClass) dataResponse.getServices().get(position).clone();

What is the difference between passing arguments in Java and Python? [duplicate]

This question already has answers here:
Is Java "pass-by-reference" or "pass-by-value"?
(93 answers)
How do I pass a variable by reference?
(39 answers)
Python and Java parameter passing [duplicate]
(1 answer)
Closed 5 years ago.
I come from Java and C++, and now I'm learning Python with this tutorial.
To the best of my knowledge, in Java arguments are passed by value. It seems that they are passed by reference, because when the argument is an object, we pass the reference of the object. So, if inside the called function we change the object state, the object will result modified even after the function call. But, if inside the function we reassign the function parameter we are changing the referenced object, which means that from that point the function's argument will not be affected anymore.
A simple example:
void foo(List<Integer> l){
l.append(1); //affecting list_argument
l = new ArrayList<int>();
l.append(2); //not affecting list_argument
}
public static void main(String[] args){
List<Integer> list_argument = new ArrayList<Integer>();
foo(list_argument); //passing list_argument's reference by value
//list_argument contains 1 only
}
Now, I'm reading this article about passing arguments in Python. In the article, it refers to a fancy name strategy called "passing by object", but to me it seems exactly the mechanism that I described above.
So, my question is: is there any difference the passing argument strategy between Python and Java?

reason: why java is not pass by reference? [duplicate]

This question already has answers here:
Why doesn't java support pass by reference like C++
(2 answers)
Is Java "pass-by-reference" or "pass-by-value"?
(93 answers)
Closed 9 years ago.
Java is strictly pass by value..I am still confused with this concept.
I have gone through many websites to get an answer for this but I am not able to find any good reason.
Is there any proper reason why Java is not pass by reference?

The value of a reference variable is an "address" in Java. When you pass a reference variable to a method, a new reference variable is placed on the stack and a copy of the passed reference variable's value is used to initialize the new local reference varaible's value, just like any primitive type.
That is the classic definition of pass by value.
NOTE: While you can think of the reference as a memory address, it's not. The underlying mechanism makes it act logically as if it were though.
SHORT VERSION: references are simple variables just like the other primitive types for purposes of passing arguments to methods. What you can do with them once passed is obviously different.

Java Arguments Passed To A Method [duplicate]

This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
Is Java “pass-by-reference”?
Pass by value or Pass by reference in Java?
When we pass the arguments to a method inside a java class. Are the parameters passed in By VALUE or BY REFERENCE as default?
There can be two possibilities,
1. if we pass arguments to a method from another method within the same class.
2. if we pass arguments to a method from another class.
Secondly, if i want to pass values by reference (in case default attribute of java is By Value) then what should i do?

Whatever be the case.. Java is PASS BY VALUE and even references are passed by value
and to get more examples here are few interesting links to read out
http://www.javaworld.com/javaqa/2000-05/03-qa-0526-pass.html
How to do the equivalent of pass by reference for primitives in Java Pass by value or Pass by reference in Java?

I am pretty sure that Java is all pass by value. C/C++ is in to passing by reference. As far as working around passing by reference it is quite easy. As with with C, Java has return type methods. You simply place the variable to the left of the assignment ( = ) operator to call of a method that returns what its new value should be. Plus a few other ways.
String name = "Jon Doe";
name = getName();
String getName()
{
//code to get name goes here.
}

Assign an object to null [duplicate]

This question already has answers here:
Is Java "pass-by-reference" or "pass-by-value"?
(93 answers)
Closed 4 years ago.
If I instantiate an object and pass it to an function, in this function I assign this object to null.
It seems when return from the function, the object still there.
I just want to know when I assign null, what happens.

You can never assign to an object. All you ever have are primitives and references. A reference is either null or a pointer to an object of suitable class.
Java arguments are passed by value. Your called method got a copy of a reference. It made that reference null. The calling method has its own reference which was unaffected by any assignments to the passed copy. That reference still points to the object.

Arguments to methods in Java are 'pass-by-value', which means you are passing a copy of the object reference into the method. Assigning this reference a value of null will change its value within the method call, but does nothing to the reference outside the method, since its a copy. Illustrated with code:
void doSomething(final String input) {
input = null;
System.out.println("Input is: " + input); // prints null
return;
}
final String name = "Bob";
doSomething(name);
System.out.println("Name is: " + name); // prints 'Bob'

when you instantiate an object and pass it to a function, and inside the function you reassign that to null or whatever, at the calling side it is not reflected as arguments are pass by value (copy of reference in case of objects), at calling side it'll still point to the old object. If you want to restrict reassigning in a method, you can use final keyword in method parameter

When you pass the object reference to a function(Java always call it method),in the method scope,a new reference is created on stack memory,but they point to the same object in heap memory.So if you assign null to the new reference,Only this reference's link to that object is break,It does not affect the prevous one.