Какая разница между varи valв Котлине?

Я прошел по этой ссылке:

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

Как указано по этой ссылке:

Полный синтаксис объявления свойства только для чтения отличается от изменяемого в двух отношениях: он начинается с val вместо 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
}

Какая точная разница между varи val?

Зачем нам оба?

Это не является дубликатом из переменных в Котлин, различия с Java. вар против вал? как я спрашиваю о сомнениях, связанных с конкретным примером в документации, а не только в целом.

В вашем коде 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такой же, как finalмодификатор в Java. Вероятно, вы должны знать, что мы не можем finalснова присвоить переменную, но можем изменить ее свойства.

valи varоба используются для объявления переменной.

var подобен общей переменной и известен как изменяемая переменная в kotlin и может быть назначен несколько раз.

val похож на Final переменную, он известен как неизменяемый в kotlin и может быть инициализирован только один раз.

Для получения дополнительной информации , что valи varсмотрите ниже ссылку

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

переменные, определенные с помощью var, являются изменяемыми (чтение и запись)

переменные, определенные с помощью val, являются неизменяемыми (только для чтения)

Kotlin может удалить findViewById и уменьшить код для setOnClickListener в Android Studio. Для полной справки: Kotlin потрясающие функции

Значение изменяемых переменных может быть изменено в любое время, в то время как вы не можете изменить значение неизменяемых переменных.

где я должен использовать var и где val?

используйте var, где значение часто меняется. Например, при получении местоположения устройства Android

var integerVariable : Int? = null

используйте val, где нет изменений в значении во всем классе. Например, вы хотите установить текстовое представление или текст кнопки программно.

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

valиспользовать для объявления окончательной переменной. Характеристики valпеременных

1. Должен быть инициализирован
2. значение не может быть изменено или переназначено

var как общая переменная

1. Мы можем инициализировать позже, используя lateinitмодификатор

   [ lateinitтакже использовать для глобальной переменной, мы не можем использовать ее для локальной переменной]

2. значение может быть изменено или переназначено, но не в глобальной области видимости

valв kotlinэто как finalключевое слово в java

Проще говоря, var (mutable) и val (неизменяемые значения, как в Java (модификатор final))

var x:Int=3
x *= x

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

Валь immutableи Вар mutableв Котлине.

Просто подумайте, что 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 используется для установки (значение изменится).

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это свойство только для чтения, и получить доступ к нему может только получатель. 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

Надеюсь это поможет.

Свойство val похоже на конечное свойство в Java. Вам разрешено присваивать ему значение только один раз. При попытке переназначить его значением во второй раз вы получите ошибку компиляции. Принимая во внимание, что свойство var является изменяемым, и вы можете переназначить его в любое время и в любое время.

Вам нужно изменить переменную или установить ее навсегда?

• Хороший пример, если это что-то вроде val pi5places = 3.14159, вы бы установили его как val. Есть ли вероятность, что вам нужно изменить эту переменную сейчас или позже, тогда вы бы установили ее как 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переменная, сама не может быть изменена, только может быть прочитана, но свойства 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 = переменная final

переменная = переназначаемая переменная или противоположность val.

И то, 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: эта переменная может изменяться в любой строке кода.

В kotlin мы можем объявить переменную в двух типах: valи var. valне может быть переназначен, он работает как конечная переменная.

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

С другой стороны, var может быть переназначен, он изменчив

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

Оба являются переменными, с той лишь разницей, что изменяемая переменная и неизменяемая переменная, и нет больше разницы. var - изменяемая переменная, а val - неизменный. В простом языке var может изменить это значение после того, как значение инициализации является постоянным, и он не может изменить его значение после инициализации значения.

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 swift, тогда как VAL используется для создания тех переменных, чье значение не изменится с течением времени в вашем приложении. Это то же самое, что LET swift.

val - неизменный (после инициализации не может быть переназначен)

var - Mutable (может изменить значение)

пример

в Котлине - val n = 20 и var n = 20

В Java - окончательный int n = 20; & int n = 20;

var является изменяемой переменной и может быть назначен несколько раз, а val является неизменяемой переменной и может быть инициализирован только один раз.