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

В чем разница между var и val в Kotlin?

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

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

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

Полный синтаксис объявления свойства только для чтения отличается от mutable один из двух способов: он начинается с val вместо var и делает не разрешать сеттер.

Но перед тем, как появится пример, который использует установщик.

fun copyAddress(address: Address): Address {
    val result = Address() // there 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?, поскольку я задаю вопрос о сомнении, связанном с конкретным примером в документации, а не только в целом.

+205
источник поделиться
42 ответа
  • 1
  • 2

В коде 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, но можем изменить ее свойства.

+177
источник

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

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

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

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

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

Отредактировано: от " val как константа " до " val как финал "

+102
источник
другие ответы

Связанные вопросы


Похожие вопросы

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

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

Kotlin может удалить findViewById и уменьшить код для setOnClickListener в студии Android. Для полной справки: Kotlin awesome features

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

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

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

var integerVariable : Int? = null

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

val stringVariables : String = "Button Constant or final Text"
+17
источник

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

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

var является общей переменной

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

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

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

enter image description here

val в kotlin похоже на ключевое слово final в java

+14
источник

val immutable, а var - mutable в Котлине.

+10
источник

Просто, var (mutable) и val (неизменяемые значения, такие как Java (окончательный модификатор))

var x:Int=3
x *= x

//gives compilation error (val cannot be re-assigned)
val y: Int = 6
y*=y
+9
источник

Просто подумайте, что Val как final Variable в java

+9
источник

Вы можете легко подумать, что это:

var используется для сеттера (значение изменится).

val используется для getter (только для чтения, значение не изменяется).

+6
источник
+----------------+-----------------------------+---------------------------+
|                |             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;               |
+----------------+-----------------------------+---------------------------+

Ссылка

+6
источник

В принципе

  • var= переменная, так что он может изменить
  • val= значение, поэтому оно не может измениться.
+6
источник

В 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

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

+6
источник

Если мы объявим переменную с использованием 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 a var.
    myName.lastName = myName.lastName
    return myName
}

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

+3
источник

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

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

  • Например: цвет автомобиля, может быть var colorCar = green. Позже вы можете изменить это colorCar = blue, где, как val, вы не можете.

  • Ответы здесь относительно mutable и immutable хороши, но могут быть пугающими, если эти термины не очень хорошо известны или только начинают изучать, как программировать.

+3
источник

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

+3
источник

Переменные объявляются с использованием val или var, если они являются неизменяемыми или изменяемыми

Интересная вещь из Kotlin заключается в том, что большую часть времени вам не нужно указывать тип объектов, с которыми вы работаете, пока компилятор может это сделать.

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

Var - Variable - Объект, хранящийся в переменной, может меняться (меняться) во времени.

Val - Value - Объект, хранящийся в val, не может меняться во времени. После назначения val становится только чтение, как константа на языке программирования Java. Свойства объекта (как Val) могут быть изменены, но сам объект доступен только для чтения.

fun main(args: Array<String>) {
val numberOfHoursInDay = 24
print("Number Of Hours Passed for the day : "+numberOfHoursInDay)
// after an hour
numberOfHoursInDay = 25
print("\nNumber Of Hours Passed for the day : "+numberOfHoursInDay)}

Выход:

Ошибка: (5, 5) Kotlin: Val не может быть переназначен

Мы рассмотрим пример, где мы объявим объект val и попробуем изменить значения его свойств.

fun main(args: Array<String>) {
    val book = Book("The Last Sun",250)
    print(book)
    book.name = "Incredible Hulk"
    print("\n"+book)
}

data class Book(var name: String = "", var price: Int = 0)

Выход:

Книга (имя = последнее солнце, цена = 250) Книга (имя = Невероятный Халк,> цена = 250)

+2
источник

Оба значения val и var могут использоваться для объявления переменных (локальных и свойств класса).

Локальные переменные:

  1. val объявляет переменные только для чтения, которые могут быть назначены только один раз, но не могут быть переназначены.

Пример:

val readonlyString = "hello"
readonlyString = "c u" // Not allowed for 'val'
  1. 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 будет иметь соответствующего метода настройки.

+1
источник

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

+1
источник

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

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

+1
источник

Обе переменные используются как инициализирующие

  • val как постоянная переменная, его можно прочитать, а свойства val можно изменить.

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

+1
источник

Var - Variable - Объект, хранящийся в переменной, может меняться (меняться) во времени.

Val - Value - Объект, хранящийся в val, не может меняться во времени. После присвоения значение val становится только для чтения, как константа на языке программирования Java.

Например:

  fun main(args:Array<String>){
        var numberOfHoursPassed=3
        print("Number of hours passed: $numberOfHoursPassed")

        //After 10 hours
        numberOfHoursPassed=13 //value of var can be changed
        print("Number of hours passed: $numberOfHoursPassed")
    }

Выход:

Number of hours passed: 3
Number of hours passed: 13

Хотя если мы переназначим любое значение val, тогда возникает ошибка компиляции, например,

Ошибка: - Val не может быть переназначен.

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

Ссылка: https://www.tutorialkart.com/kotlin/val-vs-var-in-kotlin/

+1
источник

Короче говоря, переменная 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

+1
источник

Нормальный

  • 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 U может изменить это

+1
источник

Значение переменной 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")
+1
источник

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

+1
источник

Великая статья, чтобы понять val и var в kotlin

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

0
источник

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

0
источник

val (от значения): неизменяемая ссылка. Переменная, объявленная с параметром val может быть переназначена после ее инициализации. Он соответствует final переменной в Java.

var (from variable): Mutable reference. Значение такой переменной можно изменить. Это объявление соответствует регулярной (не конечной) переменной Java.

0
источник

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

1. Когда вы объявляете переменную как val а не ее неизменяемую, то есть вы не можете изменить ее значение (ее final теперь, как в java)

Пример:-

val value=100

value=200 //compile time error
  1. когда вы объявляете переменную как val чем вы должны инициализировать переменную во время объявления

пример

val value=100 //you have to initialize it here only 

Но в случае var

  1. вы можете инициализировать переменную после объявления, но вы должны определить тип данных во время объявления.

пример:-

var value:Int //you can initialize it anytime

value=100    //initialized here
  1. вы можете изменить его значение в любое время, когда это необходимо

Пример:-

var value=100

value= 200 //changed its value and code will compile happily 
0
источник

Оба var и val являются ключевыми словами, которые используются для объявления переменной в Kotlin. Но между ними существует небольшая разница, как указано ниже.

var: Используется для объявления изменяемой переменной. Это означает, что значение переменной можно менять несколько раз.

val: используется для объявления переменной только для чтения. Это означает, что когда значение присваивается переменной, это не может быть изменено позже.

val аналогичен ключевому слову final в Java.

0
источник

Var означает Variable -If, что вы сохранили любой объект с помощью "var", который он мог бы изменить во времени.

Например:

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

Val означает значение -It, как "константа" в 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 an error.**
    print(a)
}
0
источник
  • 1
  • 2

Посмотрите другие вопросы по метке или Задайте вопрос