Kotlin的Val和Var


Val and Var in Kotlin

Kotlin中的var和val有什么区别？

我已经浏览了以下链接：

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

如本链接所述：

The full syntax of a read-only property declaration differs from a
mutable one in two ways: it starts with val instead of var and does
not allow a setter.

号

但在前面有一个使用setter的例子。

1
2
3
4
5
6
7
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的确切区别是什么？

为什么我们两者都需要？

这不是Kotlin中变量的重复，与Java的区别。Var与Val？正如我所问的，与文档中的特定示例相关的疑问，而不仅仅是一般疑问。

相关讨论

在您的代码中，result没有更改，其var属性正在更改。参考以下评论：

1
2
3
4
5
6
7
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
}

EDCX1的2Ω与Java中的EDCOX1×3修改器相同。正如您可能知道的那样，我们不能再为final变量赋值，但可以更改其属性。

相关讨论

val和var都用于声明变量。

var is like general variable and it's known as a mutable variable in kotlin and can be assigned multiple times.

val is like Final variable and it's known as immutable in kotlin and can be initialized only single time.

号

更多信息，请参见下面的链接。

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

号

编辑：从"val像常量"到"val像最终值"

相关讨论

用var定义的变量是可变的(读和写)

用val定义的变量是不可变的(只读)

Kotlin可以删除findViewByID并减少Android Studio中setOnClickListener的代码。完整参考：Kotlin Awesome Features

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

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

在值经常变化的地方使用var。例如，在获取Android设备的位置时

1
var integerVariable : Int? = null

。

如果整个类中的值没有变化，则使用val。例如，您希望以编程方式设置文本视图或按钮的文本。

1
val stringVariables : String ="Button's Constant or final Text"
相关讨论

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

  • 必须初始化
  • 无法更改或重新分配值enter image description here。

    • var是一个通用变量。

  • 稍后我们可以使用lateinit修饰符初始化

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

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

    • 氧化镁

    kotlin中的val与java中的final关键字相似。

    Val为immutable，Var为Kotlin中的mutable。

    简单地认为VAL就像Java中的最终变量

    简单地说，var(可变)和VAL(Java中的不可变值(最终修饰符))

    1
    2
    3
    4
    5
    6
    var x:Int=3
    x *= x

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

    。

    你可以很容易地认为：

    var用于setter(值将改变)。

    val用于getter(只读，值不变)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    +----------------+-----------------------------+---------------------------+
    |                |             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;               |
    +----------------+-----------------------------+---------------------------+

    参考

    基本上

    • Var=变量，因此可以更改
    • Val=value，所以不能改变。

      • 小精灵

      In Kotlin val is a read-only property and it can be accessed by a getter only. val is immutable.

      号Val示例：

      1
      2
      val piNumber: Double = 3.1415926
          get() = field

      号

      However, var is a read-and-write property, so it can be accessed not only by a getter but a setter as well. var is mutable.

      号Var示例：

      1
      2
      3
      4
      5
      var gravity: Double = 9.8
          get() = field
          set(value) {
              field = value
          }

      号如果试图更改不可变的Val，则IDE将显示错误：

      1
      2
      3
      4
      5
      6
      fun main() {    
          piNumber = 3.14          // ERROR
          println(piNumber)
      }

      // RESULT:   Val cannot be reassigned

      号但是一个可变的Var可以改变：

      1
      2
      3
      4
      5
      6
      fun main() {    
          gravity = 0.0
          println(gravity)
      }

      // RESULT:   0.0

      号

      希望这有帮助。

      相关讨论

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

      但是如果我们使用var声明变量，那么它将是一个我们可以读写的变量。我们可以改变它的价值。是mutable。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      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初始化。

      相关讨论

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

      • 一个很好的例子，如果它类似于val pi5places=3.14159，那么您可以将其设置为val。是否有可能需要现在或以后更改该变量，然后将其设置为var。

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

      • 这里关于mutable和immutable的回答是好的，但如果这些术语不为人所知或只是学习如何编程，可能会很可怕。

        • 小精灵

        VAL属性与Java中的最终属性类似。您只能为其分配一次值。当您尝试用第二次的值重新分配它时，您将得到一个编译错误。而var属性是可变的，您可以根据自己的意愿随时重新分配它。

        如EDOCX1,25,Variable，ITSELF不能改变，只能读，但EDOCX1,0的性能可以修改；就像其他编程语言中的突变变量。

        可用于申报变量(本地和类别性质)。

        本地变量：

      • 声明阅读-只可变，只能指定一次，但不能重写。

        • Example:

        1
        2
        val readonlyString ="hello"
        readonlyString ="c u" // Not allowed for `val`
      • 如你所知，Java的变量是可读取的(关键词将引入Java 10，"局部变量类型推理")。

        • Example:

        ZZU1

        使用EDOCX1总是比较好。尽量避免，尽量避免

        类别属性：

        两个关键词也被用于命令定义类内的属性。以data class为例：

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

        包括两个领域，其中一个是现实的(EDOCX1&8)。在另一手上，可以通过提供的EDOCX1[…]10，在课后阅读。注：元没有相应的设置方法。

        var–variable–存储在变量中的对象可能会随时间变化(变化)。

        val–value–存储在val中的对象，不能随时间变化。一旦被分配，VAR就变成只读，就像Java编程语言中的常量一样。

        例如：

        1
        2
        3
        4
        5
        6
        7
        8
          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")
            }

        输出：

        1
        2
        Number of hours passed: 3
        Number of hours passed: 13

        号

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

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

        综上所述，VaR可以在任何水平上改变。然而，一旦分配了VAL，就不能更改，但可以更改其属性。

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

        VAL是不可逆转的，最终，第一指定值不能改变。

        1
        2
        3
        val name:String ="andy"

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

        Var是可变异的，可转换的，你可以改变价值。

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

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

        I think the easiest way to remember it :

        val = variable final

        var = variable reassignable, or the opposite of val.

        相关讨论

        两个变量都被用作初始化

        • 如常数变量，可实现，且可改变阀的性能。

        • Var just like a mutable variable.你可以随时改变价值。

        Val变量的值只能赋值一次。

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

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

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

        。

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

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

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

        号

        显然，它的底层属性可以更改，只要它们没有声明为val。

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

        号

        正常的

        • EDOCX1·0是用于EDCOX1，1域，在Java中作为EDCOX1，2

        • 与爪哇中的EDOCX1·1一样/与KOTLIN相同

        • Var表示Kotlin中的变量字段，您可以更改它。

        • 当您希望立即在静态内存中保存值时，通常使用static，

          • 小精灵

          例子：

          1
          2
          3
          4
           if you assign

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

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

            埃多克斯1〔6〕

            b=4U可以更改它

            • 小精灵

            简而言之，VAL变量是最终的(不是可变的)或将来不会改变的常量值。和var变量(可变)将来可以更改。

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

            。

            见上述代码。它是一个模型类，将用于数据传递。我在变量之前设置了VAL，因为这个变量用于获取数据。

            1
            2
            3
            class DeliveryOrderEvent(var d : Delivery)

            // setter and getter is fine here. No error

            。

            另外，如果以后需要设置数据，则需要在变量之前使用var关键字，如果只需要获取一次值，则使用val关键字。

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

            让我们试试这个方法。

            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            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)

            。

            我从编译KOTLIN到Java得到了确切的答案。

            如果你在科特林这样做：

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

            您将获得使用许可：

            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            17
            18
            19
            20
            21
            22
            23
            24
            25
            26
            27
            28
            29
            30
            31
            32
            33
            34
            35
            36
            37
            38
            39
            40
            41
            42
            43
            44
            45
            46
            47
            48
            49
            50
            51
            52
            53
            54
            55
            56
            57
            58
            59
            60
            61
            62
            63
            64
            65
            66
            67
            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;
              }
            }

            。

            您还将获得使用许可证：

            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            17
            18
            19
            20
            21
            22
            23
            24
            25
            26
            27
            28
            29
            30
            31
            32
            33
            34
            35
            36
            37
            38
            39
            40
            41
            42
            43
            44
            45
            46
            47
            48
            49
            50
            51
            52
            53
            54
            55
            56
            57
            58
            59
            60
            61
            62
            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

            当我们想申报一个变量时，都使用了这两种方法。但val和var的区别在于

            当你宣布变量为val时，意味着你不能改变它的价值(它的final)

            Example:

            1
            2
            3
            val value=100

            value=200 //compile time error
          • 当你声明一个变量，如EDOCX1&0时

            • 示例

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

            但以var为例

          • 您可以在声明后初始化变量，但您必须在声明时定义数据类型。

            • Example:

            1
            2
            3
            var value:Int //you can initialize it anytime

            value=100    //initialized here
          • 当需要时，你可以改变它的价值。

            • Example:

            1
            2
            3
            var value=100

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

            Var是一个可变的变量，可以被分配多次时间。而VAL是不可改变的变量，只能在一次时间内起爆。

            (一次初始化不能重写)

            可改变值

            示例

            In Kotlin-Val N=20&Amp N=20

            In Java-FINAL INT N=20& INT N=20；

            Var被用于创建那些变量，这些变量的价值将在您应用的时间范围内改变。这与SWIFT的不同，在SWIFT的不同，在SWIFT的不同之处，在SWIFT的不同之处，在SWIFT的应用中，VAL被用于创建那些值不会改变的变量，它与SWIFT的相同。

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

            Var means variable-if you stored any object using var it could change in time.

            For example:

            1
            2
            3
            4
            5
            6
            7
            fun main(args: Array<String>) {
                var a=12
                var b=13
                var c=12
                a=c+b **//new object 25**
                print(a)
            }

            Val means value-it's like a constant in Java if you stored any object using val it couldn't change in time.

            For example:

            1
            2
            3
            4
            5
            6
            7
            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)
            }

            val(from value)：不可逆转的参考A variable declared with val在它初始化之后重新阅读。在爪哇的变量。

            var(变量)：可变异参考这种变量的价值可以改变。这项宣言是一项经常(非最终)变量。

            我们使用EDOCX1宣布一个变量。这是易变的。我们可以改变，变量。Example，

            1
            2
            3
            4
            5
            6
            7
            fun main(args : Array<String>){
                var x = 10
                println(x)

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

            我们使用公路宣布君士坦丁斯。他们是不可逆转的。无法改变Java变量与EDOCX1类似。Example，

            1
            2
            3
            4
            5
            6
            7
            fun main(args : Array<String>){
                val y = 10
                println(y)

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

            var和其他语言一样是一个变量。如。

            1
            var price: Double

            号

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

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

            而且，

            1
            2
            3
            4
            5
            6
            7
            8
            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

            。

            相关讨论