Android Kotlin变量、常量

Kotlin之变量用法

kotlin变量的声明方式与Java中声明变量有很大的区别，而且必须使用var或val关键字。其中：  
var: 用此关键字声明的变量表示可变变量，即可读且可写。相当于Java中普通变量
val: 用此关键字声明的变量表示不可变变量，即可读且不可写。相当于Java中用final修饰的变量

基础用法

定义格式：关键字 变量名: 数据类型 = xxx
例：

//立即初始化
var var_a: Int = 10

//推导出类型
var var_b = 5
println("var_a => $var_a \t var_b => $var_b")

//立即初始化
val val_a: 
Int = 100

//推导出类型
val val_b = 50
// val_c += 1 因为c是常量，所以这句代码是会报错的

// $符号表示引用的意思。这里理解为字符串模板
println("val_a => $val_a \t val_b => $val_b")

// 打印结果为：
var_a => 10      var_b => 5 
val_a => 100     val_b => 50

在类中声明以及声明可空变量

类中声明变量

声明类的属性特点：必须初始化，如果不初始化，需使用lateinit关键字。
例：

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()// 实例化

// 输出
var_a => 10      val_a => 0

声明可空变量

在java中，当我们定义一个变量是不需要关心是否为空，但在使用该变量时却需要判断是否为空，这是就会增加一定的代码量，而在kotlin中我们可以确定这个属性或变量一定不为空时，我们就用上面讲解到的去定义变量。否则就把它声明为可空变量。

可空变量的特点：

1.在声明的时候一定用标准的声明格式定义。不能用可推断类型的简写。
2.变量类型后面的?符号不能省略。不然就和普通的变量没区别了。
3.其初始化的值可以为null或确定的变量值。

定义：

var/val 变量名 ： 类型? = null/确定的值

例：

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 => null

后期初始化属性

声明后期初始化属性的特点：

 1. 使用lateinit关键字
 2. 必须是可读且可写的变量，即用var声明的变量
 3. 不能声明于可空变量。
 4. 不能声明于基本数据类型变量。例：Int、Float、Double等，注意：String类型是可以的。
 5. 声明后，在使用该变量前必须赋值，不然会抛出UninitializedPropertyAccessException异常。

实例讲解：举一个Android中常见的例子

// 声明组件
private lateinit var mTabLayout : TabLayout
lateinit var a : Int // 会报错。因为不能用于基本数据类型。
// 赋值
mTabLayout = find(R.id.home_tab_layout)
// 使用
mTabLayout.setupWithViewPager(mViewPager)

延迟初始化属性

所谓延迟初始化即：指当程序在第一次使用到这个变量（属性）的时候在初始化。

声明延迟初始化属性的特点：

1.使用lazy{}高阶函数，不能用于类型推断。且该函数在变量的数据类型后面，用by链接。
2.必须是只读变量，即用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.在伴生对象中声明

举例说明：

// 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 => 伴生对象中声明

我也是刚开始学习，这些都是我总结的一些关于kotlin的基础，如有出错欢迎指正。