Was ist der Unterschied zwischen varund valin Kotlin?

Ich habe diesen Link durchgesehen:

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

Wie auf diesem Link angegeben:

Die vollständige Syntax einer schreibgeschützten Eigenschaftsdeklaration unterscheidet sich in zweierlei Hinsicht von einer veränderlichen: Sie beginnt mit val anstelle von var und lässt keinen Setter zu.

Aber kurz bevor es ein Beispiel gibt, das einen Setter verwendet.

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
}

Was ist der genaue Unterschied zwischen varund val?

Warum brauchen wir beide?

Dies ist kein Duplikat von Variablen in Kotlin, Unterschiede zu Java. var vs val? Ich frage nach dem Zweifel in Bezug auf das jeweilige Beispiel in der Dokumentation und nicht nur allgemein.

In Ihrem Code resultändert sich nicht, seine varEigenschaften ändern sich. Siehe Kommentare unten:

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
}

valist der gleiche wie der finalModifikator in Java. Wie Sie wahrscheinlich wissen sollten, können wir eine finalVariable nicht erneut zuweisen, sondern ihre Eigenschaften ändern.

valund varbeide werden verwendet, um eine Variable zu deklarieren.

var ist wie eine allgemeine Variable und wird in kotlin als veränderbare Variable bezeichnet. Sie kann mehrfach zugewiesen werden.

val ist wie die endgültige Variable und in kotlin als unveränderlich bekannt. Sie kann nur einmal initialisiert werden.

Weitere Informationen Wie valund varunter Link finden Sie

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

Mit var definierte Variablen sind veränderlich (Lesen und Schreiben)

Mit val definierte Variablen sind unveränderlich (schreibgeschützt)

Kotlin kann findViewById entfernen und den Code für setOnClickListener in Android Studio reduzieren. Als vollständige Referenz: Kotlin fantastische Funktionen

Der Wert veränderbarer Variablen kann jederzeit geändert werden, während der Wert unveränderlicher Variablen nicht geändert werden kann.

wo soll ich var verwenden und wo val?

Verwenden Sie var, wenn sich der Wert häufig ändert. Zum Beispiel beim Abrufen des Standorts des Android-Geräts

var integerVariable : Int? = null

Verwenden Sie val, wenn sich der Wert in der gesamten Klasse nicht ändert. Sie möchten beispielsweise die Textansicht oder den Text der Schaltfläche programmgesteuert festlegen.

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

valVerwenden Sie diese Option, um die endgültige Variable zu deklarieren. Eigenschaften von valVariablen

1. Muss initialisiert werden
2. Wert kann nicht geändert oder neu zugewiesen werden

var ist als allgemeine Variable

1. Wir können später mit initialisieren lateinit Modifikator

   [lateinit auch für globale Variablen verwenden, wir können es nicht für lokale Variablen verwenden]

2. Der Wert kann geändert oder neu zugewiesen werden, jedoch nicht im globalen Bereich

valin kotlinist wie ein finalSchlüsselwort in java

Einfach var (veränderlich) und val (unveränderliche Werte wie in Java (letzter Modifikator))

var x:Int=3
x *= x

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

val ist immutableund var ist mutablein Kotlin.

Denken Sie einfach, dass Val die letzte Variable in Java ist

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

Referenz

Sie können es leicht denken als:

var wird für den Setter verwendet (Wert ändert sich).

val wird für Getter verwendet (schreibgeschützt, Wert ändert sich nicht).

Wenn wir eine Variable mit deklarieren, handelt vales sich um eine schreibgeschützte Variable. Wir können seinen Wert nicht ändern. Es ist wie die letzte Variable von Java . Es ist immutable.

Wenn wir jedoch eine Variable mit deklarieren, ist vardies eine Variable, die wir lesen oder schreiben können . Wir können seinen Wert ändern. Es ist 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
}

valkann in letzter Zeit nicht durch das Schlüsselwort initialisiert werden, lateinitaber nicht primitiv varkann in letzter Zeit durch das Schlüsselwort initialisiert werden lateinit.

Grundsätzlich

• var= variabel , damit es sich ändern kann
• val= Wert , kann sich also nicht ändern.

In Kotlin valist eine schreibgeschützte Eigenschaft, auf die nur ein Getter zugreifen kann. valist unveränderlich.

val Beispiel:

val piNumber: Double = 3.1415926
    get() = field

Da vares sich jedoch um eine Lese- und Schreibeigenschaft handelt , kann nicht nur ein Getter, sondern auch ein Setter darauf zugreifen. varist veränderlich.

var Beispiel:

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

Wenn Sie versuchen, eine unveränderliche valIDE zu ändern , zeigt IDE den folgenden Fehler an:

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

// RESULT:   Val cannot be reassigned 

Aber ein Mutable varkann geändert werden:

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

// RESULT:   0.0

Hoffe das hilft.

Die Eigenschaft val ähnelt der Eigenschaft final in Java. Sie dürfen ihm nur einmal einen Wert zuweisen. Wenn Sie versuchen, es zum zweiten Mal mit einem Wert neu zuzuweisen, wird ein Kompilierungsfehler angezeigt. Während die Eigenschaft var veränderbar ist, können Sie sie jederzeit und zu jeder gewünschten Zeit neu zuweisen.

Müssen Sie eine Variable ändern oder dauerhaft festlegen?

• Ein gutes Beispiel, wenn es so etwas wie val pi5places = 3.14159 ist , würden Sie es als festlegen val. Gibt es eine Möglichkeit, dass Sie diese Variable jetzt oder später ändern müssen, dann würden Sie sie als var festlegen.

• Zum Beispiel: Die Farbe eines Autos kann sein var colorCar = green. Später kannst du das ändern colorCar = blue, wo valdu es nicht kannst.

• Die Antworten hier in Bezug auf mutableund immutablesind in Ordnung, können aber beängstigend sein, wenn diese Begriffe nicht gut bekannt sind oder nur lernen, wie man programmiert.

Der Wert der valVariablen kann nur einmal zugewiesen werden.

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

Sie können den Wert zwar nicht neu zuweisen, aber Sie können die Eigenschaften des Objekts auf jeden Fall ändern.

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

Das heißt, Sie können die Objektreferenz, auf die die Variable zeigt, nicht ändern, aber die zugrunde liegenden Eigenschaften dieser Variablen können geändert werden.

Der Wert für die Variable var kann beliebig oft neu zugewiesen werden.

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

Offensichtlich können die zugrunde liegenden Eigenschaften geändert werden, solange sie nicht als val deklariert sind.

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

Zwei Möglichkeiten zum Erstellen von Variablen in KOTLIN VAL und VAR

1. VAL speichert konstante Werte. Wird auch als endgültige Variable bezeichnet

2. VAR speichert veränderbare Werte

Klicken Sie hier zum Beispiel

valWie eine constantVariable kann sie selbst nicht geändert, sondern nur gelesen werden, aber die Eigenschaften von a valkönnen geändert werden. vargenau wie mutierte Variable in anderen Programmiersprachen.

val ist unveränderlich, endgültig, der erste zugewiesene Wert kann nicht geändert werden.

val name:String = "andy"

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

var ist veränderlich, neu zuweisbar, Sie können den Wert immer wieder ändern.

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

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

Ich denke, der einfachste Weg, sich daran zu erinnern:

val = Variable final

var = Variable neu zuweisbar oder das Gegenteil von val.

Beide valund varkönnen zum Deklarieren von Variablen (lokale und Klasseneigenschaften) verwendet werden.

Lokale Variablen :

1. valdeklariert schreibgeschützte Variablen, die nur einmal zugewiesen, aber nicht neu zugewiesen werden können .

Beispiel:

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

2. vardeklariert neu zuweisbare Variablen, wie Sie sie aus Java kennen (das Schlüsselwort wird in Java 10, "Inferenz lokaler Variablentypen", eingeführt ).

Beispiel:

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

Es ist immer vorzuziehen, zu verwenden val. Versuche varso oft wie möglich zu vermeiden !

Klasseneigenschaften :

Beide Schlüsselwörter werden auch verwendet, um Eigenschaften innerhalb von Klassen zu definieren . Schauen Sie sich als Beispiel Folgendes an data class:

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

Das Personenthält zwei Felder, von denen eines schreibgeschützt ist ( name). Das agekann andererseits nach der Klasseninstanziierung über das bereitgestellte neu zugewiesen werden setter. Beachten Sie, dass namees keine entsprechende Setter-Methode gibt.

Beide Variablen werden als Initialisierung verwendet

• val wie eine konstante Variable. Es kann lesbar sein und die Eigenschaften eines val können geändert werden.

• var genau wie eine veränderbare Variable. Sie können den Wert jederzeit ändern.

Kurz gesagt, die Variable val ist ein endgültiger (nicht veränderbarer) oder konstanter Wert, der in Zukunft nicht mehr geändert wird, und die Variable var (veränderlich) kann in Zukunft geändert werden.

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

Siehe den obigen Code. Es ist eine Modellklasse, die für die Datenübergabe verwendet wird. Ich habe val vor der Variablen gesetzt, weil diese Variable verwendet wurde, um die Daten abzurufen.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Wenn Sie später Daten festlegen müssen, müssen Sie das Schlüsselwort var vor einer Variablen verwenden. Wenn Sie den Wert nur einmal abrufen müssen, verwenden Sie das Schlüsselwort val

Normal

• Valverwendet für staticFeld wie in Java alsStatic Keyword

• Wie Staticin Java / Wie in Kotlin

• Und Var bezeichnet Variablenfeld in Kotlin, das Sie ändern können.

• Meist Static verwendet, wenn Sie den Wert sofort im statischen Speicher speichern möchten.

Beispiel:

 if you assign

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

• Sie können nicht ändern, dies ist Endwert und statisch

  var b=2

  b=4 Du kannst es ändern

val: muss Wert hinzufügen oder initialisieren, kann sich aber nicht ändern. var: Die Variable kann sich in jeder Codezeile ändern.

In Kotlin können wir Variablen in zwei Typen deklarieren: valund var. valkann nicht neu zugewiesen werden, es funktioniert als endgültige Variable.

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

Auf der anderen Seite kann var neu zugewiesen werden, es ist veränderbar

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

Beide sind variabel, der einzige Unterschied besteht darin, dass veränderliche Variable und unveränderliche Variable und es gibt keinen weiteren Unterschied. var ist eine veränderbare Variable und val ist unveränderlich. In der einfachen Sprache kann var den Wert nach der Initialisierung ändern. val ist konstant und kann den Wert nach der Initialisierung des Werts nicht ändern.

val(vom Wert): Unveränderliche Referenz. Eine mit deklarierte Variable valkann nach ihrer Initialisierung nicht neu zugewiesen werden. Es entspricht einer finalVariablen in Java.

var(von Variable): Veränderbare Referenz. Der Wert einer solchen Variablen kann geändert werden. Diese Deklaration entspricht einer regulären (nicht endgültigen) Java-Variablen.

Var bedeutet Variable - Wenn Sie ein Objekt mit 'var' gespeichert haben, kann sich dies mit der Zeit ändern.

Beispielsweise:

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

Val bedeutet Wert - Es ist wie eine 'Konstante' in Java. Wenn Sie ein Objekt mit 'val' gespeichert haben, konnte es sich nicht zeitlich ändern.

Beispielsweise:

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 wird zum Erstellen von Variablen verwendet, deren Wert sich im Laufe der Zeit in Ihrer Anwendung ändert. Es ist dasselbe wie VAR von Swift, während VAL zum Erstellen von Variablen verwendet wird, deren Wert sich im Laufe der Zeit in Ihrer Anwendung nicht ändert. Es ist dasselbe wie LET von Swift.

val - Unveränderlich (einmal initialisiert, kann nicht neu zugewiesen werden)

var - Mutable (kann den Wert ändern)

Beispiel

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

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

var ist eine veränderbare Variable und kann mehrfach zugewiesen werden. val ist eine unveränderliche Variable und kann nur einmal initialisiert werden.