在Kotlin中var和val的区别是什么?
我已经通过了这个链接:
属性和字段
如本连结所述:
只读属性声明的完整语法不同于 可变1有两种方式:它以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的确切区别是什么?
为什么我们两者都需要?
这不是Kotlin中的变量的副本，与Java的区别:'var'和。“val”?因为我问的是与文档中的特定例子有关的疑问，而不仅仅是一般的疑问。
当前回答
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)
}
其他回答
你可以简单地把它想成:
Var用于setter(值会改变)。
Val用于getter(只读，值不会改变)。
在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)
}
通过将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声明变量，那么它将是只读变量。我们不能改变它的值。它就像Java的最终变量。它是不可变的。
但如果我们使用var声明变量，那么它将是一个我们可以读或写的变量。我们可以改变它的值。这是可变的。
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初始化，但非原始变量可以最近通过关键字lateinit初始化。
