你需要改变一个变量还是永久设置它?

一个很好的例子，如果它是val pi5places = 3.14159，你会把它设置为val。如果你现在或以后需要改变这个变量，那么你会把它设置为var。 例如:一辆车的颜色，可以是var colorCar = green。之后你可以改变colorCar = blue，作为一个val，你不能。 这里关于可变和不可变的回答很好，但是如果这些术语不是很熟悉或者刚刚开始学习如何编程，可能会很可怕。

Val和var都用于声明变量。

Var就像一般变量，它在kotlin中被称为可变变量，可以被多次赋值。 val类似于Final变量，它在kotlin中是不可变的，只能初始化一次。

有关什么是val和var的更多信息，请参见下面的链接

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

在你的代码中，结果没有改变，它的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中的最终修饰符相同。你应该知道，我们不能再给最终变量赋值，但可以改变它的属性。

通过将Kotlin反编译为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

Val像常量变量一样，本身不能改变，只能读取，但Val的属性可以修改; Var就像其他编程语言中的突变变量一样。

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