var和valKotlin 和有什么不一样？

我已经通过这个链接：

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

如该链接所述：

只读属性声明的完整语法在两个方面不同于可变的声明：它以val而不是var开头，并且不允许使用setter。

但就在之前，有一个使用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 vs val？我在问与文档中特定示例相关的疑问，而不仅仅是一般情况。

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

val和var两个用于声明的变量。

var就像一般变量一样，在kotlin中被称为可变变量，可以多次分配。

val类似于Final变量，在kotlin中被称为不可变的，并且只能一次初始化。

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

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

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

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

Kotlin可以删除android Studio中的findViewById并减少setOnClickListener的代码。有关完整参考： Kotlin的出色功能

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

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

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

var integerVariable : Int? = null

在整个类中值没有变化的地方使用val。例如，您要以编程方式设置textview或button的文本。

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

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

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

var 作为一般变量

1. 我们可以稍后使用进行初始化 lateinit修饰符进行

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

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

val在kotlin就像 final关键字在 java

简单来说，var（可变）和val（不可变值，例如Java（最终修饰符））

var x:Int=3
x *= x

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

val is immutable和var mutable位于Kotlin。

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

+----------------+-----------------------------+---------------------------+
|                |             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 用于吸气剂（只读，值不会改变）。

如果我们使用声明变量，val则它将是只读变量。我们无法改变它的价值。就像Java的final变量一样。是。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。

基本上

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

在Kotlin val中，它是一个只读属性，并且只能由getter访问。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

希望这可以帮助。

val属性类似于Java中的final属性。您只能为它分配一个值。当您尝试第二次使用值重新分配它时，会出现编译错误。var属性是可变的，您可以随时随地随意分配它。

您是否需要更改变量或将其永久设置？

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

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

• 这里的回答关于mutable，immutable很好，但是如果这些术语不是众所周知的或者只是开始学习编程的话，可能会令人恐惧。

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

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

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

2. VAR存储可变值

点击这里举例

val像constant变量一样，本身不能更改，只能读取，但是a的属性val可以修改； var就像其他编程语言中的变量一样。

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相反。

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

局部变量：

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

例：

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

2. var声明您从Java知道的可重分配变量（该关键字将在Java 10中引入，“局部变量类型推断”）。

例：

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

总是最好使用val。尽量避免回避var！

类属性：

为了在类内部定义属性，还使用了两个关键字。例如，请看以下内容data class：

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

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

这两个变量都用作初始化

• val就像常量变量一样，可以读取，并且可以修改val的属性。

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

简而言之，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关键字

正常

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

• 像Static在Java中一样/与kotlin中一样

• 并Var在Kotlin中表示“变量字段”，您可以更改它。

• 通常Static在您想一次将值保存在静态内存中时使用，

例：

 if you assign

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

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

  var b=2

  b=4 你可以改变它

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

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

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

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

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

两者都是变量，唯一的区别是可变变量和不可变变量，仅此而已。var是可变变量，而val是不可变的。在简单的语言中，var可以在初始化值之后更改为val值是常数，并且在初始化值后无法更改其值。

val（根据值）：不可变的引用。声明为的变量val在初始化后无法重新分配。它对应final于Java中的变量。

var（来自变量）：可变引用。此类变量的值可以更改。此声明对应于常规（非最终）Java变量。

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用于创建那些变量，其值将随应用程序的变化而变化。它与swift的VAR相同，而VAL用于创建其值在应用程序中不会随时间变化的变量。与swift的LET相同。

val-不可变（初始化后无法重新分配）

var-可变（可以更改值）

例

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

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

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