Kotlin——初级篇（二）：变量、常量、注释

在Kotlin中的变量、常量以及注释多多少少和Java语言是有着不一样之处的。不论是变量、常量的定义方式，仍是注释的使用。下面详细的介绍Kotlin中的变量、常量、注释的使用。以及和Java的对比。
若是您尚未搭建环境和不了解Kotlin的，请看个人上一篇博文Kotlin——初级篇（一）：开发环境搭建

目录

1、Kotlin之变量用法

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

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

1.一、基础用法

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

例：这是在顶层声明的时候

//当即初始化
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

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

1.二、在类中声明以及声明可空变量

1.2.一、类中声明变量

上面的是演示变量的基础定义。并且只有在顶层声明的状况下是能够不用实例化的。可是在实际开发当中，通常都是在一个类中去定义变量，这种状况被称为声明类的属性。在后面Kotlin——中级篇（二）：属性与字段详解章节会详细的讲解。这里讲解其声明的特色并实例分析。

其特色以下：必须初始化，若是不初始化，需使用lateinit关键字。参见1.3节。

例：

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

其中：在上面的例子中，你们只要关心类中声明变量的用法就能够了。其余的不用关心，这里只是为了能看到程序运行结果。

1.2.二、声明可空变量

在Java中，当咱们声明一个变量没必要关心这个变量是否为空，在使用这个变量的时候几乎上都会判断其是否为空增长程序的安全性。这样的习惯是极好的。可是无形中也增长了必定的代码量。有时候这样的代码还极有多是无用的废代码。然而在Kotlin中当咱们能够肯定这个属性或变量必定不为空时，咱们就用上面讲解到的去定义变量。不然就把它声明为可空变量。

可空变量的特色：

• 在声明的时候必定用标准的声明格式定义。不能用可推断类型的简写。
• 变量类型后面的?符号不能省略。否则就和普通的变量没区别了。
• 其初始化的值能够为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

关于可空变量的定义就上面那么多。可是在使用可空变量的时候就没有Java中那么复杂了。关于可空变量的使用请参见个人Kotlin——初级篇（六）： 可空类型、空安全、非空断言、类型转换等特性总结这篇文章。

1.三、后期初始化与延迟初始化

在1.2节中，当在类中定义一个变量（属性）的时候是必须初始化的。这在平时的实际开发中能知足大部分的需求。可是仍是有一些特殊的场景中不能知足。好比说：Android开发中对组件变量的声明与赋值，以及在使用Dagger2注解变量等。这就须要Kotlin中特有的后期初始化属性来知足这个需求了。固然这里还为你们讲解延迟初始化，在实际的开发中也是颇有用处的。

1.3.一、后期初始化属性

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

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

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

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

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

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

// 使用
mTabLayout.setupWithViewPager(mViewPager)

1.3.二、延迟初始化属性

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

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

• 使用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{
    "我是延迟初始化字符串变量"
}

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

3、Kotlin之注释

Kotlin中的注释几乎和Java没什么区别。惟一的区别在于Kotlin中的多行注释中能够嵌套多行注释，而Java中是不能的。

• 单行注释

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

举例：

// 1. 单行注释

• 多行注释（块注释）

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

举例：

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

• 多行注释嵌套

kotlin中块注释的级联使用，其实我的以为块注释的嵌套使用的意义不大，不过从视觉上确实能给人一种层次感

举例：

/*
    第一层块注释
    /*
        第二层块注释
        /*
            第三层快注释
            这种注释方式在java中是不支持的，可是在kotlin中是支持的。算是一个亮点吧（貌似意义不大）。
         */
     */
 */

注：在Java中使用上面的注释代码直接报错。

• 类注释、方法注释

  和Java是同样的

举例：

/**
 *  3. 方法的注释（同java同样）
 */
fun testMethodNote(){
    
}

4、尾语

对于Kotlin中的变量、常量及注释就讲解到这里。对于Kotlin的数据类型、控制语句等基础语法会在后面的章节中更新。并提供源码。
源代码

若是各位大佬看了以后感受还阔以，就请各位大佬随便star一下，您的关注是我最大的动力。
个人我的博客：Jetictors
掘金 ： Jetictors
Github：Jteictors

欢迎各位大佬进群共同研究、探索

QQ群号：497071402