Qual'è la differenza tra vare valin Kotlin?

Ho attraversato questo link:

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

Come indicato su questo link:

La sintassi completa di una dichiarazione di proprietà di sola lettura differisce da una mutabile in due modi: inizia con val anziché var e non consente un setter.

Ma poco prima c'è un esempio che 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
}

Qual è la differenza esatta tra vare val?

Perché abbiamo bisogno di entrambi?

Questo non è un duplicato di Variabili in Kotlin, differenze con Java. var vs val? come sto chiedendo riguardo al dubbio relativo al particolare esempio nella documentazione e non solo in generale.

Nel tuo codice resultnon sta cambiando, le sue varproprietà stanno cambiando. Fare riferimento ai commenti seguenti:

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è lo stesso del finalmodificatore in Java. Come probabilmente dovresti sapere che non possiamo assegnare di finalnuovo a una variabile ma possiamo cambiarne le proprietà.

valed varentrambi sono usati per dichiarare una variabile.

var è come una variabile generale ed è nota come variabile mutabile in kotlin e può essere assegnata più volte.

val è come la variabile finale ed è noto come immutabile in kotlin e può essere inizializzato solo una volta.

Per ulteriori informazioni, cos'è vale si varprega di consultare il link qui sotto

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

le variabili definite con var sono mutabili (lettura e scrittura)

le variabili definite con val sono immutabili (sola lettura)

Kotlin può rimuovere findViewById e ridurre il codice per setOnClickListener in Android Studio. Per un riferimento completo: fantastiche funzionalità di Kotlin

il valore delle variabili mutabili può essere modificato in qualsiasi momento, mentre non è possibile modificare il valore delle variabili immutabili.

dove dovrei usare var e dove val?

usa var dove il valore cambia frequentemente. Ad esempio mentre si ottiene la posizione del dispositivo Android

var integerVariable : Int? = null

usa val dove non vi è alcuna variazione di valore nell'intera classe. Ad esempio, si desidera impostare la visualizzazione di testo o il testo del pulsante a livello di codice.

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

valusare per dichiarare la variabile finale. Caratteristiche delle valvariabili

1. Deve essere inizializzato
2. il valore non può essere modificato o riassegnato

var è come una variabile generale

1. Possiamo inizializzare in seguito utilizzando lateinit modificatore

   [lateinit usa anche per variabile globale non possiamo usarlo per variabile locale]

2. il valore può essere modificato o riassegnato ma non nell'ambito globale

valin kotlinè come una finalparola chiave in java

Semplicemente, var (mutabile) e val (valori immutabili come in Java (modificatore finale))

var x:Int=3
x *= x

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

val is immutablee var è mutablea Kotlin.

Pensa semplicemente a Val come la variabile finale in 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;               |
+----------------+-----------------------------+---------------------------+

Riferimento

Puoi facilmente pensarlo come:

var viene utilizzato per il setter (il valore cambierà).

val è usato per getter (sola lettura, il valore non cambierà).

Se dichiariamo variabile usando valallora sarà variabile di sola lettura . Non possiamo cambiarne il valore. È come la variabile finale di Java . Suoimmutable .

Ma se dichiariamo la variabile usando varallora sarà una variabile che possiamo leggere o scrivere . Possiamo cambiare il suo valore. Lo è 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
}

valnon può essere inizializzato di recente dalla parola chiave, lateinitma non primitivo varpuò essere inizializzato di recente dalla parola chiave lateinit.

Fondamentalmente

• var= variabile , quindi può cambiare
• val= valore , quindi non può cambiare.

In Kotlin valè una proprietà di sola lettura ed è accessibile solo da un getter. valè immutabile.

val esempio :

val piNumber: Double = 3.1415926
    get() = field

Tuttavia, varè una proprietà di lettura e scrittura , quindi è possibile accedervi non solo da un getter ma anche da un setter. varè mutevole.

var esempio :

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

Se provi a cambiare un immutabile val, IDE ti mostrerà un errore:

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

// RESULT:   Val cannot be reassigned 

Ma un mutabile varpuò essere cambiato:

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

// RESULT:   0.0

Spero che questo ti aiuti.

La proprietà val è simile alla proprietà finale in Java. Puoi assegnare un valore solo per una volta. Quando si tenta di riassegnarlo con un valore per la seconda volta, viene visualizzato un errore di compilazione. Considerando che la proprietà var è mutevole, che sei libero di riassegnare quando lo desideri e per tutte le volte che vuoi.

Devi modificare una variabile o impostarla in modo permanente?

• Un buon esempio se è qualcosa di simile a val pi5places = 3.14159 lo imposteresti come val. C'è la possibilità che tu debba cambiare quella variabile ora o più tardi, quindi la imposteresti come var.

• Ad esempio: il colore di un'auto può essere var colorCar = green. Più tardi puoi cambiarlo colorCar = blue, dove come val, non puoi.

• Le risposte qui riguardanti mutablee immutablevanno bene, ma possono essere spaventose se questi termini non sono ben conosciuti o se si sta semplicemente imparando a programmare.

Il valore della valvariabile può essere assegnato una sola volta.

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

Sebbene non sia possibile riassegnare il valore ma è possibile modificare sicuramente le proprietà dell'oggetto.

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

Ciò significa che non è possibile modificare il riferimento all'oggetto a cui punta la variabile ma è possibile modificare le proprietà sottostanti di quella variabile.

Il valore della variabile var può essere riassegnato tutte le volte che vuoi.

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

Ovviamente, è possibile modificare le proprietà sottostanti purché non vengano dichiarate val.

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

Due modi per creare variabili in KOTLIN VAL e VAR

1. VAL memorizza valori costanti. Chiamata anche variabile finale

2. VAR memorizza valori modificabili

Clicca qui per esempio

valcome constantvariabile, di per sé non può essere modificato, può solo essere letto, ma le proprietà di a valpossono essere modificate; varproprio come la variabile mutante in altri linguaggi di programmazione.

val è immutabile, finale, il primo valore assegnato non può essere modificato.

val name:String = "andy"

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

var è modificabile, riassegnabile, è possibile modificare il valore più e più volte.

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

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

Penso che il modo più semplice per ricordarlo:

val = variabile finale

var = variabile riassegnabile o l'opposto di val.

Entrambi vale varpossono essere utilizzati per dichiarare variabili (proprietà locali e di classe).

Variabili locali :

1. valdichiara variabili di sola lettura che possono essere assegnate una sola volta, ma non possono essere riassegnate .

Esempio:

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

2. vardichiara variabili riassegnabili quando le conosci da Java (la parola chiave verrà introdotta in Java 10, "inferenza del tipo di variabile locale" ).

Esempio:

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

È sempre preferibile usare val. Cerca di evitare il varpiù spesso possibile!

Proprietà della classe :

Entrambe le parole chiave vengono utilizzate anche per definire le proprietà all'interno delle classi . Ad esempio, dai un'occhiata a quanto segue data class:

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

Il Personcontiene due campi, uno dei quali è readonly ( name). La age, d'altra parte, può essere riassegnato dopo classe istanza, tramite l'apposito setter. Nota che namenon avrà un metodo setter corrispondente.

Entrambe le variabili vengono utilizzate come inizializzazione

• val come una variabile costante, può essere leggibile e le proprietà di una val possono essere modificate.

• var proprio come una variabile mutabile. puoi modificare il valore in qualsiasi momento.

In breve, la variabile val è finale (non modificabile) o il valore costante che non verrà modificato in futuro e la variabile var (mutabile) può essere modificata in futuro.

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

Vedi il codice sopra. È una classe modello, verrà utilizzata per il passaggio di dati. Ho impostato val prima della variabile perché questa variabile è stata utilizzata per ottenere i dati.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Inoltre, se è necessario impostare i dati in un secondo momento, è necessario utilizzare la parola chiave var prima di una variabile, se è necessario ottenere il valore solo una volta, utilizzare la parola chiave val

Normale

• Valsta usando per staticcampo come in Java comeStatic Keyword

• Come Staticin Java / Come in kotlin

• E Varindica Campo variabile in Kotlin che, puoi cambiarlo.

• Principalmente Staticviene utilizzato quando si desidera salvare immediatamente il valore nella memoria statica,

Esempio:

 if you assign

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

• Non puoi cambiare, questo è il valore finale e statico

  var b=2

  b=4 Puoi cambiarlo

val: deve aggiungere o inizializzare un valore ma non può cambiare. var: la sua variabile può essere modificata in qualsiasi riga del codice.

In kotlin possiamo dichiarare la variabile in due tipi: vale var. valnon può essere riassegnato, funziona come una variabile finale.

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

D'altra parte, var può essere riassegnato è mutabile

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

Entrambe sono variabili, l'unica differenza è quella variabile mutabile e variabile immutabile e non c'è più differenza. var è una variabile mutabile e val è immutabile. In linguaggio semplice var può cambiare è valore dopo l'inizializzazione il valore val è costante e non può modificarlo dopo l'inizializzazione del valore.

val(dal valore): riferimento immutabile. Una variabile dichiarata con valnon può essere riassegnata dopo essere stata inizializzata. Corrisponde a una finalvariabile in Java.

var(dalla variabile): riferimento mutabile. Il valore di tale variabile può essere modificato. Questa dichiarazione corrisponde a una normale (non definitiva) variabile Java.

Var significa Variabile -Se hai memorizzato qualsiasi oggetto usando 'var' , potrebbe cambiare nel tempo.

Per esempio:

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

Val significa valore -È come una 'costante' in Java. Se memorizzi qualsiasi oggetto usando 'val', non potrebbe cambiare nel tempo.

Per esempio:

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 viene utilizzato per creare quelle variabili il cui valore cambierà nel corso del tempo nell'applicazione. È lo stesso di VAR di swift, mentre VAL viene usato per creare quella variabile il cui valore non cambierà nel corso del tempo nella tua applicazione. È lo stesso di LET di swift.

val - Immutabile (una volta inizializzato non può essere riassegnato)

var - Mutabile (può cambiare valore)

Esempio

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

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

var è una variabile mutabile e può essere assegnata più volte e val è una variabile immutabile e può essere inizializzata solo una volta.