Apa perbedaan antara vardan valdi Kotlin?

Saya telah melalui tautan ini:

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

Sebagaimana dinyatakan pada tautan ini:

Sintaks penuh dari deklarasi properti read-only berbeda dari yang bisa berubah dalam dua cara: ini dimulai dengan val bukan var dan tidak memungkinkan setter.

Namun sesaat sebelum ada contoh yang menggunakan 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
}

Apa perbedaan persis antara vardan val?

Mengapa kita membutuhkan keduanya?

Ini bukan duplikat dari Variabel di Kotlin, perbedaan dengan Java. var vs val? karena saya bertanya tentang keraguan terkait dengan contoh khusus dalam dokumentasi dan bukan hanya secara umum.

Dalam kode Anda resulttidak berubah, varpropertinya berubah. Lihat komentar di bawah ini:

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
}

valsama dengan finalpengubah di java. Karena Anda mungkin harus tahu bahwa kami tidak dapat menetapkan finalvariabel lagi tetapi dapat mengubah propertinya.

valdan varkeduanya digunakan untuk mendeklarasikan variabel.

var seperti variabel umum dan itu dikenal sebagai variabel yang bisa berubah di kotlin dan dapat ditugaskan beberapa kali.

val seperti variabel Final dan dikenal sebagai tidak berubah di kotlin dan dapat diinisialisasi hanya satu kali.

Untuk informasi lebih lanjut apa itu valdan varsilakan lihat tautan di bawah ini

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

variabel yang didefinisikan dengan var dapat berubah (Baca dan Tulis)

variabel yang didefinisikan dengan val tidak dapat diubah (Hanya baca)

Kotlin dapat menghapus findViewById dan mengurangi kode untuk setOnClickListener di android studio. Untuk referensi lengkap: Fitur luar biasa Kotlin

nilai variabel yang dapat berubah dapat diubah kapan saja, sementara Anda tidak dapat mengubah nilai variabel yang tidak dapat diubah.

di mana saya harus menggunakan var dan di mana val?

gunakan var di mana nilainya sering berubah. Misalnya saat mendapatkan lokasi perangkat android

var integerVariable : Int? = null

gunakan val di mana tidak ada perubahan nilai di seluruh kelas. Misalnya Anda ingin mengatur textview atau teks tombol secara terprogram.

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

valgunakan untuk mendeklarasikan variabel akhir. Karakteristik valvariabel

1. Harus diinisialisasi
2. nilai tidak dapat diubah atau ditugaskan kembali

var adalah sebagai variabel umum

1. Kita dapat menginisialisasi nanti dengan menggunakan lateinitpengubah

   [ lateinitJuga gunakan untuk variabel global kita tidak bisa menggunakannya untuk variabel lokal]

2. nilai dapat diubah atau ditugaskan kembali tetapi tidak dalam lingkup global

valin kotlinseperti finalkata kunci in java

Sederhananya, var (dapat diubah) dan val (nilai yang tidak dapat diubah seperti di Java (pengubah akhir))

var x:Int=3
x *= x

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

val adalah immutabledan var mutabledi Kotlin.

Cukup pikirkan Val seperti Variabel akhir di 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;               |
+----------------+-----------------------------+---------------------------+

Referensi

Anda dapat dengan mudah menganggapnya sebagai:

var digunakan untuk setter (nilai akan berubah).

val digunakan untuk pengambil (read-only, nilai tidak akan berubah).

Jika kita mendeklarasikan variabel menggunakan valmaka itu akan menjadi variabel read-only . Kami tidak dapat mengubah nilainya. Ini seperti variabel final Java . Ini immutable.

Tetapi jika kita mendeklarasikan variabel menggunakan varmaka itu akan menjadi variabel yang bisa kita baca atau tulis . Kita bisa mengubah nilainya. Ini 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
}

valtidak dapat diinisialisasi akhir-akhir ini oleh kata kunci lateinittetapi non-primitif vardapat diinisialisasi akhir-akhir ini oleh kata kunci lateinit.

Pada dasarnya

• var= variabel , jadi itu bisa berubah
• val= value , jadi tidak bisa diubah.

Di Kotlin valadalah properti hanya-baca dan dapat diakses oleh pengambil saja. valtidak kekal.

val contoh:

val piNumber: Double = 3.1415926
    get() = field

Namun, varadalah properti baca-dan-tulis , sehingga dapat diakses tidak hanya oleh pengambil tetapi juga penyetel. varbisa berubah.

var contoh:

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

Jika Anda mencoba mengubah yang tidak dapat diubah val, IDE akan menampilkan kesalahan:

fun main() {    
    piNumber = 3.14          // ERROR
    println(piNumber)
}

// RESULT:   Val cannot be reassigned 

Tetapi bisa berubah varbisa berubah:

fun main() {    
    gravity = 0.0
    println(gravity)
}

// RESULT:   0.0

Semoga ini membantu.

properti val mirip dengan properti final di Jawa. Anda diizinkan untuk memberikan nilai hanya untuk satu kali. Saat Anda mencoba menetapkan ulang dengan nilai untuk kedua kalinya Anda akan mendapatkan kesalahan kompilasi. Sedangkan properti var bisa berubah yang Anda bebas untuk memindahkannya kapan saja dan kapan saja Anda inginkan.

Apakah Anda perlu mengubah variabel atau mengaturnya secara permanen?

• Contoh yang bagus jika itu adalah sesuatu seperti val pi5places = 3.14159 Anda akan menetapkannya sebagai val. Apakah ada kemungkinan Anda perlu mengubah variabel itu sekarang atau nanti, maka Anda akan menetapkannya sebagai var.

• Misalnya: Warna mobil, bisa jadi var colorCar = green. Nanti Anda bisa mengubahnya colorCar = blue, di mana sebagai val, Anda tidak bisa.

• Tanggapan di sini tentang mutabledan immutablebaik-baik saja, tetapi mungkin menakutkan jika istilah-istilah ini tidak dikenal atau hanya mempelajari cara memprogram.

Nilai ke valvariabel hanya dapat ditetapkan satu kali.

val address = Address("Bangalore","India")
address = Address("Delhi","India") // Error, Reassigning is not possible with val

Meskipun Anda tidak dapat menetapkan kembali nilai tetapi Anda tentu dapat memodifikasi properti objek.

//Given that city and country are not val
address.setCity("Delhi") 
address.setCountry("India")

Itu berarti Anda tidak dapat mengubah referensi objek yang ditunjuk oleh variabel tetapi properti yang mendasari variabel itu dapat diubah.

Nilai ke variabel var dapat ditetapkan ulang sebanyak yang Anda inginkan.

var address = Address("Bangalore","India")
address = Address("Delhi","India") // No Error , Reassigning possible.

Jelas, properti yang mendasarinya dapat diubah selama mereka tidak dinyatakan val.

//Given that city and country are not val
address.setCity("Delhi")
address.setCountry("India")

Dua cara untuk membuat variabel dalam KOTLIN VAL dan VAR

1. VAL menyimpan nilai konstan. Juga disebut Final Variable

2. VAR menyimpan Nilai yang Dapat Diganti

Klik di sini misalnya

valseperti constantvariabel, itu sendiri tidak dapat diubah, hanya dapat dibaca, tetapi properti dari a valdapat dimodifikasi; varsama seperti variabel mutan dalam bahasa pemrograman lain.

val tidak dapat diubah, final, nilai yang diberikan pertama tidak dapat diubah.

val name:String = "andy"

name = "thomas" //Error: Val cannot be reassigned

var bisa berubah, dialihkan, Anda dapat mengubah nilai berulang-ulang.

val a:Int = 1
var b:Int = 1
println("${a + b}") // output 2

b = 4
println("${a + b}") // output 5

Saya pikir cara termudah untuk mengingatnya:

val = variabel akhir

var = variabel dapat dipindahkan, atau kebalikan dari val.

Keduanya, valdan vardapat digunakan untuk mendeklarasikan variabel (properti lokal dan kelas).

Variabel lokal :

1. valmendeklarasikan variabel read-only yang hanya dapat ditugaskan satu kali, tetapi tidak dapat ditugaskan kembali .

Contoh:

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

2. varmendeklarasikan variabel yang dapat ditugaskan kembali seperti yang Anda ketahui dari Jawa (kata kunci akan diperkenalkan di Java 10, “inferensi tipe variabel lokal” ).

Contoh:

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

Itu selalu lebih baik untuk digunakan val. Cobalah untuk menghindari varsesering mungkin!

Properti kelas :

Kedua kata kunci juga digunakan untuk mendefinisikan properti di dalam kelas . Sebagai contoh, lihat yang berikut ini data class:

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

The Personberisi dua bidang, salah satunya adalah readonly ( name). Di agesisi lain, dapat dipindahkan setelah instantiasi kelas, melalui yang disediakan setter. Perhatikan bahwa nametidak akan memiliki metode penyetel yang sesuai.

Kedua variabel digunakan sebagai inisialisasi

• val seperti variabel konstan, Dapat dibaca, dan properti val dapat dimodifikasi.

• var seperti variabel yang bisa berubah. Anda dapat mengubah nilainya kapan saja.

Singkatnya, variabel val adalah final (tidak bisa berubah) atau nilai konstan yang tidak akan diubah di masa depan dan variabel var (bisa berubah) dapat diubah di masa depan.

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

Lihat kode di atas. Ini adalah kelas model, akan digunakan untuk mengirimkan data. Saya telah menetapkan val sebelum variabel karena variabel ini digunakan untuk mendapatkan data.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Juga, jika Anda perlu mengatur data nanti, Anda perlu menggunakan kata kunci var sebelum variabel, jika Anda hanya perlu mendapatkan nilai satu kali kemudian gunakan kata kunci val

Normal

• Valmenggunakan untuk staticbidang seperti di Jawa sebagaiStatic Keyword

• Seperti Staticdi Jawa / Sama seperti di kotlin

• Dan Varmenunjukkan Variable Field di Kotlin itu, Anda bisa mengubahnya.

• Sebagian besar Staticdigunakan ketika Anda ingin menyimpan nilai dalam memori statis sekaligus,

Contoh:

 if you assign

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

• Anda tidak dapat berubah, ini adalah nilai akhir dan Statis

  var b=2

  b=4 Kamu bisa mengubahnya

val: harus menambah atau menginisialisasi nilai tetapi tidak bisa berubah. var: variabelnya dapat mengubah baris apa pun dalam kode.

Di kotlin kita dapat mendeklarasikan variabel dalam dua jenis: valdan var. valtidak dapat dipindahkan, ini berfungsi sebagai variabel akhir.

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

Di sisi lain, var dapat dipindahkan itu bisa berubah

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

Keduanya adalah variabel, satu-satunya perbedaan adalah variabel Mutable dan variabel immutable dan tidak ada perbedaan lagi. var adalah variabel Mutabel dan val tidak dapat diubah. Dalam Bahasa sederhana var dapat mengubah nilai setelah nilai inisialisasi val konstan dan tidak dapat mengubah nilainya setelah inisialisasi nilai.

val(dari nilai): Referensi tidak dapat diubah. Variabel yang dideklarasikan dengan valtidak dapat dipindahkan setelah diinisialisasi. Ini sesuai dengan finalvariabel di Jawa.

var(dari variabel): Referensi yang dapat diubah. Nilai variabel tersebut dapat diubah. Deklarasi ini sesuai dengan variabel Java reguler (non-final).

Var berarti Variabel -Jika Anda menyimpan objek apa pun menggunakan 'var' itu bisa berubah dalam waktu.

Sebagai contoh:

fun main(args: Array<String>) {
    var a=12
    var b=13
    var c=12
    a=c+b **//new object 25**
    print(a)
}

Val berarti nilai -Ini seperti 'konstan' di java. Jika Anda menyimpan objek apa pun menggunakan 'val' itu tidak bisa berubah dalam waktu.

Sebagai contoh:

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 digunakan untuk membuat variabel-variabel yang nilainya akan berubah dari waktu ke waktu dalam aplikasi Anda. Ini sama dengan VAR dari swift, sedangkan VAL digunakan untuk membuat variabel yang nilainya tidak akan berubah selama waktu dalam aplikasi Anda. Ini sama dengan LET of swift.

val - Immutable (setelah diinisialisasi tidak dapat dipindahkan)

var - Mutable (dapat mengubah nilai)

Contoh

di Kotlin - val n = 20 & var n = 20

Di Jawa - final n = 20; & int n = 20;

var adalah variabel yang dapat berubah dan dapat ditugaskan beberapa kali dan val adalah variabel yang tidak dapat diubah dan hanya dapat diinternalisasi satu kali.