## Kotlin之变量用法 [TOC] Kotlin变量的声明方式与Java中声明变量有很大的区别，而且**必须使用var或val关键字**。其中： * var：用此关键字声明的变量表示**可变变量**，即可读且可写。相当于Java中普通变量 * val：用此关键字声明的变量表示**不可变变量**，即可读且不可写。相当于Java中用final修饰的变量 ### 一、基础用法 **定义格式： 关键字 变量名: 数据类型 = xxx** 示例：（例：这是在顶层声明的时候） ~~~ fun main(args: Array<String>) { //立即初始化 var var_a: Int = 10 //推导出类型 var var_b = 5 //没有初始化的时候，必须声明类型，注意这里是局部变量，如果是函数中的变量，类中的变量，必须初始化。 var var_c: Float var_c = 12.3f var_c += 1 println("var_a => $var_a \t var_b => $var_b \t var_a => $var_c") //立即初始化 val val_a: Int = 100 //推导出类型 val val_b = 50 //没有初始化的时候，必须声明类型 val val_c: Int val_c = 1 // val_c += 1 因为c是不可变变量，所以这句代码是会报错的 println("val_a => $val_a \t val_b => $val_b \t val_c => $val_c")//`$`符号表示引用的意思，理解为字符串模板 } ~~~ 输出结果： ~~~ var_a => 10 var_b => 5 var_a => 13.3 val_a => 100 val_b => 50 val_c => 1 ~~~ ### 二、类中声明变量以及声明可空变量 #### 2.1类中声明变量 上面的是演示变量的基础定义。而且只有在顶层声明的情况下是可以不用实例化的。但是在实际开发当中，一般都是在一个类中去定义变量，这种情况被称为声明类的属性。这里讲解其声明的特点并实例分析。 其特点如下：**必须初始化，如果不初始化，需使用lateinit关键字。参考[三、后期初始化与延迟初始化](https://www.kancloud.cn/alex_wsc/android_kotlin/1037791#_103)** >[info] 注意：kotlin中的类和Java中的有很大的不同，详情还请具体参考类专属章节 示例代码如下 ~~~ fun main(args: Array<String>) { classVariable() } /** * 在类中，变量的定义及使用 */ fun classVariable() { class Test1 { // 定义属性 var var_a: Int = 0 val val_a: Int = 0 // 初始化 init { var_a = 10 // val_a = 0 为val类型不能更改。 println("var_a => $var_a \t val_a => $val_a") } } Test1() class Test2 { // 声明可空变量 var var_a: Int? = 0 val val_a: Int? = null init { var_a = 10 // val_a = 0 为val类型不能更改。 println("var_a => $var_a \t val_a => $val_a") } } Test2() } ~~~ 输出结果 ~~~ var_a => 10 val_a => 0 var_a => 10 val_a => null ~~~ #### 2.2 声明可空变量 在Java中，当我们声明一个变量不必关心这个变量是否为空，在使用这个变量的时候几乎上都会判断其是否为空来增加程序的安全性。这样的习惯是极好的。但是无形中也增加了一定的代码量。有时候这样的代码还极有可能是无用的废代码。然而在Kotlin中当我们可以确定这个属性或变量一定不为空时，我们就用上面讲解到的去定义变量。否则就把它声明为可空变量。 可空变量的特点： * 在声明的时候**一定用标准的声明格式定义**。不能用可推断类型的简写。 * **变量类型后面的?符号不能省略**。不然就和普通的变量没区别了。 * **其初始化的值可以为null或确定的变量值**。 **定义格式：var/val 变量名 ： 类型? = null/确定的值** 代码示例，同上，类中声明变量中的class Test2中的代码 ### 三、后期初始化与延迟初始化 在上面小节中，当在类中定义一个变量（属性）的时候是必须初始化的。这在平时的实际开发中能满足大部分的需求。 但是还是有一些特殊的场景中不能满足。比如说：Android开发中对组件变量的声明与赋值，以及在使用Dagger2注解变量等。 这就需要Kotlin中特有的后期初始化属性来满足这个需求了。当然这里还为大家讲解延迟初始化，在实际的开发中也是很有用处的。 #### 3.1 后期初始化属性 声明后期初始化属性的特点： * **使用lateinit关键字** * 必须是可读且可写的变量，即**必须用var声明的变量** * **不能声明于可空变量**。 * **不能声明于基本数据类型变量**。例：Int、Float、String等 * **声明后，在使用该变量前必须赋值**，不然会抛出UninitializedPropertyAccessException异常。 实例讲解：举一个Android中常见的例子 ~~~ // 声明组件 private lateinit var mTabLayout : TabLayout lateinit var a : Int // 会报错。因为不能用于基本数据类型。 // 赋值 mTabLayout = find(R.id.home_tab_layout) // 使用 mTabLayout.setupWithViewPager(mViewPager) ~~~ #### 3.2 延迟初始化属性 所谓延迟初始化即：指当程序在第一次使用到这个变量（属性）的时候再初始化。 声明延迟初始化属性的特点： * 使用`lazy{}`高阶函数，不能用于类型推断。且该函数在变量的数据类型后面，用by链接。 * 必须是只读变量，即**必须用val声明的变量**。 实例讲解：同样是Android中常见的例子 ~~~ // 声明一个延迟初始化的字符串数组变量 private val mTitles : Array<String> by lazy { arrayOf( ctx.getString(R.string.tab_title_android), ctx.getString(R.string.tab_title_ios), ctx.getString(R.string.tab_title_h5) ) } // 声明一个延迟初始化的字符串 private val mStr : String by lazy{ "我是延迟初始化字符串变量" } ~~~ ### Kotlin之常量的用法 Kotlin中声明常量的方式和在Java中声明常量的方式有很大的区别。这里举例说明： Kotlin中使用val时候对应的Java代码： ~~~ Kotlin中的 val numA = 6 等价于 Java中的：public final int numA = 6 ~~~ 很显然，Kotlin中只用val修饰还不是常量，它**只能是一个不能修改的变量**。那么常量怎么定义呢？其实很简单，**还需在val关键字前面加上const关键字**。 即： ~~~ const val NUM_A = 6 ~~~ 其特点：**const只能修饰val，不能修饰var** **声明常量的以下几种正确方式** 1. 在顶层声明 2. 在object修饰的类中声明，在kotlin中称为对象声明，它相当于Java中一种形式的单例类 3. 在伴生对象中声明 此外还需满足以下条件： * 以`String`或原生类型值初始化（初始化为`String`类型或基本类型的值） * 没有自定义getter 举例说明： ~~~ /** *常量的使用 */ // 1. 顶层声明 const val NUM_A: String = "顶层声明" // 2. 在object修饰的类中 object TestConst { const val NUM_B = "object修饰的类中" } // 3. 伴生对象中 class TestClass { companion object { const val NUM_C = "伴生对象中声明" } } fun main(args: Array<String>) { println("NUM_A => $NUM_A") println("NUM_B => ${TestConst.NUM_B}") println("NUM_C => ${TestClass.NUM_C}") } ~~~ 输出结果 ~~~ NUM_A => 顶层声明 NUM_B => object修饰的类中 NUM_C => 伴生对象中声明 ~~~ ### 伴生对象 **类内部的对象声明可以⽤ companion 关键字标记**： ~~~ class MyClass { companion object Factory { fun create(): MyClass = MyClass() } } ~~~ **该伴⽣对象的成员可通过只使⽤类名作为限定符来调⽤**： ~~~ val instance = MyClass.create() ~~~ 可以省略伴⽣对象的名称，在这种情况下将使⽤名称 Companion ： ~~~ class MyClass { companion object { } } val x = MyClass.Companion ~~~ 请注意，即使伴⽣对象的成员看起来像其他语⾔的静态成员，在**运⾏时他们仍然是真实对象的实例成员**，⽽且，例如还可以实现接⼝： ~~~ interface Factory<T> { fun create(): T } class MyClass { companion object : Factory<MyClass> { override fun create(): MyClass = MyClass() } } ~~~ 当然，在 JVM 平台，如果使⽤ @JvmStatic 注解，你可以将伴⽣对象的成员⽣成为真正的静态⽅法和字段。