Val et du Var en Kotlin

Quelle est la différence entre var et val dans Kotlin?

Je suis passé par ce lien:

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

Comme indiqué sur ce lien:

La syntaxe complète d'une propriété en lecture seule déclaration diffère d'un
mutable l'une de deux façons: il commence avec val au lieu de var et de ne
ne pas permettre à un setter.

Mais juste avant, il est 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 var et val?

Pourquoi avons-nous besoin des deux?

C'est pas un double de Variables dans Kotlin, les différences avec Java. var vs val? que je me suis poser des questions sur le doute liées à l'exemple dans la documentation, et pas seulement en général.

  • result ne peut pas être modifié pour faire référence à une autre instance de Address, mais l'instance, il se réfère à peut être encore modifié. Il en serait de même en Java si vous avez eu une final Address result = new Address();
  • reportez-vous sur cette android-kotlin-débutants.blogspot.dans/2018/02/...
  • Est venu ici pour la réponse parce que la Kotlin site web qui décrit tout d'abord les variables a été trop con de le mentionner, là: kotlinlang.org/docs/reference/basic-syntax.html
InformationsquelleAutor Akshar Patel | 2017-05-26
  1. 176

    Dans votre code result ne change pas, ses var propriétés sont en train de changer. Consultez les 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
}

    val est la même que la final modificateur en java. Comme vous le savez sans doute que nous ne pouvons pas attribuer à un final variable à nouveau, mais peut modifier ses propriétés.

    • val et du var dans la fonction et les classes ou dans le primaire constructeur avoir une signification différente?
    • Non, partout la même.
    • Mais quand j'ai déclarer la variable var dans la classe d'initialisation requise à cause de lui déclarer la propriété. Mais dans la fonction, il n'est pas obligatoire d'initialisation pourquoi?
    • Parce que quand la classe se charge dans la mémoire, ses propriétés obtient également évaluée. Mais en fonction de variables sont évaluées lorsque la fonction de code est exécuté.
    • Sa moyenne à l'intérieur de la fonction ou à l'intérieur de la catégorie de mot-clé val et var sont utilisées pour déclarer les propriétés? pas variable?
    • Je suis confus par la coutume, les méthodes de lecture, par exemple: val size get() = someList.size alors la valeur de la val de la propriété des changements. Comment peut-on concilier avec toutes les réponses à cette question?
    • ses même que la création d'une variable finale et dans les getter retour quelque chose d'autre.
    • peut-être un peu, mais disons que dans java, vous ne serait jamais à créer la variable finale pour commencer, vous voudrais juste écrire de la lecture. Pourquoi kotlin vous permettent de faire cela sur valpourquoi ne pas utiliser autre chose comme certains travaux de construction avec var au lieu

    InformationsquelleAutor chandil03
  2. 102

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

    var est comme général variable et il est connu comme une variable mutable dans kotlin et peuvent être affectés à plusieurs reprises.

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

    Pour plus d'informations, ce qui est val et var veuillez voir le lien ci-dessous

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

    Édité : à Partir de "val est comme Constante" à "val est comme Final"

    • "constant variable" Mes yeux T_T
    • Présente ses excuses pour une erreur.
    InformationsquelleAutor Patel Pinkal
  3. 16

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

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

    Kotlin pouvez supprimer findViewById et réduire le code pour setOnClickListener dans android studio. Pour une référence complète: Kotlin caractéristiques impressionnantes

    valeur mutable variables peuvent être modifiés à tout moment, alors que vous ne pouvez pas changer la valeur de immuable variables.

    où devrais-je utiliser le var et où val ?

    l'utilisation de la var, où la valeur change fréquemment. Par exemple lors de l'obtention de l'emplacement de l'appareil android

    var integerVariable : Int? = null

    utilisation val où il n'y a pas de changement dans la valeur dans l'ensemble de la classe. Par exemple, vous souhaitez définir textview ou du bouton de texte par programmation.

    val stringVariables : String = "Button's Constant or final Text"
    • "Kotlin pouvez supprimer findViewById et réduire le code pour setOnClickListener dans android studio. Pour une référence complète: Kotlin caractéristiques impressionnantes" Comment est-ce pertinent à la question posée?
    • val variables ne sont pas nécessairement immuable. Elles sont définitives -- seule la référence est immuable, mais si l'objet stocké dans le val est mutable, l'objet est mutable, indépendamment de savoir si il est attribué via val ou le var.
    • je ne vois pas l'intérêt d'introduire deux nouveaux mots-clés, bien qu'il pouvait faire beaucoup mieux compréhensible précédemment en Java
    InformationsquelleAutor user6435056
  4. 14

    val utiliser pour déclarer la variable finale. Caractéristiques de val variables

    1. Doit être initialisé
    2. valeur ne peut être modifiée ou de la réaffecter
      Val et du Var en Kotlin

    var est en général variable

    1. Nous pouvons initialiser ultérieurement à l'aide de lateinit modificateur

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

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

    Val et du Var en Kotlin

    val dans kotlin est comme final mot-clé dans java

    InformationsquelleAutor
  5. 10

    val est immutable et var est mutable dans Kotlin.

    InformationsquelleAutor Samir Mangroliya
  6. 9

    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
    InformationsquelleAutor huseyin
  7. 9

    Simplement de penser à Val comme la dernière Variable en java

    InformationsquelleAutor Connecting life with Android
  8. 6

    Vous pouvez facilement penser que c'est l'

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

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

    InformationsquelleAutor Ling Boo
  9. 6
    +----------------+-----------------------------+---------------------------+
|                |             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

    InformationsquelleAutor Joby Wilson Mathews
  10. 6

    Fondamentalement

    • var = variable, de sorte qu'il peut changer
    • val = valeur, de sorte qu'il ne peut pas le changer.
    InformationsquelleAutor Bharat Sonawane
  11. 6

    Dans Kotlin val est un en lecture seule propriété et il peut être consulté par un getter seulement. val est immuable.

    val exemple :

    val piNumber: Double = 3.1415926
    get() = field

    Cependant, var est un de lecture et d'écriture de la propriété, de sorte qu'il peut être accessible non seulement par un getter mais un setter ainsi. var est mutable.

    var exemple :

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

    Si vous essayez de modifier une immuable val, IDE vous montrera erreur :

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

//RESULT:   Val cannot be reassigned

    Mais une mutable var peuvent être modifiés :

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

//RESULT:   0.0

    Espère que cette aide.

    • Merci beaucoup, c'est tellement évident pour moi
    • Vous êtes les bienvenus))
    InformationsquelleAutor ARGeo
  12. 3

    val propriété est similaire à la propriété final 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. Alors que la var de la propriété est mutable qui vous êtes libre de le réaffecter quand vous le désirez et pour une fois que vous voulez.

    InformationsquelleAutor Halil RAŞO
  13. 3

    Si nous déclarons une variable à l'aide de val alors il sera 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 une variable à l'aide de var alors il sera une variable à laquelle 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é dernièrement par le mot-clé lateinit mais non primitif var peut être initialisé dernièrement par le mot-clé lateinit.

    • val et du var dans la fonction et les classes ou dans le primaire constructeur avoir une signification différente?
    InformationsquelleAutor Avijit Karmakar
  14. 3

    Vous avez 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 définissez comme val. Est-il possible que vous deviez modifier cette variable, maintenant ou plus tard, puis vous pouvez définir comme var.

    • Par exemple : La couleur d'une voiture, peut être var colorCar = green. Plus tard, vous pouvez changer le colorCar = blue, où, comme un val, vous ne pouvez pas.

    • Réponses ici sur mutable et immutable est bien, mais peut être effrayant si ces conditions ne sont pas connus ou juste d'entrer dans l'apprentissage de la façon de programmer.

    InformationsquelleAutor teckeon
  15. 1

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

    InformationsquelleAutor suyanlu
  16. 1

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

    Variables locales:

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

    Exemple:

    val readonlyString = “hello”
readonlyString = “c u” //Not allowed for `val`
    1. 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 de var aussi souvent que possible!

    Des propriétés de la classe:

    Les deux mots clés sont également utilisées afin de définir propriétés à l'intérieur des classes. Par exemple, jetez un oeil à la suite de data class:

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

    La Person contient deux champs, qui est en lecture seule (name). Le age, d'autre part, peuvent être réaffectés après l'instanciation de classe, par l'intermédiaire du setter. Notez que name de ne pas avoir un setter correspondant méthode.

    InformationsquelleAutor s1m0nw1
  17. 1

    val est immuable, définitive, la première valeur assignée ne peut pas être modifié.

    val name:String = "andy"

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

    var est mutable, reassignable, vous pouvez modifier la valeur de plus et plus.

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

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

    Je pense que le moyen le plus facile à se rappeler :

    val = variable final

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

    • La Question est à propos de la différence entre les deux, pas de savoir comment différencier un bot. Veuillez passer par dessous le lien qui vous permettra de poster les bonnes réponses, stackoverflow.com/help/how-to-answer
    • Si vous préférez la même réponse, même si beaucoup de gens a été répondu à cela. Et pour certains, de nouvelles personnes à Kotlin, val et du var ont le même son. Si vous avez besoin de leur donner un exemple de la façon de les différencier et de ce qu'ils sont. Mais oui, je vais prendre vos conseils. Merci.
    InformationsquelleAutor Wahyu Anggara Raya
  18. 1

    Les deux variables sont utilisées que l'initialisation

    • val comme une constante de la variable, Il peut être lisible, et les propriétés d'un val peut être modifié.

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

    InformationsquelleAutor Nikhil Katekhaye
  19. 1

    Var – Variable – de L'objet stocké dans la variable peut changer (modifier) dans le temps.

    Val Valeur de L'objet stocké dans le val, ne pouvait pas varier dans le temps. Une fois attribué, le val devient accessible en 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")
    }

    De sortie:

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

    Tandis que si nous réaffecter la valeur à val, puis d'erreur de compilation se produit comme,

    Erreur: – Val ne peut pas être modifiée.

    Alors, pour conclure, var peut être changé à n'importe quel niveau. Alors que val une fois attribué, ne pouvait pas être changé, mais ses propriétés peuvent être modifiées.

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

    InformationsquelleAutor hetsgandhi
  20. 1

    En bref, val variable est définitive (non modifiable) ou la valeur de la constante qui ne seront pas modifiées à l'avenir
    et
    var variable (mutable) peut être modifié à l'avenir. 

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

    Voir le code ci-dessus. C'est un modèle de classe, sera utilisé pour la transmission de 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

    Aussi, si vous avez besoin de mettre des données plus tard, vous devrez utiliser var mot-clé avant une variable, si vous avez seulement besoin d'obtenir la valeur la fois, puis les utiliser val mot-clé

    InformationsquelleAutor Shaon
  21. 1

    De la valeur à val variable peut être attribuée qu'une seule fois.

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

    Si vous ne pouvez pas réaffecter la valeur, mais 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 de l'objet pour lequel la variable est de pointage, mais les propriétés sous-jacentes de cette variable peut être modifiée.

    Valeur à la variable var peut être réaffectés autant de fois que vous le souhaitez.

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

    Évidemment, C'est un sous-tendent les propriétés peuvent être modifiées tant qu'ils ne sont pas déclarées val.

    //Given that city and country are not val
address.setCity("Delhi")
address.setCountry("India")
    InformationsquelleAutor Saurabh Padwekar
  22. 1

    Normal

    • Val pour static domaine comme en Java, comme Static Keyword

    • Comme Static en Java/Même que dans kotlin

    • Et Var désigne la Variable de Champ dans Kotlin, vous pouvez le modifier.

    • Surtout Static est utilisé lorsque vous voulez 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 U peut changer

    InformationsquelleAutor ZafarHussain
  23. 1

    val :
    devez ajouter ou initialisé la valeur, mais ne peuvent pas changer.
    var:
    c'est variable peut ba changement de ligne dans le code.

    InformationsquelleAutor Mohamed Ibrahim
  24. 0

    Les deux sont variables, la seule différence est que Mutable variable et immuable variable et il n'y a rien de plus de différence. var est Mutable variable et val est immuable.Dans un Langage simple, var pouvez changer la valeur après l'initialisation de la valeur val est constante et on ne peut pas changer la valeur après initialisation de la valeur.

    InformationsquelleAutor Nick
  25. 0

    val (de valeur):
    Immuable de référence. Une variable déclarée avec val ne peut pas être
    réaffectés après c'est initialisée. Il correspond à un final variable en Java.

    var (à partir d'une variable):
    Mutable référence. La valeur de cette variable peut être modifiée.
    Cette déclaration correspond à un régulière (non définitif) variable Java.

    InformationsquelleAutor Gulzar Bhat
  26. 0

    val et var les deux sont utilisés lorsque l'on veut déclarer une variable.
    mais la différence entre val et var sont

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

    Exemple:-

    val value=100

value=200 //compile time error
    1. 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
    1. vous pouvez modifier sa valeur à tout moment lorsque nécessaire

    Exemple:-

    var value=100

value= 200 //changed its value and code will compile happily
    InformationsquelleAutor Shubham Mittal
  27. 0

    Var signifie Variable-Si vous avez stocké un objet à l'aide '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 un "constante" de la en java .si vous avez stocké n'importe quel objet à l'aide de '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)
}
    InformationsquelleAutor NHB SOHEL
  28. 0

    VAR est utilisé pour la création de ces variables dont la valeur va changer au cours du temps dans votre application. Il en est de même de VAR de swift, tandis que VAL est utilisé pour la création de ces variable dont la valeur ne changera pas au cours du temps dans votre application.C'est même comme de swift.

    InformationsquelleAutor Ashutosh Shukla
  29. 0

    val - Immuable(une fois initialisée ne peut pas être réaffectés)

    var - Mutables(pouvez pas modifier la valeur)

    Exemple

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

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

    InformationsquelleAutor Najib Ahmed Puthawala
  30. 0

    var est une variable mutable et peuvent être affectés à plusieurs reprises
    et val est immuable variable et peut être initialisée en une seule fois.

    InformationsquelleAutor Yohan Malshika
  31. 0

    Dans Kotlin nous utilisons var de déclarer un variable. Il est mutable. Nous peut changement, réaffecter variables. Exemple,

    fun main(args : Array<String>){
    var x = 10
    println(x)

    x = 100 //vars can reassign.
    println(x)
}

    Nous utilisons val de déclarer constantes. Ils sont immuable. Incapable de changer, réaffecter vals-les-bains. val est quelque chose de semblable à final variables en java. Exemple,

    fun main(args : Array<String>){
    val y = 10
    println(y)

    y = 100 //vals can't reassign (COMPILE ERROR!).
    println(y)
}
    • bonne explication!!!
    InformationsquelleAutor Osusara Kammalawatta
  32. 0

    - Je obtenir la réponse exacte à partir de de-la compilation de Kotlin de Java.

    Si vous le faites en Kotlin:

    data class UsingVarAndNoInit(var name: String)
data class UsingValAndNoInit(val name: String)

    Vous obtiendrez UsingVarAndNoInit:

    package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
public final class UsingVarAndNoInit {
@NotNull private String name;
@NotNull
public final String getName() {
return this.name;
}
public final void setName(@NotNull String string) {
Intrinsics.checkParameterIsNotNull((Object) string, (String) "<set-?>");
this.name = string;
}
public UsingVarAndNoInit(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
this.name = name;
}
@NotNull
public final String component1() {
return this.name;
}
@NotNull
public final UsingVarAndNoInit copy(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
return new UsingVarAndNoInit(name);
}
@NotNull
public static /* bridge */ /* synthetic */ UsingVarAndNoInit copy$default(
UsingVarAndNoInit usingVarAndNoInit, String string, int n, Object object) {
if ((n & 1) != 0) {
string = usingVarAndNoInit.name;
}
return usingVarAndNoInit.copy(string);
}
public String toString() {
return "UsingVarAndNoInit(name=" + this.name + ")";
}
public int hashCode() {
String string = this.name;
return string != null ? string.hashCode() : 0;
}
public boolean equals(Object object) {
block3:
{
block2:
{
if (this == object) break block2;
if (!(object instanceof UsingVarAndNoInit)) break block3;
UsingVarAndNoInit usingVarAndNoInit = (UsingVarAndNoInit) object;
if (!Intrinsics.areEqual((Object) this.name, (Object) usingVarAndNoInit.name)) break block3;
}
return true;
}
return false;
}
}

    Vous obtiendrez également UsingValAndNoInit:

    package classesiiiandiiiobjects.dataiiiclasses.p04variiiandiiival;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
public final class UsingValAndNoInit {
@NotNull private final String name;
@NotNull
public final String getName() {
return this.name;
}
public UsingValAndNoInit(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
this.name = name;
}
@NotNull
public final String component1() {
return this.name;
}
@NotNull
public final UsingValAndNoInit copy(@NotNull String name) {
Intrinsics.checkParameterIsNotNull((Object) name, (String) "name");
return new UsingValAndNoInit(name);
}
@NotNull
public static /* bridge */ /* synthetic */ UsingValAndNoInit copy$default(
UsingValAndNoInit usingValAndNoInit, String string, int n, Object object) {
if ((n & 1) != 0) {
string = usingValAndNoInit.name;
}
return usingValAndNoInit.copy(string);
}
public String toString() {
return "UsingValAndNoInit(name=" + this.name + ")";
}
public int hashCode() {
String string = this.name;
return string != null ? string.hashCode() : 0;
}
public boolean equals(Object object) {
block3:
{
block2:
{
if (this == object) break block2;
if (!(object instanceof UsingValAndNoInit)) break block3;
UsingValAndNoInit usingValAndNoInit = (UsingValAndNoInit) object;
if (!Intrinsics.areEqual((Object) this.name, (Object) usingValAndNoInit.name)) break block3;
}
return true;
}
return false;
}
}

    Il y a d'autres exemples ici: https://github.com/tomasbjerre/yet-another-kotlin-vs-java-comparison

    InformationsquelleAutor Tomas Bjerre
  33. 0

    Permet d'essayer cette façon.

    Val is a Immutable constant 
val change="Unchange" println(change)
//It will throw error because val is constant variable
//change="Change" 
//println(change)
Var is a Mutable constant
var name: String="Dummy"
println(name)
name="Funny"
println(name)
    InformationsquelleAutor
  34. -1

    Val = une varible que vous ne pouvez pas modifier

    Var = une varible que vous pouvez modifier

    InformationsquelleAutor David Wenzel
  35. -6

    var est une variable comme une autre langue.
    par exemple.

    var price: Double

    De l'autre côté, val vous offre la fonctionnalité de référencement.
    par exemple. 

    val CONTINENTS = 7
//You refer this to get constant value 7. In this case, val acts as access
//specifier final in Java

    et, 

    val Int.absolute: Int
get() {
return Math.abs(this)
}
//You refer to the newly create 'method' which provides absolute value 
//of your integer
println(-5.absolute) //O.P: 5
    • Ressemble 4 d'entre eux ne comprennent pas cela.
    InformationsquelleAutor Mukund Desai