Is Kotlin "pass-by-value" or "pass-by-reference"?

Java passes a copy (pass-by-value) of the reference (pass-by-reference). I would say Kotlin does the same as it is a JVM-based language.

UPDATE

OK, so it's been a while since this answer and I think some clarification should be included. As @robert-liberatore is mentioning in the comments, the behaviour I'm describing is true for objects. Whenever your methods expect any object, you can assume that the JVM internally will make a copy of the reference to the object and pass it to your method. That's why having code like

void doSomething(List<Integer> x) { x = new ArrayList<Integer>() } List<Integer> x = Arrays.asList(1, 2, 3); doSomething(x); x.length() == 3 

behaves like it does. You're copying the reference to the list, so "reassigning it" will take no effect in the real object. But since you're referring to the same object, modifying its inner content will affect the outer object.

This is something you may miss when defining your attributes as final in order to achieve immutability. You won't be able to reassign them, but there's nothing preventing you from changing its contents.

Of course, this is true for objects where you have a reference. In the case of primitives, which are not a reference to an object containing something but rather "something" themselves, it's different. Java will still make a copy of the whole value (as it does with the whole reference) and pass it to the method. But primitives are just values, you can't "modify its inner values". So any change inside a method will have no effect in the outer values.

Now, talking about Kotlin

In Kotlin you "don't have" primitive values. But you "do have" primitive classes. Internally, the compiler will try to use JVM primitive values where needed, but you can assume that you are always working with the boxed version of the JVM primitives. Because of that, when possible the compiler will just make a copy of the primitive value and, in other scenarios, it will copy the reference to the object.

Or with code:

fun aJvmPrimitiveWillBeUsedHere(x: Int): Int = x * 2 fun aJvmObjectWillBeUsedHere(x: Int?): Int = if (x != null) x * 2 else 1 

I'd say that the Kotlin scenario is a bit safer than Java because it forces its arguments to be final. So you can modify its inner content but not reassign it:

fun doSomething(x: MutableList<Int>) { x.add(2) // this works, you can modify the inner state x = mutableListOf(1, 2) // this doesn't work, you can't reassign an argument } 

The semantics is identical to Java.

In Java, when you have an instance of an object, and you pass it to a method, that method can change the state of that object, and when the method is done, the changes would have been applied to the object at the call site.

The same applies in Kotlin.

For all basic types except for Arrays, the value is passed. For the rest, a reference to the object is passed.

Note: basic type are colloquially known as "primitives", though they are actually objects in Kotlin.

I'll explain with two examples:

The code:

fun main() { var a = 5 var b = a a = 6 println("b = $b") } 

prints: b = 5. Kotlin passes the value of a to b because a is a "primitive". So changing a afterwards won't impact b.

The code:

fun main() { var a = Dog(5) var b = a a.value = 6 println("b = ${b.value}") } class Dog (var value: Int) 

prints b = 6 because this time a is not a "primitive", and so the reference to the object (Dog) was passed to b instead of its value. Therefore, changing a would affect all objects that point to it.

In summary, Numbers (Byte, Short, Int, Long), Booleans, Characters and Strings are pass-by-value. All the rest are pass-by-reference.

In Java primitive types like int, float, double, boolean are passed to a method by value, if you modify them inside the receiver method they doesn't change into the calling method. But if the property/variable type isn't a primitive, like arrays of primitives or other classes when they are changed inside the method that receive them as parameter they also change in the caller method. But with Kotlin nothing seems to be primitive, so I think all is passed by reference.

This might be a little bit confusing. The correct answer, IMHO, is that everything passes by reference, but no assignment is possible so it will be similar to passing by value in C++.

Note that function parameters are constant, i.e., they cannot be assigned.

Remember that in Kotlin there are no primitive types. Everything is an object. When you write:

var x: Int = 3 x += 10 

You actually create an object of type Int, assign it the value 3, and get a reference, or pointer, named x. When you write

x += 10 

You reassign a new Int object, with the value 13, to x. The older object becomes a garbage (and garbage-collected).

Of course, the compiler optimizes it, and creates no objects in the heap in this particular case, but conceptually it is as explained.

So what is the meaning of passing by reference function parameters?

• Since no assignment is possible for function parameters, the main advantage of passing by reference in C++ does not exist in Kotlin.
• If the object (passed to the function) has a method which changes its internal state, it will affect the original object.
  • No such method exists for Int, String, etc. They are immutable objects.
• No copy is ever generated when passing objects to functions.

In Kotlin, objects are passed by reference-to-const. It means that the reference to the object is passed to the function, but the function cannot modify the original reference to point to a different object. However, the contents of the object (if it's mutable) can be modified.

Bear in mind, am quite new to Kotlin. In my opinion, primitives are passed-by-value, but objects are passed-by-reference.

A primitive passed to a class works by default, but if you pass an object from a list, for example, and that object changes, the class object changes too. Because, in fact, it is the same object.

Additionally, if objects gets removed from the list, the class object IS STILL A REFERENCE. So it can still change due to references in other places.

Example below explaines. You can run it here.

fun main() { val listObjects = mutableListOf(ClassB(), ClassB(), ClassB()) val listPrimitives = mutableListOf(111, 222, 333) val test = ClassA() test.ownedObject = listObjects[0] test.ownedPrimitive = listPrimitives[0] println("ownedObject: " + test.ownedObject.isEnabled +", ownedPrimitive: " + test.ownedPrimitive) listObjects[0].isEnabled = true println("ownedObject: " + test.ownedObject.isEnabled +", ownedPrimitive: " + test.ownedPrimitive) listPrimitives[0] = 999 println("ownedObject: " + test.ownedObject.isEnabled +", ownedPrimitive: " + test.ownedPrimitive) } class ClassA { var ownedObject: ClassB = ClassB() var ownedPrimitive: Int = 0 } class ClassB { var isEnabled = false } 

Send instance of first class to second class and then you can change all public variable of first class.

class MainActivity : AppCompatActivity() { lateinit var _myClassA: ClassA var x:Int=0 lateinit var _myClassB: ClassB override fun onCreate(...) { ... _myClassB=ClassB() _myClassB.setValue(this) } } 

and in ClassB

class ClassB() { fun setValue(mainActivity:MainActivity){ mainActivity._myClassA=ClassA()//and you can change you want on this class a as reference value mainActivity.x+=10 } }