ความแตกต่างระหว่างvarและvalใน Kotlin คืออะไร?

ฉันได้ไปที่ลิงค์นี้:

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เหมือนกับfinalmodifier ใน java อย่างที่คุณควรจะรู้ว่าเราไม่สามารถกำหนดให้กับfinalตัวแปรอีกครั้ง แต่สามารถเปลี่ยนคุณสมบัติได้

valและvarทั้งสองถูกใช้เพื่อประกาศตัวแปร

varเป็นเหมือนตัวแปรทั่วไปและเป็นที่รู้จักกันว่าเป็นตัวแปรที่ไม่แน่นอนในkotlinและสามารถกำหนดได้หลายครั้ง

valเป็นเหมือนตัวแปรขั้นสุดท้ายและเป็นที่รู้จักกันว่าไม่เปลี่ยนรูปในkotlinและสามารถเริ่มต้นได้เพียงครั้งเดียวเท่านั้น

สำหรับข้อมูลเพิ่มเติมคืออะไรvalและvarโปรดดูลิงค์ด้านล่าง

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

ตัวแปรที่กำหนดด้วยvar สามารถเปลี่ยนแปลงได้ (อ่านและเขียน)

ตัวแปรที่กำหนดด้วยval ไม่เปลี่ยนรูป (อ่านอย่างเดียว)

Kotlin สามารถลบ findViewById และลดรหัสสำหรับ setOnClickListener ใน android studio สำหรับการอ้างอิงแบบเต็ม: คุณสมบัติที่ยอดเยี่ยมของ Kotlin

ค่าของตัวแปรที่ไม่แน่นอนสามารถเปลี่ยนแปลงได้ตลอดเวลาในขณะที่คุณไม่สามารถเปลี่ยนค่าของตัวแปรที่ไม่เปลี่ยนรูปได้

ฉันควรใช้ var และวาลอยู่ที่ไหน

ใช้ var โดยที่ค่าเปลี่ยนแปลงบ่อย ตัวอย่างเช่นในขณะที่รับตำแหน่งของอุปกรณ์ Android

var integerVariable : Int? = null

ใช้ val ที่ไม่มีการเปลี่ยนแปลงมูลค่าในชั้นเรียนทั้งหมด ตัวอย่างเช่นคุณต้องการตั้งค่า textview หรือข้อความของปุ่มโดยทางโปรแกรม

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 ใช้สำหรับ setter (ค่าจะเปลี่ยน)

val ใช้สำหรับผู้ทะเยอทะยาน (อ่านอย่างเดียวค่าจะไม่เปลี่ยนแปลง)

ถ้าเราประกาศการใช้ตัวแปรvalมันจะเป็นตัวแปรแบบอ่านอย่างเดียว เราไม่สามารถเปลี่ยนค่าของมัน มันเหมือนสุดท้ายตัวแปรของJava 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ค่า = ดังนั้นจึงไม่สามารถเปลี่ยนแปลงได้

ใน Kotlin valเป็นคุณสมบัติแบบอ่านอย่างเดียวและสามารถเข้าถึงได้โดย getter เท่านั้น valไม่เปลี่ยนรูป

val ตัวอย่าง:

val piNumber: Double = 3.1415926
    get() = field

อย่างไรก็ตามvarเป็นคุณสมบัติการอ่านและเขียนดังนั้นจึงสามารถเข้าถึงได้โดยไม่เพียง แต่ทะเยอทะยาน แต่ setter เช่นกัน varไม่แน่นอน

var ตัวอย่าง:

var gravity: Double = 9.8
    get() = field
    set(value) { 
        field = value 
    }    

หากคุณพยายามเปลี่ยนไม่เปลี่ยนรูปvalIDE จะแสดงข้อผิดพลาด:

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 คุณได้รับอนุญาตให้กำหนดมูลค่าเพียงครั้งเดียวเท่านั้น เมื่อคุณพยายามกำหนดใหม่ด้วยค่าเป็นครั้งที่สองคุณจะได้รับข้อผิดพลาดในการรวบรวม โดยที่คุณสมบัติ var ไม่สามารถเปลี่ยนแปลงได้ซึ่งคุณมีอิสระที่จะมอบหมายใหม่เมื่อคุณต้องการและทุกครั้งที่คุณต้องการ

คุณต้องการเปลี่ยนตัวแปรหรือตั้งค่าอย่างถาวรหรือไม่?

• เป็นตัวอย่างที่ดีถ้ามันเป็นสิ่งที่ต้องการpi5places Val = 3.14159valที่คุณจะตั้งเป็น มีความเป็นไปได้ที่คุณจะต้องเปลี่ยนตัวแปรทันทีหรือหลังจากนั้นคุณจะตั้งเป็น 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

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และ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จะไม่มีวิธีการตั้งค่าที่สอดคล้องกัน

ตัวแปรทั้งสองถูกใช้เป็นการเริ่มต้น

• 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: มันเป็นตัวแปรที่สามารถ ba เปลี่ยนแปลงในบรรทัดใด ๆ ในรหัส

ใน Kotlin เราสามารถประกาศตัวแปรในสองประเภทและ val ไม่สามารถกำหนดใหม่ได้มันทำงานเป็นตัวแปรสุดท้ายvarval

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 ใช้สำหรับสร้างตัวแปรเหล่านั้นซึ่งค่าจะเปลี่ยนแปลงตลอดเวลาในแอปพลิเคชันของคุณ มันเหมือนกับ VAR of swift ในขณะที่ VAL ใช้สำหรับสร้างตัวแปรเหล่านั้นซึ่งค่าจะไม่เปลี่ยนแปลงตลอดเวลาในแอปพลิเคชันของคุณมันเหมือนกับ LET of swift

val - ไม่เปลี่ยนรูป (เมื่อเริ่มต้นไม่สามารถกำหนดใหม่ได้)

var - เปลี่ยนแปลงได้ (สามารถเปลี่ยนค่าได้)

ตัวอย่าง

ใน Kotlin - val n = 20 & var n = 20

ใน Java - สุดท้าย int n = 20; & int n = 20;

var เป็นตัวแปรที่ไม่แน่นอนและสามารถกำหนดได้หลายครั้งและ val เป็นตัวแปรที่ไม่เปลี่ยนรูปและสามารถกำหนดเวลาได้เพียงครั้งเดียว