【Kotlin -- 知识点】变量 & 常量 & 注释

本文详细的介绍 Kotlin 中的变量、常量、注释的使用。

一、变量

Kotlin 变量的声明方式与 Java 中声明变量有很大的区别，而且必须使用 var 或 val 关键字。其中：

• var: 用此关键字声明的变量表示可变变量，即可读且可写。相当于 Java 中普通变量
• val: 用此关键字声明的变量表示不可变变量，即可读且不可写。相当于 Java 中用 final 修饰的变量

1. 基础用法

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

例子：

fun main() {
    basisVariable()
}

/**
 * 基础变量的定义及用法
 */
private fun basisVariable() {
    //立即初始化
    var varA: Int = 10

    //推导出类型
    var varB = 5

    //没有初始化的时候，必须声明类型
    var varC: Float
    varC = 12.3f
    varC += 1

    println("varA => $varA \t varB => $varB \t varC => $varC")

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

    //推导出类型
    val valB = 50

    //没有初始化的时候，必须声明类型
    val valC: Int
    valC = 1
    // val_c += 1 因为c是常量，所以这句代码是会报错的

    println("valA => $valA \t valB => $valB \t valC => $valC")
}

输出结果：

说明：

• var 和 val 是 Kotlin 中定义变量必须使用的关键字。
• 每一行代码的结束可以省略掉分号;，这一点是和 Java 不同的地方。当然，第一次写可能会有一点不习惯。
• print() 与 println() 都是打印方法，后者打印完成之后会换一行。此两个方法和 Java 的打印方法是一模一样的。
• $符号表示引用的意思。这里理解为字符串模板

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

• 类中声明变量

在实际开发当中，一般都是在一个类中去定义变量，这种情况被称为声明类的属性。

例子：

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")
    }
}

----------------------分隔线----------------------
fun main() {
    Test1()
}

输出结果：

• 声明可空变量

特点：

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

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

例子：

class Test1 {
    // 声明可空变量
    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")
    }
}

----------------------分隔线----------------------
fun main() {
    Test1()
}

输出结果：

3. 后期初始化与延迟初始化

• 后期初始化属性

特点：

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

例子：

// 声明组件
private lateinit var mTabLayout : TabLayout

lateinit var a : Int // 会报错。因为不能用于基本数据类型。

// 赋值
mTabLayout = find(R.id.home_tab_layout)

// 使用
mTabLayout.setupWithViewPager(mViewPager)

• 延迟初始化属性

特点：

• 使用 lazy{} 高阶函数，不能用于类型推断。且该函数在变量的数据类型后面，用 by 链接。
• 必须是只读变量，即用 val 声明的变量。

例子：

// 声明一个延迟初始化的字符串数组变量
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 中使用 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. 顶层声明
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() {
    println("NUM_A => $NUM_A")
    println("NUM_B => ${TestConst.NUM_B}")
    println("NUM_C => ${TestClass.NUM_C}")
}

输出结果：

三、注释

1. 单行注释

两个斜杠开头表示单行注释（//）

举例：

// 单行注释

2. 多行注释（块注释）

以斜杠加星号开头（/），同时以星号加斜杠结尾（/），中间这是要注释的代码块！

举例：

/*
多行注释（块注释）
我是多行注释
*/

3. 类注释、方法注释

类注释和 Java 是一样的，这里不做表述，重点看方法注释

举例：

/**
  * 测试函数
  * [numA] 参数a
  * [numB] 参数b
  */
fun testMethodNote(int numA, int numB){

}