Qual é a diferença entre vare valno Kotlin?

Passei por este link:

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

Conforme indicado neste link:

A sintaxe completa de uma declaração de propriedade somente leitura difere de uma mutável de duas maneiras: começa com val em vez de var e não permite um setter.

Mas, pouco antes, há um exemplo que usa um levantador.

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
}

Qual é a diferença exata entre vare val?

Por que precisamos dos dois?

Esta não é uma duplicata de variáveis ​​no Kotlin, diferenças com o Java. var vs val? como estou perguntando sobre a dúvida relacionada ao exemplo específico na documentação e não apenas em geral.

No seu código resultnão está mudando, suas varpropriedades estão mudando. Consulte os comentários abaixo:

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
}

valé o mesmo que o finalmodificador em java. Como você provavelmente deve saber, não podemos atribuir a uma finalvariável novamente, mas podemos alterar suas propriedades.

vale varambos são usados ​​para declarar uma variável.

var é como variável geral e é conhecida como variável mutável no kotlin e pode ser atribuída várias vezes.

val é como variável final e é conhecido como imutável no kotlin e pode ser inicializado apenas uma vez.

Para mais informações o que é vale varpor favor veja o link abaixo

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

variáveis ​​definidas com var são mutáveis ​​(leitura e gravação)

variáveis ​​definidas com val são imutáveis ​​(somente leitura)

O Kotlin pode remover o findViewById e reduzir o código do setOnClickListener no android studio. Para referência completa: Recursos impressionantes do Kotlin

o valor de variáveis ​​mutáveis ​​pode ser alterado a qualquer momento, enquanto você não pode alterar o valor de variáveis ​​imutáveis.

onde devo usar var e where val?

use var onde o valor está mudando com frequência. Por exemplo, ao obter a localização do dispositivo Android

var integerVariable : Int? = null

use val onde não há alteração de valor em toda a classe. Por exemplo, você deseja definir a visualização de texto ou o texto do botão programaticamente.

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

valuse para declarar a variável final. Características das valvariáveis

1. Deve ser inicializado
2. valor não pode ser alterado ou reatribuir

var é como uma variável geral

1. Podemos inicializar mais tarde usando lateinit modificador

   [lateinit também usar para variável global, não podemos usá-lo para variável local]

2. valor pode ser alterado ou reatribuído, mas não no escopo global

valem kotliné como finalpalavra-chave em java

Simplesmente, var (mutável) e val (valores imutáveis, como em Java (modificador final))

var x:Int=3
x *= x

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

val é immutablee var está mutableem Kotlin.

Simplesmente pense Val como Variável final em 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;               |
+----------------+-----------------------------+---------------------------+

Referência

Você pode pensar facilmente como:

var é usado para o setter (o valor mudará).

val é usado para getter (somente leitura, o valor não muda).

Se declararmos variável usando val, será uma variável somente leitura . Não podemos mudar seu valor. É como a variável final do Java . É immutable.

Mas se declararmos variável usando var, será uma variável que podemos ler ou escrever . Nós podemos mudar seu valor. É 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
}

valnão pode ser inicializado recentemente pela palavra lateinit- chave, mas não primitivo varpode ser inicializado recentemente pela palavra-chave lateinit.

Basicamente

• var= variável , para que possa mudar
• val= value , portanto, não pode mudar.

No Kotlin valé uma propriedade somente leitura e pode ser acessada apenas por um getter. valé imutável.

val exemplo:

val piNumber: Double = 3.1415926
    get() = field

No entanto, varé uma propriedade de leitura e gravação , para que possa ser acessada não apenas por um getter, mas também por um setter. varé mutável.

var exemplo:

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

Se você tentar alterar um imutável val, o IDE mostrará um erro:

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

// RESULT:   Val cannot be reassigned 

Mas um mutável varpode ser alterado:

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

// RESULT:   0.0

Espero que isto ajude.

A propriedade val é semelhante à propriedade final em Java. Você pode atribuir um valor a ele apenas uma vez. Ao tentar atribuí-lo novamente com um valor pela segunda vez, você receberá um erro de compilação. Enquanto a propriedade var é mutável, você pode reatribuí-la quando desejar e quando quiser.

Você precisa alterar uma variável ou defini-la permanentemente?

• Um bom exemplo, se for algo como val pi5places = 3.14159, você definiria como val. Existe a possibilidade de você precisar alterar essa variável agora ou mais tarde e configurá-la como var.

• Por exemplo: A cor de um carro pode ser var colorCar = green. Mais tarde você pode mudar isso colorCar = blue, onde, como val, você não pode.

• As respostas aqui sobre mutablee immutablesão boas, mas podem ser assustadoras se esses termos não forem bem conhecidos ou apenas para aprender a programar.

O valor da valvariável pode ser atribuído apenas uma vez.

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

Embora você não possa reatribuir o valor, certamente pode modificar as propriedades do objeto.

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

Isso significa que você não pode alterar a referência do objeto para a qual a variável está apontando, mas as propriedades subjacentes dessa variável podem ser alteradas.

O valor para a variável var pode ser reatribuído quantas vezes você desejar.

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

Obviamente, suas propriedades subjacentes podem ser alteradas desde que não sejam declaradas como val.

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

Duas maneiras de criar variável no KOTLIN VAL e VAR

1. VAL armazena valores constantes. Também chamada Variável Final

2. VAR armazena valores variáveis

Clique aqui por exemplo

valcomo constantvariável, ela mesma não pode ser alterada, apenas pode ser lida, mas as propriedades de a valpodem ser modificadas; varassim como variável mutante em outras linguagens de programação.

val é imutável, final, o primeiro valor atribuído não pode ser alterado.

val name:String = "andy"

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

var é mutável, reatribuível, você pode alterar o valor repetidamente.

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

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

Eu acho que a maneira mais fácil de lembrar:

val = variável final

var = variável reatribuível ou o oposto de val.

Ambos vale varpodem ser usados ​​para declarar variáveis ​​(propriedades locais e de classe).

Variáveis ​​locais :

1. valdeclara variáveis somente leitura que podem ser atribuídas apenas uma vez, mas não podem ser reatribuídas .

Exemplo:

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

2. vardeclara variáveis transferíveis como você as conhece do Java (a palavra-chave será introduzida no Java 10, “inferência do tipo de variável local” ).

Exemplo:

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

É sempre preferível usar val. Tente evitar o varmais rápido possível!

Propriedades da classe :

As duas palavras-chave também são usadas para definir propriedades dentro das classes . Como exemplo, dê uma olhada no seguinte data class:

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

O Personcontém dois campos, um dos quais é somente leitura ( name). O age, por outro lado, pode ser reatribuído após a instanciação da classe, através do fornecido setter. Observe que namenão terá um método setter correspondente.

Ambas as variáveis ​​são usadas como inicialização

• val como uma variável constante, pode ser legível e as propriedades de um val podem ser modificadas.

• var como uma variável mutável. você pode alterar o valor a qualquer momento.

Em resumo, a variável val é final (não mutável) ou valor constante que não será alterado no futuro e a variável var (mutável) poderá ser alterada no futuro.

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

Veja o código acima. É uma classe de modelo, será usada para passagem de dados. Eu configurei val antes da variável porque essa variável foi usada para obter os dados.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Além disso, se você precisar definir dados posteriormente, precisará usar a palavra-chave var antes de uma variável. Se você precisar obter o valor apenas uma vez, use a palavra-chave val

Normal

• Valestá usando staticcampo como em Java comoStatic Keyword

• Como Staticem Java / Mesmo que em kotlin

• E Vardenota Variable Field no Kotlin que, você pode alterá-lo.

• Principalmente Staticé usado quando você quer salvar o valor na memória estática de uma vez,

Exemplo:

 if you assign

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

• Você não pode mudar, este é o valor final e estático

  var b=2

  b=4 Você pode mudar isso

val: deve adicionar ou inicializar o valor, mas não pode mudar. var: sua variável pode ser alterada em qualquer linha do código.

No kotlin, podemos declarar variável em dois tipos: vale var. valnão pode ser reatribuído, ele funciona como uma variável final.

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

Por outro lado, var pode ser reatribuído, é mutável

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

Ambos são variáveis, a única diferença é que a variável mutável e a variável imutável e não há mais diferença. var é variável mutável e val é imutável. Em linguagem simples, var pode alterar o valor após o valor de inicialização, o valor é constante e não pode ser alterado após a inicialização do valor.

val(do valor): referência imutável. Uma variável declarada com valnão pode ser reatribuída depois de inicializada. Corresponde a uma finalvariável em Java.

var(da variável): referência mutável. O valor dessa variável pode ser alterado. Esta declaração corresponde a uma variável Java regular (não final).

Var significa Variável -Se você armazenou algum objeto usando 'var', ele pode mudar com o tempo.

Por exemplo:

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

Val significa value -É como uma 'constante' em java. Se você armazenou qualquer objeto usando 'val', não pôde mudar com o tempo.

Por exemplo:

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

O VAR é usado para criar as variáveis ​​cujo valor será alterado ao longo do tempo em seu aplicativo. É o mesmo que VAR da swift, enquanto VAL é usado para criar a variável cujo valor não será alterado ao longo do tempo em seu aplicativo. É o mesmo que LET da swift.

val - Imutável (uma vez inicializado, não pode ser reatribuído)

var - Mutável (pode alterar o valor)

Exemplo

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

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

var é uma variável mutável e pode ser atribuída várias vezes e val é uma variável imutável e pode ser inicializada apenas uma vez.