違いは何であるvarとvalKotlinでは？

私はこのリンクを通過しました：

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

このリンクで述べたように：

読み取り専用のプロパティ宣言の完全な構文は、2つの点で変更可能なプロパティ宣言とは異なります。varではなくvalで始まり​​、セッターを許可していません。

しかし、直前にセッターを使用する例があります。

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プロパティは変化しています。以下のコメントを参照してください：

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
}

valfinalJava の修飾子と同じです。おそらく、final変数に再度割り当てることはできませんが、そのプロパティを変更できることをご存知でしょう。

valそしてvar両方の変数を宣言するために使用されています。

varは一般的な変数のようなもので、kotlinでは可変変数と呼ばれ、複数回割り当てることができます。

valはFinal変数のようなもので、kotlinでは不変として知られており、1回だけ初期化できます。

詳細についてはval、var以下のリンクを参照してください

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

varで定義された変数は変更可能です（読み取りおよび書き込み）

valで定義された変数は不変です（読み取り専用）

Kotlinは、Android StudioでfindViewByIdを削除し、setOnClickListenerのコードを削減できます。完全なリファレンス：Kotlinの素晴らしい機能

可変変数の値はいつでも変更できますが、不変変数の値は変更できません。

どこでvarを、どこでvalを使用すればよいですか？

値が頻繁に変化するvarを使用します。たとえば、Androidデバイスの位置を取得しているとき

var integerVariable : Int? = null

クラス全体で値に変化がない場合はvalを使用します。たとえば、テキストビューまたはボタンのテキストをプログラムで設定したいとします。

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はmutableKotlinにあります。

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では、読み取り専用のプロパティであり、ゲッターのみがアクセスできます。val不変です。

val 例：

val piNumber: Double = 3.1415926
    get() = field

ただし、varは読み書き可能なプロパティであるため、ゲッターだけでなくセッターからもアクセスできます。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、どこのように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変数の値は、何度でも再割り当てできます。

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で変数を作成する2つの方法

1. VALは定数値を格納します。最終変数とも呼ばれます

2. VARは変更可能な値を格納します

例はここをクリック

valconstant変数と同様に、それ自体を変更することはできません。読み取りのみが可能ですが、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 =変数final

var =再割り当て可能な変数、またはvalの反対。

両方、valそしてvar変数（ローカルおよびクラスプロパティ）を宣言するために使用することができます。

ローカル変数：

1. val一度だけ割り当てることができ、再割り当てできない読み取り専用変数を宣言します。

例：

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

2. varJavaでわかっているように、再割り当て可能な変数を宣言します（このキーワードは、Java 10で導入される「ローカル変数の型推論」）。

例：

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

常に使用することをお勧めしますval。varできるだけ頻繁に避けてください！

クラスプロパティ：

両方のキーワードは、クラス内のプロパティを定義するためにも使用されます。例として、以下を見てくださいdata class。

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

にPersonは2つのフィールドがあり、そのうちの1つは読み取り専用（name）です。age一方、提供介して、クラスのインスタンス化の後に再割り当てされてもよいですsetter。name対応するセッターメソッドがないことに注意してください。

両方の変数が初期化として使用されます

• 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キーワードを使用する必要があります。値を1回だけ取得する必要がある場合は、valキーワードを使用します

正常

• ValstaticJavaのようにフィールドに使用していますStatic Keyword

• StaticJavaのように/ 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では、変数を2つの型で宣言できます：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初期化された後に再度割り当てることはできません。finalJavaの変数に対応しています。

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は、アプリケーションで時間の経過とともに値が変化しない変数を作成するために使用されます。wiftのLETと同じです。

val-不変（初期化すると再割り当てできません）

var-可変（値を変更できる）

例

Kotlinの場合-val n = 20＆var n = 20

Javaの場合-final int n = 20; ＆int n = 20;

varは可変変数であり、複数回割り当てることができ、valは不変変数であり、初期化は1回のみ可能です。