What is the difference between var
and val
in Kotlin?
I have gone through this link:
KotlinLang: Properties and Fields
As stated on this link:
The full syntax of a read-only property declaration differs from a mutable one in two ways: it starts with val instead of var and does not allow a setter.
But just before there is an example which uses a setter.
fun copyAddress(address: Address): Address {
val result = Address() // there's no 'new' keyword in Kotlin
result.name = address.name // accessors are called
result.street = address.street
// ...
return result
}
What is the exact difference between var
and val
?
Why do we need both?
This is not a duplicate of Variables in Kotlin, differences with Java: 'var' vs. 'val'? as I am asking about the doubt related to the particular example in the documentation and not just in general.
This question is related to
kotlin
Var means Variable-If you stored any object using 'var' it could change in time.
For example:
fun main(args: Array<String>) {
var a=12
var b=13
var c=12
a=c+b **//new object 25**
print(a)
}
Val means value-It's like a 'constant' in java .if you stored any object using 'val' it could not change in time.
For Example:
fun main(args: Array<String>) {
val a=12
var b=13
var c=12
a=c+b **//You can't assign like that.it's an error.**
print(a)
}
Normal
Val
is using for static
field like in Java as Static Keyword
Like Static
in Java/ Same as in kotlin
And Var
denotes Variable Field in Kotlin that, you can change it.
Mostly Static
is used when you want to save value in static memory at once,
Example:
if you assign
val a=1
a=3 You can not change it
You can not change, this is final value and Static
var b=2
b=4
U can change it
var is a variable like any other language. eg.
var price: Double
On the other side, val provides you feature of referencing. eg.
val CONTINENTS = 7
// You refer this to get constant value 7. In this case, val acts as access
// specifier final in Java
and,
val Int.absolute: Int
get() {
return Math.abs(this)
}
// You refer to the newly create 'method' which provides absolute value
// of your integer
println(-5.absolute) // O.P: 5
In short, val variable is final (not mutable) or constant value that won't be changed in future and var variable (mutable) can be changed in future.
class DeliveryOrderEvent(val d : Delivery)
// Only getter
See the above code. It is a model class, will be used for data passing. I have set val before the variable because this variable was used to get the data.
class DeliveryOrderEvent(var d : Delivery)
// setter and getter is fine here. No error
Also, if you need to set data later you need to use var keyword before a variable, if you only need to get the value once then use val keyword
val
(from value):
Immutable reference. A variable declared with val
can’t be
reassigned after it’s initialized. It corresponds to a final
variable in Java.
var
(from variable):
Mutable reference. The value of such a variable can be changed.
This declaration corresponds to a regular (non-final) Java variable.
Comparing val
to a final is wrong!
var
s are mutable val
s are read only; Yes val cannot be reassigned just like final variables from Java but they can return a different value over time, so saying that they are immutable is kind of wrong;
Consider the following
var a = 10
a = 11 //Works as expected
val b = 10
b = 11 //Cannot Reassign, as expected
So for so Good!
Now consider the following for val
s
val d
get() = System.currentTimeMillis()
println(d)
//Wait a millisecond
println(d) //Surprise!, the value of d will be different both times
Hence, vars can correspond to nonfinal variables from Java, but val aren't exactly final variables either;
Although there are const
in kotlin which can be like final
, as they are compile time constants and don't have a custom getter, but they only work on primitives
In Kotlin
val
is a read-only property and it can be accessed by a getter only.val
is immutable.
val
example :val piNumber: Double = 3.1415926
get() = field
However,
var
is a read-and-write property, so it can be accessed not only by a getter but a setter as well.var
is mutable.
var
example :var gravity: Double = 9.8
get() = field
set(value) {
field = value
}
val
, IDE will show you error :fun main() {
piNumber = 3.14 // ERROR
println(piNumber)
}
// RESULT: Val cannot be reassigned
var
can be changed :fun main() {
gravity = 0.0
println(gravity)
}
// RESULT: 0.0
Hope this helps.
In Kotlin we use var
to declare a variable. It is mutable. We can change, reassign variables. Example,
fun main(args : Array<String>){
var x = 10
println(x)
x = 100 // vars can reassign.
println(x)
}
We use val to declare constants. They are immutable. Unable to change, reassign vals. val
is something similar to final
variables in java. Example,
fun main(args : Array<String>){
val y = 10
println(y)
y = 100 // vals can't reassign (COMPILE ERROR!).
println(y)
}
Both variables are used as initialising
val like a constant variable, It can be readable, and the properties of a val can be modified.
var just like a mutable variable. you can change the value at any time.
In kotlin we can declare variable in two types: val
and var
.
val
cannot be reassigned, it works as a final variable.
val x = 2
x=3 // cannot be reassigned
On the other side, var can be reassigned it is mutable
var x = 2
x=3 // can be reassigned
Do you need to change a variable or set it permanently?
A good example if it is something like val pi5places = 3.14159 you would set it as val
. Is there a possibility that you need to change that variable now or later, then you would set it as var.
For example : The color of a car, can be var colorCar = green
. Later you can change that colorCar = blue
, where as a val
, you can not.
Responses here regarding mutable
and immutable
is fine, but may be scary if these terms are not well known or just getting into learning how to program.
val property is similar to final property in Java. You are allowed to assign it a value only for one time. When you try to reassign it with a value for second time you will get a compilation error. Whereas var property is mutable which you are free to reassign it when you wish and for any times you want.
Basically
var
= variable, so it can changeval
= value, so it can not change.val
and var
both are used to declare a variable.
var is like general variable and it's known as a mutable variable in kotlin and can be assigned multiple times.
val is like Final variable and it's known as immutable in kotlin and can be initialized only single time.
For more information what is val
and var
please see below link
Both, val
and var
can be used for declaring variables (local and class properties).
Local variables:
val
declares read-only variables that can only be assigned once, but cannot be reassigned.Example:
val readonlyString = “hello”
readonlyString = “c u” // Not allowed for `val`
var
declares reassignable variables as you know them from Java (the keyword will be introduced in Java 10, “local variable type inference”).Example:
var reasignableString = “hello”
reasignableString = “c u” // OK
It is always preferable to use val
. Try to avoid var
as often as possible!
Class properties:
Both keywords are also used in order to define properties inside classes. As an example, have a look at the following data class
:
data class Person (val name: String, var age: Int)
The Person
contains two fields, one of which is readonly (name
). The age
, on the other hand, may be reassigned after class instantiation, via the provided setter
. Note that name
won’t have a corresponding setter method.
Simply, var (mutable) and val (immutable values like in Java (final modifier))
var x:Int=3
x *= x
//gives compilation error (val cannot be re-assigned)
val y: Int = 6
y*=y
Value to val
variable can be assigned only once.
val address = Address("Bangalore","India")
address = Address("Delhi","India") // Error, Reassigning is not possible with val
Though you can't reassign the value but you can certainly modify the properties of the object.
//Given that city and country are not val
address.setCity("Delhi")
address.setCountry("India")
That means you can't change the object reference to which the variable is pointing but the underlying properties of that variable can be changed.
Value to var variable can be reassigned as many times as you want.
var address = Address("Bangalore","India")
address = Address("Delhi","India") // No Error , Reassigning possible.
Obviously, It's underlying properties can be changed as long as they are not declared val.
//Given that city and country are not val
address.setCity("Delhi")
address.setCountry("India")
If we declare variable using val
then it will be read-only variable. We cannot change it's value. It's like final variable of Java. It's immutable
.
But if we declare variable using var
then it will be a variable which we can read or write. We can change it's value. It's mutable
.
data class Name(val firstName: String, var lastName: String)
fun printName(name: Name): Name {
val myName = Name("Avijit", "Karmakar") // myName variable is read only
// firstName variable is read-only.
//You will get a compile time error. Val cannot be reassigned.
myName.firstName = myName.firstName
// lastName variable can be read and write as it's a var.
myName.lastName = myName.lastName
return myName
}
val
cannot be initialized lately by the keyword lateinit
but non-primitive var
can be initialized lately by the keyword lateinit
.
In Kotlin, we have two types of variables: var or val. The first one, var, is a mutable reference (read-write) that can be updated after initialization. The var keyword is used to define a variable in Kotlin. It is equivalent to a normal (nonfinal) Java variable. If our variable needs to change at some time, we should declare it using the var keyword. Let's look at an example of a variable declaration:
fun main(args: Array<String>) {
var fruit:String = "orange" // 1
fruit = "banana" // 2
}
I get the exact answer from de-compiling Kotlin to Java.
If you do this in Kotlin:
data class UsingVarAndNoInit(var name: String)
data class UsingValAndNoInit(val name: String)
You will get UsingVarAndNoInit:
package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
public final class UsingVarAndNoInit {
@NotNull private String name;
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String string) {
Intrinsics.checkParameterIsNotNull((Object) string, (String) "<set-?>");
this.name = string;
}
public UsingVarAndNoInit(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
this.name = name;
}
@NotNull
public final String component1() {
return this.name;
}
@NotNull
public final UsingVarAndNoInit copy(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
return new UsingVarAndNoInit(name);
}
@NotNull
public static /* bridge */ /* synthetic */ UsingVarAndNoInit copy$default(
UsingVarAndNoInit usingVarAndNoInit, String string, int n, Object object) {
if ((n & 1) != 0) {
string = usingVarAndNoInit.name;
}
return usingVarAndNoInit.copy(string);
}
public String toString() {
return "UsingVarAndNoInit(name=" + this.name + ")";
}
public int hashCode() {
String string = this.name;
return string != null ? string.hashCode() : 0;
}
public boolean equals(Object object) {
block3:
{
block2:
{
if (this == object) break block2;
if (!(object instanceof UsingVarAndNoInit)) break block3;
UsingVarAndNoInit usingVarAndNoInit = (UsingVarAndNoInit) object;
if (!Intrinsics.areEqual((Object) this.name, (Object) usingVarAndNoInit.name)) break block3;
}
return true;
}
return false;
}
}
You will also get UsingValAndNoInit:
package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
public final class UsingValAndNoInit {
@NotNull private final String name;
@NotNull
public final String getName() {
return this.name;
}
public UsingValAndNoInit(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
this.name = name;
}
@NotNull
public final String component1() {
return this.name;
}
@NotNull
public final UsingValAndNoInit copy(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
return new UsingValAndNoInit(name);
}
@NotNull
public static /* bridge */ /* synthetic */ UsingValAndNoInit copy$default(
UsingValAndNoInit usingValAndNoInit, String string, int n, Object object) {
if ((n & 1) != 0) {
string = usingValAndNoInit.name;
}
return usingValAndNoInit.copy(string);
}
public String toString() {
return "UsingValAndNoInit(name=" + this.name + ")";
}
public int hashCode() {
String string = this.name;
return string != null ? string.hashCode() : 0;
}
public boolean equals(Object object) {
block3:
{
block2:
{
if (this == object) break block2;
if (!(object instanceof UsingValAndNoInit)) break block3;
UsingValAndNoInit usingValAndNoInit = (UsingValAndNoInit) object;
if (!Intrinsics.areEqual((Object) this.name, (Object) usingValAndNoInit.name)) break block3;
}
return true;
}
return false;
}
}
There are more examples here: https://github.com/tomasbjerre/yet-another-kotlin-vs-java-comparison
variables defined with var are mutable(Read and Write)
variables defined with val are immutable(Read only)
Kotlin can remove findViewById and reduce code for setOnClickListener in android studio. For full reference: Kotlin awesome features
value of mutable variables can be changed at anytime, while you can not change value of immutable variables.
where should I use var and where val ?
use var where value is changing frequently. For example while getting location of android device
var integerVariable : Int? = null
use val where there is no change in value in whole class. For example you want set textview or button's text programmatically.
val stringVariables : String = "Button's Constant or final Text"
Simply think Val like final Variable in java
val
like constant
variable, itself cannot be changed, only can be read, but the properties of a val
can be modified;
var
just like mutant variable in other programming languages.
val - Immutable(once initialized can't be reassigned)
var - Mutable(can able to change value)
Example
in Kotlin - val n = 20 & var n = 20
In Java - final int n = 20; & int n = 20;
val is immutable
and var is mutable
in Kotlin.
Val is immutable and its properties are set at run time, but you can use a const modifier to make it as a compile time constant. Val in kotlin is same as final in java.
Var is mutable and its type is identified at compile time.
var is a mutable variable and can be assigned multiple times and val is immutable variable and can be intialized only single time.
VAR is used for creating those variable whose value will change over the course of time in your application. It is same as VAR of swift, whereas VAL is used for creating those variable whose value will not change over the course of time in your application.It is same as LET of swift.
Lets try this way.
Val is a Immutable constant
val change="Unchange" println(change)
//It will throw error because val is constant variable
// change="Change"
// println(change)
Var is a Mutable constant
var name: String="Dummy"
println(name)
name="Funny"
println(name)
val : must add or initialized value but can't change. var: it's variable can ba change in any line in code.
Two ways to create variable in KOTLIN VAL and VAR
1.VAL stores constant values. Also called Final Variable
2.VAR stores Changeable Values
val is immutable, final, the first assigned value cannot be changed.
val name:String = "andy"
name = "thomas" //Error: Val cannot be reassigned
var is mutable, reassignable, you can change the value over and over.
val a:Int = 1
var b:Int = 1
println("${a + b}") // output 2
b = 4
println("${a + b}") // output 5
I think the easiest way to remember it :
val = variable final
var = variable reassignable, or the opposite of val.
+----------------+-----------------------------+---------------------------+
| | val | var |
+----------------+-----------------------------+---------------------------+
| Reference type | Immutable(once initialized | Mutable(can able to change|
| | can't be reassigned) | value) |
+----------------+-----------------------------+---------------------------+
| Example | val n = 20 | var n = 20 |
+----------------+-----------------------------+---------------------------+
| In Java | final int n = 20; | int n = 20; |
+----------------+-----------------------------+---------------------------+
Both are variable the only difference is that Mutable variable and immutable variable and there is nothing more difference. var is Mutable variable and val is immutable.In simple Language var can change is value after initialization value val is constant and it cannot change it value after initialization the value.
You can easily think it as:
var
is used for setter (value will change).
val
is used for getter (read-only, value won't change).
val
use to declare final variable. Characteristics of val
variables
var
is as a general variable
We can initialize later by using lateinit
modifier
[lateinit
also use for global variable
we can not use it for local variable]
val
in kotlin
is like final
keyword in java
Source: Stackoverflow.com