¿Cuál es la diferencia entre vary valen Kotlin?

He pasado por este enlace:

https://kotlinlang.org/docs/reference/properties.html

Como se indica en este enlace:

La sintaxis completa de una declaración de propiedad de solo lectura difiere de una mutable de dos maneras: comienza con val en lugar de var y no permite un setter.

Pero justo antes hay un ejemplo que usa un 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
}

¿Cuál es la diferencia exacta entre vary val?

¿Por qué necesitamos ambos?

Este no es un duplicado de Variables en Kotlin, diferencias con Java. var vs val? ya que estoy preguntando sobre la duda relacionada con el ejemplo particular en la documentación y no solo en general.

En su código resultno está cambiando, sus varpropiedades están cambiando. Consulte los comentarios a continuación:

fun copyAddress(address: Address): Address {
    val result = Address() // result is read only
    result.name = address.name // but not their properties.
    result.street = address.street
    // ...
    return result
}

vales igual que el finalmodificador en java. Como probablemente debería saber, no podemos asignar una finalvariable nuevamente, pero podemos cambiar sus propiedades.

valy varambos se usan para declarar una variable.

var es como una variable general y se conoce como una variable mutable en kotlin y puede asignarse varias veces.

val es como la variable Final y se conoce como inmutable en kotlin y se puede inicializar solo una vez.

Para obtener más información sobre qué es valy varconsulte el siguiente enlace

http://blog.danlew.net/2017/05/30/mutable-vals-in-kotlin/

Las variables definidas con var son mutables (lectura y escritura)

Las variables definidas con val son inmutables (solo lectura)

Kotlin puede eliminar findViewById y reducir el código para setOnClickListener en el estudio de Android. Para referencia completa: características increíbles de Kotlin

El valor de las variables mutables se puede cambiar en cualquier momento, mientras que no se puede cambiar el valor de las variables inmutables.

¿Dónde debo usar var y where val?

use var donde el valor cambia con frecuencia. Por ejemplo, al obtener la ubicación del dispositivo Android

var integerVariable : Int? = null

use val donde no haya cambio de valor en toda la clase. Por ejemplo, desea establecer la vista de texto o el texto del botón mediante programación.

val stringVariables : String = "Button's Constant or final Text"

valse usa para declarar la variable final. Características de las valvariables.

1. Debe ser inicializado
2. el valor no se puede cambiar ni reasignar

var es como una variable general

1. Podemos inicializar más tarde usando un lateinitmodificador

   [ lateinittambién uso para variable global no podemos usarlo para variable local]

2. el valor se puede cambiar o reasignar pero no en el ámbito global

valen kotlines como finalpalabra clave en java

Simplemente, var (mutable) y val (valores inmutables como en Java (modificador final))

var x:Int=3
x *= x

//gives compilation error (val cannot be re-assigned)
val y: Int = 6
y*=y

val es immutabley var está mutableen Kotlin.

Simplemente piense que Val es la variable final en Java

+----------------+-----------------------------+---------------------------+
|                |             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;               |
+----------------+-----------------------------+---------------------------+

Referencia

Puedes pensarlo fácilmente como:

var se utiliza para establecer (el valor cambiará).

val se usa para getter (solo lectura, el valor no cambiará).

Si declaramos variable usando, valentonces será variable de solo lectura . No podemos cambiar su valor. Es como la variable final de Java . Es immutable.

Pero si declaramos variables usando, varentonces será una variable que podremos leer o escribir . Podemos cambiar su valor. Es 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
}

valno se puede inicializar últimamente por la palabra clave, lateinitpero no primitivo varse puede inicializar últimamente por la palabra clave lateinit.

Básicamente

• var= variable , por lo que puede cambiar
• val= valor , por lo que no puede cambiar.

En Kotlin vales una propiedad de solo lectura y solo un getter puede acceder a ella. valEs inmutable.

val ejemplo:

val piNumber: Double = 3.1415926
    get() = field

Sin embargo, vares una propiedad de lectura y escritura , por lo que puede acceder a ella no solo un getter sino también un setter. vares mutable

var ejemplo:

var gravity: Double = 9.8
    get() = field
    set(value) { 
        field = value 
    }    

Si intenta cambiar un elemento inmutable val, IDE le mostrará un error:

fun main() {    
    piNumber = 3.14          // ERROR
    println(piNumber)
}

// RESULT:   Val cannot be reassigned 

Pero una mutable varse puede cambiar:

fun main() {    
    gravity = 0.0
    println(gravity)
}

// RESULT:   0.0

Espero que esto ayude.

La propiedad val es similar a la propiedad final en Java. Se le permite asignar un valor solo por una vez. Cuando intente reasignarlo con un valor por segunda vez, obtendrá un error de compilación. Mientras que la propiedad var es mutable, puede reasignarla cuando lo desee y en cualquier momento que desee.

¿Necesita cambiar una variable o establecerla permanentemente?

• Un buen ejemplo si es algo así como val pi5places = 3.14159 lo configuraría como val. ¿Existe la posibilidad de que necesite cambiar esa variable ahora o más tarde, luego la establecería como var.

• Por ejemplo: el color de un automóvil, puede ser var colorCar = green. Más tarde puedes cambiar eso colorCar = blue, donde como a val, no puedes.

• Las respuestas aquí con respecto a mutabley immutableestá bien, pero pueden dar miedo si estos términos no se conocen bien o simplemente se inicia en aprender a programar.

El valor de la valvariable solo se puede asignar una vez.

val address = Address("Bangalore","India")
address = Address("Delhi","India") // Error, Reassigning is not possible with val

Aunque no puede reasignar el valor, sí puede modificar las propiedades del objeto.

//Given that city and country are not val
address.setCity("Delhi") 
address.setCountry("India")

Eso significa que no puede cambiar la referencia del objeto al que apunta la variable, pero las propiedades subyacentes de esa variable se pueden cambiar.

El valor de la variable var se puede reasignar tantas veces como desee.

var address = Address("Bangalore","India")
address = Address("Delhi","India") // No Error , Reassigning possible.

Obviamente, sus propiedades subyacentes se pueden cambiar siempre que no se declaren val.

//Given that city and country are not val
address.setCity("Delhi")
address.setCountry("India")

Dos formas de crear variables en KOTLIN VAL y VAR

1. VAL almacena valores constantes. También llamada variable final

2. VAR almacena valores modificables

Haga clic aquí por ejemplo

valcomo constantvariable, en sí no se puede cambiar, solo se puede leer, pero valse pueden modificar las propiedades de a ; varal igual que la variable mutante en otros lenguajes de programación.

val es inmutable, final, el primer valor asignado no se puede cambiar.

val name:String = "andy"

name = "thomas" //Error: Val cannot be reassigned

var es mutable, reasignable, puede cambiar el valor una y otra vez.

val a:Int = 1
var b:Int = 1
println("${a + b}") // output 2

b = 4
println("${a + b}") // output 5

Creo que la forma más fácil de recordarlo:

val = variable final

var = variable reasignable, o lo contrario de val.

Ambos, valy varpueden usarse para declarar variables (propiedades locales y de clase).

Las variables locales :

1. valdeclara variables de solo lectura que solo pueden asignarse una vez, pero no pueden reasignarse .

Ejemplo:

val readonlyString = “hello”
readonlyString = “c u” // Not allowed for `val`

2. vardeclara variables reasignables como las conoce de Java (la palabra clave se introducirá en Java 10, "inferencia de tipo de variable local" ).

Ejemplo:

var reasignableString = “hello”
reasignableString = “c u” // OK

Siempre es preferible usar val. ¡Intenta evitarlo con la varmayor frecuencia posible!

Propiedades de clase :

Ambas palabras clave también se utilizan para definir propiedades dentro de las clases . Como ejemplo, eche un vistazo a lo siguiente data class:

data class Person (val name: String, var age: Int)

El Personcontiene dos campos, uno de los cuales es de sólo lectura ( name). El age, por otro lado, puede ser reasignado después de la instanciación de clase, a través de lo proporcionado setter. Tenga en cuenta que nameno tendrá un método de establecimiento correspondiente.

Ambas variables se utilizan como inicialización.

• val como una variable constante, puede ser legible y las propiedades de un val pueden modificarse.

• var como una variable mutable. Puede cambiar el valor en cualquier momento.

En resumen, la variable val es final (no mutable) o un valor constante que no se cambiará en el futuro y la variable var (mutable) se puede cambiar en el futuro.

class DeliveryOrderEvent(val d : Delivery)
// Only getter

Ver el código de arriba. Es una clase de modelo, se utilizará para el paso de datos. He establecido val antes de la variable porque esta variable se usó para obtener los datos.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Además, si necesita establecer datos más tarde, debe usar la palabra clave var antes de una variable, si solo necesita obtener el valor una vez, use la palabra clave val

Normal

• Valestá utilizando para el staticcampo como en Java comoStatic Keyword

• Como Staticen Java / Igual que en Kotlin

• Y Vardenota Campo variable en Kotlin que, puede cambiarlo.

• Principalmente Staticse usa cuando desea guardar valor en la memoria estática a la vez,

Ejemplo:

 if you assign

 val a=1
 a=3  You can not change it 

• No puede cambiar, este es el valor final y estático

  var b=2

  b=4 U puedes cambiarlo

val: debe agregar o valor inicializado pero no puede cambiar. var: es variable, puede cambiar en cualquier línea del código.

En kotlin podemos declarar variables en dos tipos: valy var. valno se puede reasignar, funciona como una variable final.

val x = 2
x=3 // cannot be reassigned

Por otro lado, var se puede reasignar, es mutable

var x = 2
x=3 // can be reassigned

Ambas son variables, la única diferencia es que la variable Mutable y la variable inmutable y no hay nada más de diferencia. var es variable mutable y val es inmutable. En un lenguaje simple, var puede cambiar su valor después de la inicialización. val es constante y no puede cambiar su valor después de inicializar el valor.

val(del valor): referencia inmutable. Una variable declarada con valno se puede reasignar después de que se inicializa. Corresponde a una finalvariable en Java.

var(de variable): referencia mutable. El valor de dicha variable se puede cambiar. Esta declaración corresponde a una variable Java regular (no final).

Var significa Variable: si almacenó algún objeto usando 'var' , podría cambiar con el tiempo.

Por ejemplo:

fun main(args: Array<String>) {
    var a=12
    var b=13
    var c=12
    a=c+b **//new object 25**
    print(a)
}

Val significa valor. Es como una 'constante' en Java. Si almacenó algún objeto usando 'val', no podría cambiar a tiempo.

Por ejemplo:

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)
}

VAR se utiliza para crear aquellas variables cuyo valor cambiará con el tiempo en su aplicación. Es lo mismo que VAR de swift, mientras que VAL se usa para crear aquellas variables cuyo valor no cambiará con el transcurso del tiempo en su aplicación. Es lo mismo que LET de swift.

val: inmutable (una vez inicializado no se puede reasignar)

var - Mutable (puede cambiar el valor)

Ejemplo

en Kotlin - val n = 20 & var n = 20

En Java - final int n = 20; & int n = 20;

var es una variable mutable y se puede asignar varias veces y val es una variable inmutable y se puede inicializar solo una vez.