Jaka jest różnica między vari valw Kotlin?

Przejrzałem ten link:

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

Zgodnie z tym linkiem:

Pełna składnia deklaracji właściwości tylko do odczytu różni się od zmiennej na dwa sposoby: zaczyna się od val zamiast var i nie pozwala na ustawienie.

Ale tuż przed przykładem jest 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
}

Jaka jest dokładna różnica między vari val?

Dlaczego potrzebujemy obu?

Jest to nie duplikat od zmiennych w Kotlin, różnic z Java. var vs val? ponieważ pytam o wątpliwości związane z konkretnym przykładem w dokumentacji, a nie tylko ogólnie.

W kodzie resultsię nie zmienia, zmieniają się jego varwłaściwości. Zobacz komentarze poniżej:

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
}

valjest taki sam jak finalmodyfikator w Javie. Jak zapewne powinieneś wiedzieć, że nie możemy finalponownie przypisać zmiennej, ale możemy zmienić jej właściwości.

vali varoba służą do deklarowania zmiennej.

var jest jak zmienna ogólna i jest znana jako zmienna zmienna w kotlin i może być przypisywana wiele razy.

val jest jak zmienna końcowa i jest znany jako niezmienny w kotlin i może być zainicjowany tylko raz.

Aby uzyskać więcej informacji, co znajduje się vali varzobacz poniższy link

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

zmienne zdefiniowane za pomocą var są zmienne (odczyt i zapis)

zmienne zdefiniowane za pomocą val są niezmienne (tylko do odczytu)

Kotlin może usunąć findViewById i zmniejszyć kod dla setOnClickListener w Android Studio. Pełny opis : niesamowite funkcje Kotlin

wartość zmiennych zmiennych można zmienić w dowolnym momencie, natomiast nie można zmienić wartości zmiennych niezmiennych.

gdzie powinienem używać var ​​i gdzie val?

użyj var, gdzie wartość często się zmienia. Na przykład podczas uzyskiwania lokalizacji urządzenia z systemem Android

var integerVariable : Int? = null

użyj val, gdy nie ma zmiany wartości w całej klasie. Na przykład chcesz programowo ustawić widok tekstu lub tekst przycisku.

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

valsłuży do deklarowania zmiennej końcowej. Charakterystyka valzmiennych

1. Musi zostać zainicjowany
2. wartości nie można zmienić ani zmienić przypisania

var jest jako zmienna ogólna

1. Możemy zainicjować później za pomocą lateinitmodyfikatora

   [ lateinitużyj także dla zmiennej globalnej, nie możemy użyć jej dla zmiennej lokalnej]

2. wartość można zmienić lub zmienić przypisanie, ale nie w zakresie globalnym

valin kotlinjest jak finalsłowo kluczowe w java

Po prostu var (mutable) i val (niezmienne wartości jak w Javie (modyfikator końcowy))

var x:Int=3
x *= x

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

val jest immutablei var jest mutablew Kotlin.

Po prostu pomyśl Val jak ostatnia zmienna w 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;               |
+----------------+-----------------------------+---------------------------+

Odniesienie

Możesz łatwo pomyśleć to jako:

var służy do ustawienia (wartość ulegnie zmianie).

val służy do pobierania (tylko do odczytu, wartość się nie zmieni).

Jeśli zadeklarujemy zmienną za pomocą val, będzie to zmienna tylko do odczytu . Nie możemy zmienić jego wartości. To jest jak ostatnia zmienna Java . Jest immutable.

Ale jeśli zadeklarujemy zmienną za pomocą var, będzie to zmienna, którą możemy odczytać lub zapisać . Możemy zmienić jego wartość. Jest 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
}

valnie może być ostatnio zainicjowany przez słowo kluczowe, lateinitale nieprymitywne varmoże być ostatnio zainicjowane przez słowo kluczowe lateinit.

Gruntownie

• var= zmienna , więc może się zmienić
• val= wartość , więc nie można jej zmienić.

W Kotlinie valjest właściwość tylko do odczytu i może być dostępna tylko dla gettera. valjest niezmienny.

val przykład:

val piNumber: Double = 3.1415926
    get() = field

Jest to jednak właściwość vardo odczytu i zapisu , więc dostęp do niej może uzyskać nie tylko getter, ale i setter. varjest zmienny.

var przykład:

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

Jeśli spróbujesz zmienić niezmienny val, IDE wyświetli błąd:

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

// RESULT:   Val cannot be reassigned 

Ale zmienne varmożna zmienić:

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

// RESULT:   0.0

Mam nadzieję że to pomoże.

Właściwość val jest podobna do właściwości końcowej w Javie. Możesz przypisać mu wartość tylko raz. Podczas drugiej próby przypisania wartości wartością pojawi się błąd kompilacji. Podczas gdy własność var ​​jest zmienna, którą możesz dowolnie przypisać, kiedy chcesz i na dowolny czas.

Czy musisz zmienić zmienną lub ustawić ją na stałe?

• Dobry przykład, jeśli jest to coś w rodzaju val pi5places = 3.14159 , ustawiłbyś to jako val. Czy istnieje możliwość, że musisz zmienić tę zmienną teraz lub później, a następnie ustaw ją jako var.

• Na przykład: Kolor samochodu może być var colorCar = green. Później możesz to zmienić colorCar = blue, gdy valnie możesz tego zrobić.

• Odpowiedzi tutaj dotyczące mutablei immutablesą w porządku, ale mogą być przerażające, jeśli te terminy nie są dobrze znane lub po prostu zaczynają się uczyć programowania.

Wartość do valzmiennej można przypisać tylko raz.

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

Chociaż nie można ponownie przypisać wartości, ale z pewnością można zmodyfikować właściwości obiektu.

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

Oznacza to, że nie można zmienić odwołania do obiektu, na który wskazuje zmienna, ale można zmienić podstawowe właściwości tej zmiennej.

Wartość zmiennej var można przypisać dowolną liczbę razy.

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

Oczywiście właściwości leżące u jego podstaw można zmieniać, o ile nie zostaną zadeklarowane jako val.

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

Dwa sposoby tworzenia zmiennej w KOTLIN VAL i VAR

1. VAL przechowuje wartości stałe. Nazywany także zmienną końcową

2. VAR przechowuje zmienne wartości

Kliknij tutaj na przykład

valpodobnie jak constantzmienna, sama nie może zostać zmieniona, można ją tylko odczytać, ale właściwości a valmożna modyfikować; varpodobnie jak zmienna mutanta w innych językach programowania.

val jest niezmienny, końcowy, pierwszej przypisanej wartości nie można zmienić.

val name:String = "andy"

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

var jest zmienny, można go ponownie przypisać, możesz zmieniać wartość w kółko.

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

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

Myślę, że najłatwiej to zapamiętać:

val = zmienna końcowa

var = zmienna, którą można ponownie przypisać, lub odwrotnie niż val.

Zarówno vali varmogą być używane do deklarowania zmiennych (właściwości lokalne i właściwości klasy).

Zmienne lokalne :

1. valdeklaruje zmienne tylko do odczytu, które można przypisać tylko raz, ale nie można ich ponownie przypisać .

Przykład:

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

2. vardeklaruje zmienne, które można ponownie przypisać z języka Java (słowo kluczowe zostanie wprowadzone w Javie 10, „wnioskowanie typu zmiennej lokalnej” ).

Przykład:

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

Zawsze lepiej jest używać val . Staraj się unikać vartak często, jak to możliwe!

Właściwości klasy :

Oba słowa kluczowe są również używane do definiowania właściwości wewnątrz klas . Jako przykład, spójrz na następujące data class:

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

PersonZawiera dwa pola, z których jeden jest tylko do odczytu ( name). Z agedrugiej strony, można ponownie przypisać po utworzeniu instancji klasy, za pośrednictwem podanego setter. Zauważ, że namenie będzie mieć odpowiedniej metody ustawiania.

Obie zmienne są używane jako inicjalizacja

• val jak stała zmienna, może być czytelny, a właściwości val można modyfikować.

• var podobnie jak zmienna zmienna. możesz zmienić wartość w dowolnym momencie.

Krótko mówiąc, zmienna val jest wartością końcową (niemodyfikowalną) lub stałą wartością, która nie będzie zmieniana w przyszłości, a zmienną var (zmienną) można zmienić w przyszłości.

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

Zobacz powyższy kod. Jest to klasa modelowa, która będzie używana do przekazywania danych. Mam ustawiony val przed zmienną, ponieważ zmienna ta została wykorzystana w celu uzyskania danych.

class DeliveryOrderEvent(var d : Delivery)

// setter and getter is fine here. No error

Ponadto, jeśli chcesz ustawić dane później, musisz użyć słowa kluczowego var przed zmienną, jeśli potrzebujesz tylko raz uzyskać wartość, użyj słowa kluczowego val

Normalna

• Valużywa dla staticpola jak w Javie jakoStatic Keyword

• Jak Staticw Javie / Taki sam jak w kotlin

• I Varoznacza zmienne pole w Kotlinie, że możesz to zmienić.

• Najczęściej Staticjest używany, gdy chcesz jednocześnie zapisać wartość w pamięci statycznej,

Przykład:

 if you assign

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

• Nie można zmienić, jest to wartość końcowa i statyczna

  var b=2

  b=4 Możesz to zmienić

val: należy dodać lub zainicjować wartość, ale nie można jej zmienić. var: zmienna może zmieniać się w dowolnym wierszu kodu.

W kotlin możemy zadeklarować zmienną w dwóch typach: vali var. valnie można go ponownie przypisać, działa jako zmienna końcowa.

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

Z drugiej strony var może zostać ponownie przypisany, jest zmienny

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

Oba są zmienne, jedyną różnicą jest zmienna zmienna i zmienna niezmienna i nie ma już żadnej różnicy. var jest zmienną zmienną, a val jest niezmienny. W prostym języku var może zmieniać wartość po inicjalizacji wartość val jest stała i nie może jej zmienić po inicjalizacji wartości.

val(od wartości): Niezmienne odniesienie. Zmiennej zadeklarowanej za valpomocą nie można ponownie przypisać po jej zainicjowaniu. Odpowiada tofinal zmiennej w Javie.

var(ze zmiennej): Zmienne odniesienie. Wartość takiej zmiennej można zmienić. Ta deklaracja odpowiada zwykłej (nie ostatecznej) zmiennej Java.

Var oznacza Zmienną - Jeśli zapisałeś dowolny obiekt za pomocą „var” , może on ulec zmianie w czasie.

Na przykład:

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

Val oznacza wartość - To jest jak „stała” w java. Jeśli zapisałeś dowolny obiekt używając „val”, to nie mógł się zmienić w czasie.

Na przykład:

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 służy do tworzenia tych zmiennych, których wartość zmienia się w miarę upływu czasu w twojej aplikacji. Jest to to samo, co VAR dla swift, natomiast VAL służy do tworzenia tych zmiennych, których wartość nie zmieni się z upływem czasu w twojej aplikacji. Jest to to samo, co LET dla swift.

val - Niezmienny (po zainicjowaniu nie można go ponownie przypisać)

var - Zmienny (może zmieniać wartość)

Przykład

w Kotlinie - val n = 20 i var n = 20

W Javie - końcowy int n = 20; i int n = 20;

var jest zmienną zmienną i może być przypisywana wiele razy, a val jest zmienną niezmienną i może być zainicjalizowany tylko raz.