varVe valKotlin arasındaki fark nedir ?

Bu bağlantıdan geçtim:

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

Bu bağlantıda belirtildiği gibi:

Salt okunur bir özellik bildiriminin tam sözdizimi, değiştirilebilir bir dosyadan iki şekilde farklıdır: var yerine val ile başlar ve ayarlayıcıya izin vermez.

Ama hemen önce bir ayarlayıcı kullanan bir örnek var.

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
}

Arasındaki kesin fark nedir varve val?

Neden ikisine de ihtiyacımız var?

Bu kopyası olmaması ait KOTLIN içinde Değişkenler, Java ile farklılıkları. var vs val? sadece genel olarak değil, dokümantasyondaki belirli bir örnekle ilgili şüpheleri de soruyorum.

Kodunuz resultdeğişmiyor, varözellikleri değişiyor. Aşağıdaki yorumlara bakın:

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'daki değiştiriciyle aynıdır . Muhtemelen bir finaldeğişkeni tekrar atayamayacağımızı, ancak özelliklerini değiştirebileceğimizi bilmelisiniz .

valve varher ikisi de bir değişken bildirmek için kullanılır.

var gibidir genel değişken ve bir değişken değişken olarak bilinen KOTLIN ve birden çok kez atanabilir.

val , Final değişkeni gibidir ve kotlin'de değişmez olarak bilinir ve sadece bir kez başlatılabilir.

Ne fazla bilgi için valve varbağlantı aşağıya bakınız lütfen

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

ile tanımlanan değişkenler var ile değişkenler değiştirilebilir (Okuma ve Yazma)

ile tanımlanan değişkenler val ile değiştirilemez (Salt okunur)

Kotlin, android Studio'da findViewById öğesini kaldırabilir ve setOnClickListener kodunu azaltabilir. Tam referans için: Kotlin harika özellikler

Değişken değişkenlerin değeri her zaman değiştirilebilirken değişmez değişkenlerin değerini değiştiremezsiniz.

nerede var ve nerede val kullanmalıyım?

değerin sık sık değiştiği var komutunu kullanın. Örneğin android cihazın yerini alırken

var integerVariable : Int? = null

tüm sınıfta değer değişikliği olmayan val kullanın. Örneğin, metin görünümünü veya düğmenin metnini programlı olarak ayarlamak istiyorsunuz.

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

valson değişkeni bildirmek için kullanın. Özellikleri valdeğişkenleri

1. Başlatılmalı
2. değer değiştirilemez veya yeniden atanamaz

var genel bir değişken olarak

1. Daha sonra lateinitdeğiştirici kullanarak başlatabiliriz

   [lateinit global değişken için de kullanıyoruz yerel değişken için kullanamayız]

2. değer değiştirilebilir veya yeniden atanabilir ancak global kapsamda değiştirilemez

valiçindeki anahtar kelime kotlingibidir finaljava

Basitçe, var (değiştirilebilir) ve val (Java'daki gibi son değerler (son değiştirici))

var x:Int=3
x *= x

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

val immutableve var mutableKotlin'de.

Sadece Val'i Java'daki son Değişken gibi düşünün

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

Referans

Kolayca şöyle düşünebilirsiniz:

var ayarlayıcı için kullanılır (değer değişecektir).

val alıcı için kullanılır (salt okunur, değer değişmez).

Değişkeni kullanarak valbildirirsek, salt okunur değişken olacaktır. Değerini değiştiremeyiz. Java'nın son değişkeni gibi . Öyle .immutable

Ancak değişken kullanarak varbildirirsek, okuyabileceğimiz veya yazabileceğimiz bir değişken olacaktır . Değerini değiştirebiliriz. Öyle 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
}

valanahtar kelime tarafından son zamanlarda başlatılamaz, lateinitancak ilkel olmayan varanahtar kelime tarafından son zamanlarda başlatılabilir lateinit.

temel olarak

• var= değişken , böylece değişebilir
• val= değer , bu yüzden değişemez.

KOTLIN yılında valbir olan salt okunur özellik ve sadece gaz giderici tarafından erişilebilir. valdeğişmez.

val misal :

val piNumber: Double = 3.1415926
    get() = field

Bununla birlikte, varbir okuma ve yazma özelliği, bu nedenle sadece bir alıcı tarafından değil, bir ayarlayıcı tarafından da erişilebilir. vardeğişebilir.

var misal :

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

Değişmez bir dosyayı değiştirmeye çalışırsanız val, IDE size hata gösterir:

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

// RESULT:   Val cannot be reassigned 

Ancak değişebilir bir varşey değiştirilebilir:

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

// RESULT:   0.0

Bu yardımcı olur umarım.

val özelliği, Java'daki nihai özelliğe benzer. Yalnızca bir kez bir değer atamanıza izin verilir. İkinci kez bir değerle yeniden atamaya çalıştığınızda bir derleme hatası alırsınız. Oysa var özelliği değiştirilebilir ve istediğiniz zaman yeniden atayabilirsiniz.

Bir değişkeni değiştirmeniz veya kalıcı olarak ayarlamanız mı gerekiyor?

• Val pi5places = 3.14159 gibi bir şeyse iyi bir örnek olarak ayarlayabilirsiniz val. Bu değişkeni şimdi veya daha sonra değiştirmeniz gerekiyorsa, var olarak ayarlamanız gerekir.

• Örneğin: Bir arabanın rengi olabilir var colorCar = green. Daha sonra bunu değiştirebilirsin colorCar = blue, nerede olarak valyapamazsın.

• Buradaki yanıtlar iyi mutableve immutableiyidir, ancak bu terimler iyi bilinmiyorsa veya sadece nasıl programlanacağını öğrenmeye başlarsa korkutucu olabilir.

valDeğişkene değer yalnızca bir kez atanabilir.

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

Yine de değeri yeniden atayamazsınız, ancak nesnenin özelliklerini kesinlikle değiştirebilirsiniz.

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

Bu, değişkenin işaret ettiği nesne referansını değiştiremeyeceğiniz, ancak değişkenin temel özelliklerini değiştirebileceğiniz anlamına gelir.

Var değişkenine değer istediğiniz kadar yeniden atanabilir.

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

Açıkçası, val bildirilmediği sürece temel özellikleri değiştirilebilir.

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

KOTLIN VAL ve VAR'da değişken oluşturmanın iki yolu

1. VAL sabit değerleri saklar. Olarak da adlandırılırNihai Değişken olarak

2. VAR , Değiştirilebilir Değerleri saklar

Örneğin buraya tıklayın

valconstantdeğişken gibi , kendisi değiştirilemez, sadece okunabilir, ancak a'nın özellikleri valdeğiştirilebilir; vartıpkı diğer programlama dillerindeki mutant değişken gibi.

val değiştirilemez, son, ilk atanan değer değiştirilemez.

val name:String = "andy"

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

var değiştirilebilir, yeniden atanabilir, değeri tekrar tekrar değiştirebilirsiniz.

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

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

Bence bunu hatırlamanın en kolay yolu:

val = değişken final

var = değişken yeniden atanabilir veya val'in tersi.

Her ikisi de valve vardeğişkenleri bildirmek için kullanılabilir (yerel ve sınıf özellikleri).

Yerel değişkenler :

1. valyalnızca bir kez atanabilen ancak yeniden atanamayan salt okunur değişkenleri bildirir .

Misal:

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

2. varJava'dan bildiğiniz gibi yeniden atanabilir değişkenleri bildirir (anahtar kelime Java 10'da “yerel değişken türü çıkarımı” olarak tanıtılır ).

Misal:

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

Her zaman kullanılması tercih edilir val. varMümkün olduğunca sık kaçının !

Sınıf özellikleri :

Her iki anahtar kelime de sınıf içindeki özellikleri tanımlamak için kullanılır . Örnek olarak aşağıdakilere bir göz atın data class:

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

PersonSalt okunur biri iki alan içerir ( name). ageResim ile, diğer taraftan, sınıf örnekleme sonrasında yeniden edilebilir setter. nameKarşılık gelen bir ayarlayıcı yöntemi olmayacağını unutmayın .

Her iki değişken de başlatma olarak kullanılır

• sabit bir değişken gibi val, okunabilir ve bir val özellikleri değiştirilebilir.

• değişebilir bir değişken gibi değişebilir. değeri istediğiniz zaman değiştirebilirsiniz.

Kısacası, val değişkeni nihai (değişmez) veya gelecekte değişmeyecek sabit değerdir ve var değişkeni (değişebilir) gelecekte değiştirilebilir.

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

Yukarıdaki koda bakınız. Bu bir model sınıfıdır, veri aktarımı için kullanılacaktır. Bu değişkeni veri almak için kullanıldığından, değişkenden önce val ayarladım .

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Ayrıca, verileri daha sonra ayarlamanız gerekiyorsa, bir değişkenden önce var anahtar sözcüğünü kullanmanız gerekir; yalnızca değeri bir kez almanız gerekiyorsa val anahtar sözcüğünü kullanın

Normal

• Valstaticgibi Java gibi alan için kullanıyorStatic Keyword

• Gibi StaticKOTLIN olduğu gibi Java / Same

• Ve VarKotlin'deki Değişken Alanı belirtir, değiştirebilirsiniz.

• Çoğunlukla Staticstatik belleğe aynı anda değer kaydetmek istediğinizde kullanılır,

Misal:

 if you assign

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

• Değiştiremezsiniz, bu son değer ve Statik

  var b=2

  b=4 U değiştirebilirsin

val: değer eklemeli veya başlatmalı, ancak değiştirilemez. var: değişken, koddaki herhangi bir satırda değişebilir.

Kotlin'de iki tipte değişken tanımlayabiliriz: valve var. valyeniden atanamazsa, son değişken olarak çalışır.

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

Diğer tarafta, değişken yeniden atanabilir

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

Her ikisi de değişkendir, tek fark Mutable değişkeni ve değişmez değişken olmasıdır ve daha fazla fark yoktur. var Değişken değişkendir ve val değişmezdir. Basit bir dilde var değişebilir başlatma değerinden sonra değer val sabittir ve değer başlatmadan sonra değerini değiştiremez.

val(değerden): Değişmez referans. İle bildirilen bir değişken valbaşlatıldıktan sonra yeniden atanamaz. finalJava'daki bir değişkene karşılık gelir .

var(değişkenden): Değişken referans. Böyle bir değişkenin değeri değiştirilebilir. Bu bildirim, normal (son olmayan) bir Java değişkenine karşılık gelir.

Var , Değişken anlamına gelir -'var ' kullanarak herhangi bir nesneyi sakladıysanız , zaman içinde değişebilir.

Örneğin:

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

Val değer anlamına gelir -Java'da 'sabit' gibidir . 'Val' kullanarak herhangi bir nesneyi sakladıysanız, zamanla değişemezdi.

Örneğin:

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, değeri uygulamanızda zaman içinde değişecek olan bu değişkeni oluşturmak için kullanılır. Hızlı VAR ile aynıdır, ancak VAL, değeri uygulamanızda zaman içinde değişmeyecek olan bu değişkeni yaratmak için kullanılır.

val - Değişmez (başlatıldıktan sonra yeniden atanamaz)

var - Değişken (değeri değiştirebilir)

Misal

in Kotlin - val n = 20 ve var n = 20

Java'da - son int n = 20; & int n = 20;

var değişebilir bir değişkendir ve birden çok kez atanabilir ve val değişmez değişkendir ve yalnızca tek seferde inatize edilebilir.