Quelle est la différence entre varet valà Kotlin?

J'ai parcouru ce lien:

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

Comme indiqué sur ce lien:

La syntaxe complète d'une déclaration de propriété en lecture seule diffère d'une déclaration mutable de deux manières: elle commence par val au lieu de var et ne permet pas de définir.

Mais juste avant il y a un exemple qui utilise 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
}

Quelle est la différence exacte entre varet val?

Pourquoi avons-nous besoin des deux?

Ce n'est pas un doublon de variables dans Kotlin, des différences avec Java. var vs val? car je pose des questions sur le doute lié à l'exemple particulier de la documentation et pas seulement en général.

Dans votre code resultne change pas, ses varpropriétés changent. Reportez-vous aux commentaires ci-dessous:

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
}

valest le même que le finalmodificateur en java. Comme vous devez probablement le savoir, nous ne pouvons plus assigner une finalvariable mais pouvons changer ses propriétés.

valet les vardeux sont utilisés pour déclarer une variable.

var est comme une variable générale et est connue comme une variable mutable dans kotlin et peut être affectée plusieurs fois.

val est comme la variable finale et il est connu comme immuable dans kotlin et ne peut être initialisé qu'une seule fois.

Pour plus d'informations sur ce qu'est valet varveuillez voir le lien ci-dessous

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

les variables définies avec var sont mutables (lecture et écriture)

les variables définies avec val sont immuables (lecture seule)

Kotlin peut supprimer findViewById et réduire le code de setOnClickListener dans le studio Android. Pour une référence complète: fonctionnalités impressionnantes de Kotlin

La valeur des variables modifiables peut être modifiée à tout moment, tandis que vous ne pouvez pas modifier la valeur des variables immuables.

où dois-je utiliser var et où val?

utilisez var où la valeur change fréquemment. Par exemple lors de la localisation de l'appareil Android

var integerVariable : Int? = null

utilisez val où il n'y a pas de changement de valeur dans toute la classe. Par exemple, vous souhaitez définir la vue de texte ou le texte du bouton par programmation.

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

valutiliser pour déclarer la variable finale. Caractéristiques des valvariables

1. Doit être initialisé
2. la valeur ne peut pas être modifiée ou réaffectée

var est une variable générale

1. Nous pouvons initialiser plus tard en utilisant le lateinitmodificateur

   [ lateinitégalement utilisé pour la variable globale, nous ne pouvons pas l'utiliser pour la variable locale]

2. la valeur peut être modifiée ou réaffectée mais pas dans la portée globale

valen kotlinest comme finalmot clé dans java

Simplement, var (mutable) et val (valeurs immuables comme en Java (dernier modificateur))

var x:Int=3
x *= x

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

val est immutableet var est mutableà Kotlin.

Pensez simplement à Val comme variable finale 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;               |
+----------------+-----------------------------+---------------------------+

Référence

Vous pouvez facilement le penser comme:

var est utilisé pour le setter (la valeur changera).

val est utilisé pour getter (lecture seule, la valeur ne changera pas).

Si nous déclarons une variable en utilisant valalors ce sera une variable en lecture seule . Nous ne pouvons pas changer sa valeur. C'est comme la dernière variable de Java . Ça l'est immutable.

Mais si nous déclarons une variable en utilisant varalors ce sera une variable que nous pouvons lire ou écrire . Nous pouvons changer sa valeur. Ça l'est 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
}

valne peut pas être initialisé récemment par le mot-clé lateinitmais non primitif varpeut être initialisé récemment par le mot-clé lateinit.

Fondamentalement

• var= variable , donc il peut changer
• val= valeur , il ne peut donc pas changer.

Dans Kotlin valest une propriété en lecture seule et accessible uniquement par un getter. valest immuable.

val exemple :

val piNumber: Double = 3.1415926
    get() = field

Cependant, varest une propriété en lecture et en écriture , donc elle est accessible non seulement par un getter mais aussi par un setter. varest mutable.

var exemple :

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

Si vous essayez de changer un immuable val, l'IDE vous montrera une erreur:

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

// RESULT:   Val cannot be reassigned 

Mais un mutable varpeut être changé:

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

// RESULT:   0.0

J'espère que cela t'aides.

La propriété val est similaire à la propriété finale en Java. Vous n'êtes autorisé à lui attribuer une valeur qu'une seule fois. Lorsque vous essayez de le réaffecter avec une valeur pour la deuxième fois, vous obtiendrez une erreur de compilation. Alors que la propriété var est modifiable, vous êtes libre de la réaffecter quand vous le souhaitez et à tout moment.

Avez-vous besoin de changer une variable ou de la définir de façon permanente?

• Un bon exemple si c'est quelque chose comme val pi5places = 3.14159 vous le définiriez comme val. Y a-t-il une possibilité que vous deviez changer cette variable maintenant ou plus tard, alors vous la définiriez comme var.

• Par exemple: La couleur d'une voiture peut être var colorCar = green. Plus tard, vous pouvez changer cela colorCar = blue, alors qu'en tant que val, vous ne pouvez pas.

• Les réponses ici concernant mutableet immutableest très bien, mais peuvent être effrayantes si ces termes ne sont pas bien connus ou simplement pour apprendre à programmer.

La valeur de la valvariable ne peut être affectée qu'une seule fois.

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

Bien que vous ne puissiez pas réaffecter la valeur, vous pouvez certainement modifier les propriétés de l'objet.

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

Cela signifie que vous ne pouvez pas modifier la référence d'objet vers laquelle la variable pointe, mais les propriétés sous-jacentes de cette variable peuvent être modifiées.

La valeur de la variable var peut être réaffectée autant de fois que vous le souhaitez.

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

De toute évidence, ses propriétés sous-jacentes peuvent être modifiées tant qu'elles ne sont pas déclarées val.

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

Deux façons de créer une variable dans KOTLIN VAL et VAR

1. VAL stocke des valeurs constantes. Aussi appelé variable finale

2. VAR stocke les valeurs modifiables

Cliquez ici par exemple

valcomme constantvariable, elle-même ne peut pas être changée, seulement peut être lue, mais les propriétés d'un valpeuvent être modifiées; vartout comme la variable mutante dans d'autres langages de programmation.

val est immuable, final, la première valeur affectée ne peut pas être modifiée.

val name:String = "andy"

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

var est mutable, réaffectable, vous pouvez changer la valeur encore et encore.

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

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

Je pense que la façon la plus simple de s'en souvenir:

val = variable finale

var = variable réaffectable, ou l'opposé de val.

Les deux, valet varpeuvent être utilisés pour déclarer des variables (propriétés locales et propriétés de classe).

Variables locales :

1. valdéclare des variables en lecture seule qui ne peuvent être affectées qu'une seule fois, mais ne peuvent pas être réaffectées .

Exemple:

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

2. vardéclare les variables réaffectables telles que vous les connaissez depuis Java (le mot clé sera introduit dans Java 10, «inférence de type de variable locale» ).

Exemple:

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

Il est toujours préférable d'utiliser val. Essayez d'éviter le varplus souvent possible!

Propriétés de classe :

Les deux mots clés sont également utilisés afin de définir des propriétés à l'intérieur des classes . Par exemple, jetez un œil à ce qui suit data class:

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

Le Personcontient deux champs, dont l'un est en lecture seule ( name). Le age, d'autre part, peut être réaffecté après instanciation de classe, via le fourni setter. Notez qu'il namen'y aura pas de méthode de définition correspondante.

Les deux variables sont utilisées comme initialisation

• val comme une variable constante, il peut être lisible et les propriétés d'un val peuvent être modifiées.

• var comme une variable mutable. vous pouvez modifier la valeur à tout moment.

En bref, la variable val est finale (non modifiable) ou une valeur constante qui ne sera pas modifiée à l'avenir et la variable var (modifiable) peut être modifiée à l'avenir.

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

Voir le code ci-dessus. Il s'agit d'une classe modèle, qui sera utilisée pour le passage des données. J'ai mis val avant la variable car cette variable a été utilisée pour obtenir les données.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

De plus, si vous devez définir des données plus tard, vous devez utiliser le mot-clé var avant une variable, si vous n'avez besoin d'obtenir la valeur qu'une seule fois, puis utilisez le mot-clé val

Ordinaire

• Valutilise pour le staticchamp comme en Java commeStatic Keyword

• Comme Staticen Java / Même qu'en kotlin

• Et Vardénote le champ variable dans Kotlin, vous pouvez le changer.

• Surtout Staticest utilisé lorsque vous souhaitez enregistrer la valeur dans la mémoire statique à la fois,

Exemple:

 if you assign

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

• Vous ne pouvez pas changer, c'est la valeur finale et statique

  var b=2

  b=4 Tu peux le changer

val: doit ajouter ou initialiser une valeur mais ne peut pas changer. var: sa variable peut changer dans n'importe quelle ligne de code.

Dans kotlin, nous pouvons déclarer une variable de deux types: valet var. valne peut pas être réaffecté, il fonctionne comme une variable finale.

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

De l'autre côté, var peut être réaffecté il est mutable

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

Les deux sont variables, la seule différence est la variable Mutable et la variable immuable et il n'y a plus de différence. var est une variable Mutable et val est immuable. Dans un langage simple var peut changer sa valeur après la valeur d'initialisation val est constant et il ne peut pas changer sa valeur après l'initialisation de la valeur.

val(à partir de la valeur): référence immuable. Une variable déclarée avec valne peut pas être réaffectée après son initialisation. Il correspond à une finalvariable en Java.

var(à partir d'une variable): référence mutable. La valeur d'une telle variable peut être modifiée. Cette déclaration correspond à une variable Java régulière (non finale).

Var signifie Variable -Si vous avez stocké un objet en utilisant 'var', il pourrait changer dans le temps.

Par exemple:

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

Val signifie valeur - C'est comme une «constante» en java. Si vous avez stocké un objet en utilisant «val», il ne pourrait pas changer dans le temps.

Par exemple:

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 est utilisé pour créer ces variables dont la valeur changera au fil du temps dans votre application. C'est la même chose que VAR de swift, alors que VAL est utilisé pour créer les variables dont la valeur ne changera pas au fil du temps dans votre application. C'est la même chose que LET de swift.

val - immuable (une fois initialisé ne peut pas être réaffecté)

var - Mutable (peut changer la valeur)

Exemple

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

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

var est une variable mutable et peut être affectée plusieurs fois et val est une variable immuable et ne peut être initialisée qu'une seule fois.