Kotlin的Val和Var

Question

Kotlin中var和val之间有什么区别？

我已经通过了这个链接：

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

如上所述：

  

只读属性声明的完整语法与a不同   可变的两种方式：它以val而不是var开头   不允许二传手。

但就在有一个使用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
}

var和val之间的确切区别是什么？

为什么我们需要两者？

这是不是Variables in Kotlin, differences with Java. var vs val?的重复，因为我在询问与文档中特定示例有关的疑问，而不仅仅是一般性的。

Answer 1

在您的代码中result没有变化，其var属性正在发生变化。请参阅以下评论：

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与java中的final修饰符相同。您应该知道我们不能再次分配final变量，但可以更改其属性。

Answer 2

val和var都用于声明变量。

  

var 类似于一般变量，它在 kotlin 中称为可变变量，可以多次分配。

     

val 就像最终变量一样，在 kotlin 中称为不可变，只能一次初始化。

有关val和var的更多信息，请参阅以下链接

  

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

已编辑：从“ val 就像常量”到“ val 就像最终< /强>“

Answer 3

用 var定义的变量是可变的（读写）

用 val定义的变量是不可变的（只读）

Kotlin可以删除findViewById并减少android studio中setOnClickListener的代码。完整参考： Kotlin awesome features

可变变量的值可以随时更改，而不能更改不可变变量的值。

我应该在哪里使用var和val？

使用var，其中值经常变化。例如，获取Android设备的位置

var integerVariable : Int? = null

使用val，即全班的价值没有变化。例如，您希望以编程方式设置textview或按钮的文本。

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

Answer 4

val用于声明最终变量。 val变量的特征

1. 必须初始化
2. 值无法更改或重新分配

var是一般变量

1. 我们可以稍后使用lateinit修饰符

   进行初始化

   [lateinit也用于全局变量  我们不能将它用于局部变量]

2. 值可以更改或重新分配，但不能在全局范围内



val中的

kotlin与final中的java关键字相似

Answer 5

Kotlin中的 {strong> immutable 和var为 mutable 。

Answer 6

简单地说， var（mutable）和val（Java中的不可变值（最终修饰符））

var x:Int=3
x *= x

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

Answer 7

简单地认为Val就像java中的final变量

Answer 8

您可以轻松地将其视为：

var用于设置器（值将更改）。

val用于获取getter（只读，值不会改变）。

Answer 9

基本上

• var = 变量，因此它可以更改
• val = 值，因此它不能更改。

Answer 10

  

在Kotlin中， val 是只读属性，只能由吸气剂访问。 val 是不可变的。

val示例：

val piNumber: Double = 3.1415926
    get() = field

  

但是， var 是一种读写属性，因此它不仅可以通过getter进行访问，还可以通过setter进行访问。 var 是可变的。

var示例：

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

如果您尝试更改不可变的val，IDE将显示错误：

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

// RESULT:   Val cannot be reassigned 

但是可以更改易变的var：

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

// RESULT:   0.0

希望这会有所帮助。

Answer 11

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

Reference

Answer 12

如果我们使用val声明变量，那么它将是只读变量。我们不能改变它的价值。它就像 Java 的最终变量。它是immutable。

但是如果我们使用var声明变量，那么它将是一个变量，我们可以读取或写入。我们可以改变它的价值。它是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最近无法通过关键字lateinit进行初始化，但非原始var最近可以通过关键字lateinit进行初始化。

Answer 13

您需要更改变量还是永久设置？

• 一个很好的例子，如果它像 val pi5places = 3.14159 ，你可以将其设置为val。您是否有可能需要立即或稍后更改该变量，然后将其设置为var。

• 例如：汽车的颜色可以是var colorCar = green。稍后您可以更改colorCar = blue，而val则不能更改。

• 此处对mutable和immutable的回复很好，但如果这些术语不为人所知或只是开始学习如何编程，可能会很吓人。

Answer 14

val 属性类似于Java中的final属性。您只能为其分配一次值。当您尝试第二次使用值重新分配时，您将收到编译错误。 var属性是可变的，你可以随意和任何你想要的时间自由重新分配。

Answer 15

将access-control-expose-headers: Set-Cookie 与决赛进行比较是错误的！

val是可变的。var是只读的；是val不能像Java中的最终变量那样重新分配，但是它们会随着时间返回不同的值，因此说它们是不可变的是一种错误；

请考虑以下内容

val

var a = 10
a = 11 //Works as expected

太棒了！

现在考虑以下val b = 10 b = 11 //Cannot Reassign, as expected s

val

因此，var可以对应于Java中的非最终变量，但是val也不完全是最终变量；

尽管kotlin中有val d get() = System.currentTimeMillis() println(d) //Wait a millisecond println(d) //Surprise!, the value of d will be different both times 类似于const，因为它们是编译时间常数，没有自定义getter，但它们仅适用于基本类型

Answer 16

正常

• Val用于static字段，就像Java中的Static Keyword

• 类似于Java中的Static /与kotlin中的

• Var表示Kotlin中的变量字段，您可以对其进行更改。

• 大多数情况下，Static都想在静态存储器中保存值时使用

示例：

 if you assign

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

• 您不能更改，这是最终值和静态值

  var b=2

  b=4您可以更改

Answer 17

简而言之， val 变量是最终的（不可更改）或不变的值，以后不会更改 和 var 变量（可变）将来可以更改。

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

请参见上面的代码。这是一个模型类，将用于数据传递。我已在变量前设置 val ，因为该变量用于获取数据。

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

此外，如果以后需要设置数据，则需要在变量前使用 var 关键字，如果只需要获取一次值，则可以使用 val 关键字< / p>

Answer 18

变量 –变量–变量中存储的对象可能随时间变化（变化）。

Val –值–存储在val中的对象随时间变化。赋值后，val变为只读，就像Java编程语言中的常量一样。

例如：

  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")
    }

输出：

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

如果我们将任何值重新分配给 val ，则会出现编译错误，例如

错误：–无法重新分配Val。

因此，可以得出结论，可以在任何级别上更改var。 val一旦分配，就无法更改，但是其属性可以更改。

参考：https://www.tutorialkart.com/kotlin/val-vs-var-in-kotlin/

Answer 19

val变量的值只能分配一次。

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

尽管您不能重新分配值，但是可以修改对象的属性。

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

这意味着您不能更改变量指向的对象引用，但是可以更改该变量的基础属性。

var变量的值可以根据需要重新分配多次。

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

很明显，只要不将其声明为val，就可以更改其基础属性。

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

Answer 20

val： 必须添加或初始化值，但不能更改。 var： 它的变量可以在代码的任何行中更改。

Answer 21

两个变量都用作初始化

• val类似于常量变量，它可以读取，并且可以修改val的属性。

• var就像一个可变变量。您可以随时更改该值。

Answer 22

val 是不可变的，最终，第一个指定的值无法更改。

val name:String = "andy"

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

var 是可变的，可重新分配，您可以反复更改该值。

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

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

  

我认为最简单的方法就是记住它：

     

val =变量最终

     

var =变量可重新分配，或与val相反。

Answer 23

val类似constant变量，本身无法更改，只能读取，但val的属性可以修改; var就像其他编程语言中的突变变量一样。

Answer 24

在KOTLIN VAL和VAR中创建变量的两种方法

1. VAL 存储常数值。也称为最终变量

2. VAR 存储可变值

Click here for example

Answer 25

val和var都可用于声明变量（本地和类属性）。

本地变量：

1. val声明只能分配一次的只读变量，但无法重新分配。

示例：

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

1. var声明可重新分配的变量，因为您从Java中了解它们（该关键字将在Java 10中引入，“local variable type inference”）。

示例：

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

始终最好使用val。尽量避免var！

类属性：

这两个关键字也用于定义properties inside classes。例如，请查看以下data class：

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

Person包含两个字段，其中一个是只读（name）。另一方面，age可以在类实例化之后通过提供的setter重新分配。请注意，name将没有相应的setter方法。

Answer 26

在Kotlin中，我们有两种类型的变量：var或val。第一个是var，是 可变引用（读写），可以在初始化后进行更新。变种 关键字用于在Kotlin中定义变量。它等效于普通（非最终）Java变量。如果我们的变量需要在某个时间更改，我们应该 使用var关键字声明它。让我们看一个变量的例子 声明：

 fun main(args: Array<String>) {
     var fruit:String = "orange"  // 1
     fruit = "banana"             // 2
 }

Answer 27

让我们尝试这种方式。

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)

Answer 28

在kotlin中，我们可以用两种类型声明变量：val和var。 val无法重新分配，它用作最终变量。

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

另一方面，可以将var重新分配为可变的

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

Answer 29

Var 表示变量 - 如果使用'var'存储任何对象，则可能会及时更改。

例如：

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

Val 表示值 - 就像java中的'常量'。如果使用'val'存储任何对象，则无法更改及时。

例如：

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)
}

Answer 30

我从de-compiling Kotlin to Java得到了确切答案。

如果您在Kotlin中这样做：

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

您将获得 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;
  }
}

您还将获得 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;
  }
}

这里还有更多示例：https://github.com/tomasbjerre/yet-another-kotlin-vs-java-comparison

Answer 31

在Kotlin中，我们使用var来声明变量。它是可变。我们可以更改，重新分配变量。例子

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

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

我们使用val声明常量。它们是不变的。 无法进行更改，重新分配。 val与Java中的final变量相似。例子

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

    y = 100 // vals can't reassign (COMPILE ERROR!).
    println(y)
}

Answer 32

var是一个可变变量，可以多次分配 和val是不可变的变量，只能单次初始化。

Answer 33

val - 不可变（一旦初始化就不能重新分配）

var - Mutable（能够改变值）

示例

在Kotlin - val n = 20＆amp; var n = 20

在Java中 - final int n = 20; ＆安培; int n = 20;

Answer 34

VAR用于创建那些值随着应用程序的变化而变化的变量。它与swift的VAR相同，而VAL则用于创建那些在应用程序中值不会随时间变化的变量。它与swift的LET相同。

Answer 35

当我们想要声明变量时，会使用

val和var。 但val和var之间的区别是

1.当你将一个变量声明为val而不是它的不可变时，这意味着你不能改变它的值（现在它的final就像在java中一样）

实施例： -

val value=100

value=200 //compile time error

1. 当您将变量声明为val时，您必须在声明时初始化变量

实施例

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

但是在var

的情况下
1. 您可以在声明后初始化变量，但必须在声明时定义数据类型。

例如： -

var value:Int //you can initialize it anytime

value=100    //initialized here

1. 您可以在需要时随时更改其值

实施例： -

var value=100

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

Answer 36

val（来自价值）： 不变的参考。用val声明的变量不能 在初始化之后重新分配。它对应于Java中的final变量。

var（来自变量）： 可变参考。可以改变这种变量的值。 该声明对应于常规（非最终）Java变量。

Answer 37

两者都是变量唯一的区别是Mutable变量和不可变变量并没有什么区别。 var是Mutable变量，val是不可变的。在简单语言中var可以在初始化值val为常量后改变，并且在初始化值后不能改变它。

Answer 38

Val 是不可变的，并且其属性是在运行时设置的，但是您可以使用 const 修饰符将其设置为编译时间常数。 Kotlin中的 Val 与Java中的final是相同的。

Var 是可变的，并且其类型是在编译时标识的。

Answer 39

Val =您无法更改的变量

Var =您可以更改的变量

Answer 40

var是一个像任何其他语言一样的变量。 例如

var price: Double

另一方面，val为您提供引用功能。 例如。

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

和，

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