Val et Var à Kotlin

val et var sont tous deux utilisés pour déclarer une variable.

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

val est comme constante variable et son connu comme immuable dans kotlin et peut être initialisé qu'une seul fois.

pour plus d'informations qu'est-ce que val et var s'il vous plaît voir ci-dessous lien

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

variables définies avec var sont mutables (lire et écrire)

variables définies avec val sont immuables (lire seulement)

Kotlin peut supprimer findViewById et réduire le code pour setOnClickListener dans android studio. Pour référence complète: Kotlin en vedette

valeur des variables mutables peut être modifié à tout moment, alors que vous ne pouvez pas changer la valeur des variables immuables.

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

utiliser var lorsque la valeur change fréquemment. Par exemple, lors de la localisation de l'appareil android

var integerVariable : Int? = null

utiliser val s'il n'y a pas de changement de valeur dans l'ensemble de la classe. Par exemple, vous voulez définir le texte de textview ou de button de façon programmatique.

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

val utiliser pour déclarer la variable finale. Caractéristiques des variables val 1519100920"

1. doit être initialisé
La valeur
2. ne peut pas être changée ou réattribuée

var est une variable générale

1. nous pouvons initialiser plus tard en utilisant lateinit modificateur

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

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

val dans kotlin est comme final mot clé java

simplement penser Val comme Variable finale en java

simplement, var (mutable) et val (valeurs inaltérables comme en Java (final modificateur))

var x:Int=3
x *= x

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

val est immutable et var est mutable à Kotlin.

vous pouvez facilement le penser comme:

var est utilisé pour le setter (valeur va changer).

val est utilisé pour de lecture (lecture seule, la valeur ne change pas).

val la propriété est similaire à la propriété finale en Java. Vous êtes autorisé à attribuer une valeur seulement pour un temps. Lorsque vous essayez de le réaffecter à une valeur pour la deuxième fois, vous obtiendrez une erreur de compilation. Tandis que la propriété var est mutable que vous êtes libre de la réassigner quand vous le souhaitez et pour toutes les fois que vous voulez.

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

avez-vous besoin de changer une variable ou fixe de façon permanente? Un bon exemple si c'est quelque chose comme" val pi5places = 3.14159 " vous le définiriez comme val. S'il y a une possibilité que vous devez 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 = vert". Plus tard, vous pouvez changer que colorCar = bleu, où en tant que val, vous ne pouvez pas.

réponses ici concernant mutable et immuable est bien, mais peut être effrayant si ces termes ne sont pas bien connus ou juste en train d'apprendre comment programmer.

les Variables sont déclarées en utilisant val ou var , à condition qu'elles soient immuables ou mutables

une chose intéressante de Kotlin est que la plupart du temps vous n'aurez pas besoin de spécifier le type des objets avec lesquels vous travaillez, tant que le compilateur peut le déduire.

donc nous avons juste besoin d'écrire var ou val en fonction du type de variable que nous voulons générer, et le type peut normalement être déduit. Nous pouvons toujours spécifier une type de manière explicite.

Var-Variable-l'objet stocké dans la variable peut changer (varier) dans le temps.

Val-Value-l'objet stocké dans val, ne pouvait pas varier dans le temps. Une fois assignée, la val devient lecture seule, comme une constante dans le langage de programmation Java. Les propriétés de l'objet (Val) peut être changé, mais l'objet lui-même est en lecture seule.

fun main(args: Array<String>) {
val numberOfHoursInDay = 24
print("Number Of Hours Passed for the day : "+numberOfHoursInDay)
// after an hour
numberOfHoursInDay = 25
print("\nNumber Of Hours Passed for the day : "+numberOfHoursInDay)}

sortie:

erreur: (5, 5) Kotlin: Val ne peut pas être réaffecté

nous allons examiner un exemple où nous allons déclarer un objet à val et essayer de changer les valeurs de ses propriétés.

fun main(args: Array<String>) {
    val book = Book("The Last Sun",250)
    print(book)
    book.name = "Incredible Hulk"
    print("\n"+book)
}

data class Book(var name: String = "", var price: Int = 0)

sortie:

Livre (nom=Le Dernier soleil, Prix = 250) Livre(nom=Incroyable Hulk,> prix=250)

si nous déclarons la variable en utilisant val alors ce sera variable en lecture seule variable. Nous ne pouvons pas changer la valeur. C'est comme final variable de Java . C'est immutable .

mais si nous déclarons la variable en utilisant var alors ce sera une variable que nous pouvons lire ou écrire . Nous pouvons changer la valeur. C'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
}

val ne peut pas être initialisé récemment par le mot-clé lateinit mais non-primitif var peut être initialisé récemment par le mot-clé lateinit .

val comme constant variable, elle-même ne peut pas être changée, seulement peut être lu, mais les propriétés d'un val peut être modifié; var comme la variable mutant dans d'autres langages de programmation.

à la fois, val et var peuvent être utilisés pour déclarer des variables (propriétés locales et de classe).

variables locales :

1. val déclare lecture seule variables qui ne peut être attribuée qu'une fois, mais ne peut être réattribué .

exemple:

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

2. var déclare reassignable variables comme vous le savez de Java (le mot-clé sera introduit dans Java 10, "variable locale de l'inférence de type" ).

exemple:

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

Il est toujours préférable d'utiliser val . Essayez d'éviter var aussi souvent que possible!

des propriétés de la Classe :

les deux mots clés sont également utilisés pour définir propriétés à l'intérieur des classes . À titre d'exemple, jetez un coup d'oeil à data class :

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

le Person contient deux champs, dont l'un est readonly ( name ). Le age , d'autre part, peut être réassigné après instanciation de la classe, via le setter fourni . Notez que name n'aura pas de méthode de setter correspondante.

val est immuable, finale, la première valeur attribuée ne peut pas être changée.

val name:String = "andy"

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

var est mutable, réassignable, 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 facile de s'en souvenir:

val = final variable

var = variable reassignable, ou à l'opposé de val.

Var – Variable – l'objet stocké dans la variable peut changer (varier) dans le temps.

Val – valeur – l'objet stocké dans val, ne pouvait pas varier dans le temps. Une fois assigné, le val devient lecture seule, comme une constante dans le langage de programmation Java.

par exemple:

  fun main(args:Array<String>){
        var numberOfHoursPassed=3
        print("Number of hours passed: $numberOfHoursPassed")

        //After 10 hours
        numberOfHoursPassed=13 //value of var can be changed
        print("Number of hours passed: $numberOfHoursPassed")
    }

sortie:

Number of hours passed: 3
Number of hours passed: 13

alors que si nous réaffectons une valeur à val , puis erreur de compilation se produit comme,

: - Val ne peut pas être réaffecté.

ainsi pour conclure, var pourrait être changé à n'importe quel niveau. Alors que val une fois assignée, ne pouvait pas être changée, mais ses propriétés pouvaient être changées.

référence: https://www.tutorialkart.com/kotlin/val-vs-var-in-kotlin /

en bref, val la variable est finale (Non mutable) ou constante valeur qui ne sera pas changée dans le futur et var variable (mutable) peut être modifié à l'avenir.

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

voir le code ci-dessus. Il s'agit d'une classe de modèle, qui sera utilisée pour la transmission des données. J'ai placé val avant la variable parce que cette variable a été utilisée pour obtenir les données.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

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

Normal .

Val utilise pour le champ statique comme en Java comme mot-clé statique

Comme Statique en Java/ Même que dans kotlin

&

Var indique champ Variable dans Kotlin que, vous pouvez le changer .

quasi-Statique est utilisé lorsque vous voulez enregistrer la valeur dans la mémoire statique à la fois,

si vous assignez

val=1 a=3 U ne peut pas changer it

vous ne pouvez pas changer , c'est la valeur finale et Statique

var B=2 b=4 U peut la changer

grand Article pour comprendre val et var à kotlin

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

les deux sont variables la seule différence est que variable Mutable et variable immuable et il n'y a plus de différence. var est variable Mutable et val est immuable.Dans le langage simple var peut changer la valeur est après l'initialisation la valeur val est constante et elle ne peut pas changer la valeur après l'initialisation la valeur.

val (à partir de la valeur): Immuable de référence. Une variable déclarée avec val ne peut pas être réaffecté après avoir été initialisé. Il correspond à une variable final en Java.

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

val et var sont tous deux utilisés lorsque nous voulons déclarer une variable. mais la différence entre val et var sont

1.quand vous déclarez une variable comme val que son immuable, ce qui signifie que vous ne pouvez pas changer sa valeur (son final maintenant comme en java)

exemple: -

val value=100

value=200 //compile time error

2. lorsque vous déclarez une variable comme val que vous devez initialiser la variable au moment de la déclaration

exemple

val value=100 //you have to initialize it here only 

mais dans le cas de var

1. vous pouvez initialiser la variable d'après la déclaration, mais vous devez définir le type de données au moment de la déclaration.

exemple: -

var value:Int //you can initialize it anytime

value=100    //initialized here

2. , vous pouvez modifier sa valeur à tout moment en cas de besoin

exemple: -

var value=100

value= 200 //changed its value and code will compile happily 

les deux variables sont utilisées pour initialiser

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

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

var et val sont des mots-clés qui sont utilisés pour déclarer une variable dans Kotlin. Mais il y a une petite différence entre eux comme mentionné ci-dessous.

var: utilisé pour déclarer une variable mutable. Cela signifie que la valeur de variable peut être changée plusieurs fois.

val: utilisé pour déclarer une variable en lecture seule. Cela signifie qu'une fois que la valeur est assignée à variable, cela ne peut pas être changé plus tard.

val est le même que le mot-clé final dans Java.

Var signifie Variable - si vous avez stocké un objet en utilisant 'var' cela 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 un "constante en java .si vous avez stocké n'importe quel objet en utilisant 'val' il ne pouvait 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 la variable dont la valeur changera au cours du temps dans votre application. Il est identique à VAR de swift, tandis que VAL est utilisé pour créer ces variables dont la valeur ne changera pas au cours du temps dans votre application.C'est comme pour swift.

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

var-Mutable (peut changer de valeur)

exemple

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

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

les deux var et val sont des mots clés qui sont utilisés pour déclarer une variable dans Kotlin. Mais il y a une petite différence entre eux-

var: utilisé pour déclarer une variable mutable. Cela signifie que la valeur d'une variable peut être changée plusieurs fois.

val: utilisé pour déclarer une variable en lecture seule. Cela signifie qu'une fois que la valeur est assignée à une variable, cela ne peut pas être changé plus tard.

val est la même que comme le mot-clé final en Java.

Par Exemple: -

var v1 = 10
v1 = 20 //works fine

val v2 = 15
v2 = 30 //it will show error, "Val cannot be reassigned"

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