web-dev-qa-db-ja.com

Kotlinのヴァルとヴァール

Kotlinのvarとvalの違いは何ですか？

私はこのリンクを通り抜けました：

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

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

読み取り専用プロパティ宣言の完全な構文は、2つの点で変更可能なものと異なります。それは、varではなくvalで始まり​​、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の正確な違いは何ですか？

なぜ両方が必要なのでしょうか。

これは 重複していない of Kotlinの 変数、Javaとの違いです。 VAR対VAR？ 私は一般的なことだけではなく、文書中の特定の例に関連する疑問について質問しています。

kotlin
191
Akshar Patel

あなたのコードでは、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は、Javaのfinal修飾子と同じです。 final変数に再度代入することはできませんが、そのプロパティを変更することはできます。

165
chandil03

valとvarは両方とも変数を宣言するために使用されます。

var は general variableのようなもので、 kotlin では可変変数として知られており、複数回割り当てることができます。

val は Final 変数のようであり、 kotlin では不変であることが知られており、一度だけ初期化できます。

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

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

編集 ： " val は似ている 定数 "から " val は似ている Final "

92
Patel Pinkal

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

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

KotlinはfindViewByIdを削除し、AndroidスタジオのsetOnClickListenerのコードを減らすことができます。完全な参照のために：Kotlin素晴らしい機能

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

どこでvarを使いどこでvalを使うべきですか？

値が頻繁に変化する場合は、varを使用してください。例えばAndroidデバイスの位置を取得しながら

var integerVariable : Int? = null

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

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

valは最終的な変数を宣言するために使用します。 val変数の特性

  1. 初期化する必要があります
  2. 値を変更または再割り当てすることはできません enter image description here

varは一般変数として

  1. lateinit修飾子を使って後で初期化することができます

    [lateinitはグローバル変数にも使用しますが、ローカル変数には使用できません]

  2. 値は変更または再割り当てできますが、グローバルスコープではありません。

enter image description here

valのkotlinは、finalのJavaキーワードに似ています

14
user4696837

kotlinでは、valはimmutable、varはmutableです。

10
Samir Mangroliya

単純にValをJavaの最終変数のように考える

8
Connecting life with Android

簡単に言えば、var（mutable）とval（Java（final modifier）のように不変の値）

var x:Int=3
x *= x

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

あなたは簡単にそれを考えることができます：

varはセッターに使用されます（値は変更されます）。

valはgetterに使用されます（読み取り専用、値は変更されません）。

6
Ling Boo

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

お役に立てれば。

5
ARGeo
+----------------+-----------------------------+---------------------------+
|                |             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;               |
+----------------+-----------------------------+---------------------------+

参照

5
Joby Wilson Mathews

基本的に

  • var = variable なので、変更することができます
  • val = value なので、変更することはできません。
4
droidgeek

val propertyはJavaのfinalプロパティに似ています。一度だけ値を割り当てることができます。 2回目の値で再割り当てしようとすると、コンパイルエラーが発生します。 varプロパティは変更可能ですが、いつでも好きなときに自由に再割り当てできます。

3
Halil RAŞO

valを使用して変数を宣言すると、それは 読み取り専用 variableになります。その価値を変えることはできません。 final / Java のようなものです。それはimmutableです。

しかしvarを使って変数を宣言すると、それは read または write にできる変数になります。その価値を変えることができます。それは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によって最近初期化することができます。

3
Avijit Karmakar

変数を変更したり、恒久的に設定したりする必要がありますか？

  • それが val pi5places = 3.14159 のようなものである場合の良い例です - /あなたはそれをvalとして設定するでしょう。その変数を今すぐまたは後で変更する必要がある可能性はありますか、それならあなたはそれをvarとして設定するでしょう。

  • 例： 自動車の色は、var colorCar = greenです。後でcolorCar = blueを変更できますが、valとしては変更できません。

  • mutableとimmutableに関するここでの回答は問題ありませんが、これらの用語があまりよく知られていない場合、または単にプログラミングの仕方を学んでいる場合は、恐ろしいかもしれません。

3
teckeon

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")
1
Saurabh Padwekar

つまり、 val variableは最終的なもの（変更不可）、または将来変更されない定数値、および var variable（変更可能）は将来変更される可能性があります。

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

上記のコードを見てください。これはモデルクラスです、データの受け渡しに使用されます。この変数はデータを取得するために使用されたため、変数の前に val を設定しました。

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

また、後でデータを設定する必要がある場合は、変数の前に var キーワードを使用する必要があります。値を1回だけ取得する必要がある場合は val keywordを使用します。

1
Shaon

Var - 変数 - 変数に格納されているオブジェクトは、時間の経過とともに変化する可能性があります。

Val - Value - valに格納されているオブジェクトは、時間的に変動することはありません。一度割り当てられると、valは読み取り専用になります。これは、Javaプログラミング言語の定数のようになります。

例えば：

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

出力：

Number of hours passed: 3
Number of hours passed: 13

valに値を再割り当てすると、コンパイルエラーが発生します。

エラー： - Valは再割り当てできません。

結論として、varはどのレベルでも変更できます。一度割り当てられたvalは変更できませんでしたが、そのプロパティは変更できました。

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

1
hetsgandhi

KOTLIN VALおよびVARで変数を作成する2つの方法

1。VALは定数値を保存します。 最終変数とも呼ばれます

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

例はここをクリック

1
Coltin Casmir

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の逆。

1
Wahyu Anggara Raya

普通

  • Valは、JavaのようにStatic Keywordとしてstaticフィールドに使用しています

  • JavaのStaticと同じ/ kotlinと同じ

  • そしてVarはKotlinの変数フィールドを意味し、あなたはそれを変更することができます。

  • Staticは、一度に静的メモリに値を保存したいときに使われます。

例：

 if you assign

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

  • 変更することはできません、これは最終的な値であり静的です

    var b=2

    b=4 Uはそれを変更できます

1
ZafarHussain

valとvarは両方とも、変数（ローカルおよびクラスプロパティ）の宣言に使用できます。

ローカル変数 ：

  1. valは、1回しか割り当てられない 読み取り専用 変数を宣言しますが、再割り当てはできませんを宣言します。

例：

val readonlyString = “hello”
readonlyString = “c u” // Not allowed for `val`
  1. varは、あなたがJavaから知っているようにreassignable変数を宣言します（キーワードは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には対応するセッターメソッドがありません。

1
s1m0nw1

valはconstant変数のように、それ自身は変更することはできず、読み取ることしかできませんが、valのプロパティは変更することができます。 varは他のプログラミング言語のミュータント変数と同じです。

1
suyanlu

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

  • valは定数変数のように、読みやすく、valのプロパティを変更することができます。

  • varは可変変数と同じです。値はいつでも変更できます。

1
Nikhil Katekhaye

val： 値を追加または初期化する必要がありますが、変更することはできません。 var： その変数はコードのどの行でも変更できます。

1
Mohamed Ibrahim

valとvarは両方とも変数を宣言したいときに使われます。 valとvarの違いは

1.変数を不変ではなくvalとして宣言すると、その値を変更することはできません（現在、Javaのようにfinal）

例： - 

val value=100

value=200 //compile time error
  1. 宣言時に変数を初期化する必要があるよりも、変数をvalとして宣言した場合

例

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

しかしvarの場合

  1. 宣言後に変数を初期化できますが、宣言時にデータ型を定義する必要があります。

例： - 

var value:Int //you can initialize it anytime

value=100    //initialized here
  1. 必要に応じていつでも値を変更できます

例： - 

var value=100

value= 200 //changed its value and code will compile happily
0
Shubham Mittal

両方とも変数ですが、唯一の違いは、可変変数と不変変数であり、それ以上の違いはありません。 varは可変変数、valは不変です。簡単な言語では、varは初期化後の値を変更できますvalは定数であり、初期化後の値を変更することはできません。

0
Nick

Kotlinでは、 変数 を宣言するためにvarを使います。 可変 です。 can change、 再割り当て 変数。例、

fun main(args : Array<String>){
    var x = 10
    println(x)

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

定数 を宣言するためにvalを使います。それらは 不変 です。 変更不可 、 再割り当て vals。 valは、Javaのfinal変数に似たものです。例、

fun main(args : Array<String>){
    val y = 10
    println(y)

    y = 100 // vals can't reassign (COMPILE ERROR!).
    println(y)
}
0
Osusara Kammalawatta

このようにしてみましょう。

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)
0
user10480468

VARは、アプリケーション内で時間の経過とともに値が変化する変数を作成するために使用されます。それはSwiftのVARと同じですが、VALはあなたのアプリケーションで時間の経過と共に変化しないそれらの変数を作成するために使用されます。SwiftのLETと同じです。

0
Ashutosh Shukla

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

0
Yohan Malshika

正確な答えは KotlinをJavaに逆コンパイルする から得られます。

あなたがコトリンでこれをするならば：

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

0
Tomas Bjerre

val（from value）：不変の参照valで宣言された変数は、初期化後に再割り当てすることはできません。これはJavaのfinal変数に対応します。

var（from from variable）：可変参照そのような変数の値は変更することができます。この宣言は通常の（最後ではない）Java変数に対応します。

0
Gulzar Bhat

Valは不変で、そのプロパティはrun timeに設定されますが、const修飾子を使用して、時定数をコンパイルします。 kotlinのValはJavaのfinalと同じです。

Varは可変であり、そのタイプはcompile timeで識別されます。

0
Varun Chandran

val - 不変（一度初期化されたものは再割り当てできません）

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

例

コトリンで - val n = 20＆var n = 20

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

0
Najib Ahmed Puthawala

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)
}
0
NHB SOHEL