1 标识符和关键字

1.1 标识符

标识符 就是用于给程序中的变量、常量、函数、类、接口、枚举等命名的名字。标识符的长度没有限制。

Kotlin语言中的标识符的命名规则如下：

区分大小写，因此Abc和abc是两个不同的标识符。
可以由字符、数字和下划线组成，但不能以数字开头。并不局限于26个英文字符，可以包含中文字符、日文字符等等（以后给老外开发程序全尼玛用中文定义变量和常量，哈哈哈）。
硬关键字不能作为标识符，软关键字、修饰符关键字在它们的适用场景之外可以作为标识符适用。
标识符不能包含空格。
标识符只能包含下划线（ _ ），不能包含@、#等特殊字符，这点与Java不同。
特定标识符 field 和 it 。在Kotlin中有两个又编译器定义的特定标识符，它们只能在特定场景中适用有特定的作用，即不需要声明就可以使用的参数。
如果一定要使用关键字作为标识符，可以在关键字前后添加反引号（`）
Kotlin字母采用的是双字节Unicode编码。Unicode叫作统一编码制，它包含了亚洲文字编码，如中文，日文，韩文等。

标识符示例：

    var userName = "社会我鹏哥"        // 合法
    var User_Name = "人狠话不多"       // 合法
    var _Study_Kotlin = "学习Kotlin"  // 合法
    var 身高 = "一米六一米七"           // 合法

    var 666TokyoHot = "东京热"        // 不合法，不能以数字开头
    var tel_*#06# = "13812345678"    // 不合法，不能包含特殊字符*，#）
    var &Name = "Freeman"            // 不合法，不能以&开头
    var class = "HelloKt.class"      // 不合法，不能用关键字

    var `class` = "HelloKt.class"    // 合法，class是硬关键字，前后添加反引号，可以用于声明标识符
    var public = "共有的"             // 合法，public是修饰符关键字，可以用于声明变量标识符
    val `π` = "3.14159"              // 合法

    val it = 100                     // 合法，it是普通标识符，由开发人员定义的
    val ary = arrayListOf<String>("A", "B", "C")
    ary.forEach { println(it) }      // it是特定标识符，由编译器定义的

1.2 关键字

在 Kotlin 中有一些具有特殊用途的单词被称为关键字，当定义标识符时，不要让标识符与关键字相同，否则将引起错误。

Kotlin的关键字分为三类：硬关键字、软关键字、修饰符关键字

硬关键字：这些关键字无论什么情况下都不能用作标识符。
软关键字：这些关键字可以在它们不起作用的上下文中用作标识符。
修饰符关键字：这些关键字也可以在代码中用作标识符。

硬关键字包括： as、as?、break、class、continue、do、else、false、for、fun、if、in、!in、is、!is、 null、object、package、return、super、this、throw、true、try、typealias、val、var、 when、while

软关键字包括： by、catch、constructor、delegate、dynamic、field、file、finally、get、import、init、param、property、receiveris、set、setparam、where

修饰符关键字：abstract、annotation、companion、const、crossinline、data、enum、external、final、infix、inline、inner、internal、lateinit、noinline、open、out、override、private、protected、public、reified、sealed、tailrec、vararg

2 变量和常量

2.1 变量

在 Kotlin 中，所有的变量类型都是引用类型，变量必须先声明后使用，声明变量时必须显式或隐式指定变量的类型。

声明变量需要使用 var 或 val，如下所示:

var | val 变量名 [:类型] [=初始值]

val 是只读的，仅能一次赋值，后面就不能被重新赋值
var 是可写的，在它生命周期中可以被多次赋值

fun main(args: Array<String>) {
    // 声明变量时显式指定类型
    var b: Int
    // 声明变量时指定初始值，编译器会根据初始值确定该变量的类型为 String
    var name = "google"
    b = 20  // b 的类型是 Int(整型〉，赋值正确
    name = "play" // name 的类型为 String，赋值正确
    name = 12     // name 的类型为 String，但 12 为 Int，赋值错误

    // 声明变量时既显式指定类型，也指定初始值，显式指定的类型与初始值的类型 一致，声明变量正确
    var age: Int = 25
    age = 12  // age 的类型是 Int， 赋值正确

    // 声明变量时既显式指定类型，也指定初始值，显式指定的类型与初始值的类型 不一致，声明变量失败
    var sun: String = 500
    val book = "金瓶梅"
    book = "a" // 使用 val 声明的变量是不可变变量，不能被重新赋值
}

2.1 常量和只读变量

常量和只读变量一旦初始化后就不能被修改，声明常量是在标识符的前面加上 val 或 const val 关键字，它们的区别如下：

val 声明的是运行期常量，常量是在运行时初始化的
const val 声明的是编译期常量，常量是在编译时初始化，只能用于顶层常量声明或声明对象中的常量声明，而且只能是 String 或基本数据类型。

编译期常量（const val）相当于 Java 中 public final static 所修饰的常量；运行期常量（val）相当于 Java 中的 final 所修饰的常量。

package com.example.grammar

const val MAX_COUNT = 1000             //声明顶层常量

const val _Hello1 = "Hello，world"     //声明顶层常量

// 编译错误，运行期顶层常量只能是 String 或基本类型
const val _Hello2 = StringBuilder("HelloWorld")

// 声明对象
object UserDAO {
    const val MAX_COUNT = 100 //声明对象中的声明常量
}

fun main(args: Array<String>) {
    // 正确
    val scoreForStudent: Float = 0.0f
    
    // 编译错误，因为这里试图修改 _Hello1 常量值
    _Hello1 = "Hello, World"
    val y = 20
    y = 30 

    // 编译错误，在函数中的运行期常量，因为运行期常量只能用于顶层常量声明或声明对象中的常量声明
    const val x = 10
}

3 注释

Kotlin 的注释与 Java 基本保持一致，Kotlin 注释同样支持单行注释、多行注释、文档注释。

3.1 单行注释和多行注释

单行注释就是在程序中注释一行代码，在 Kotlin 语言中，将双斜线（//）放在需要注释的内容之前就可以了;

多行注释是指一次性地将程序中的多行代码注释掉，在 Kotlin语言中，使用 “ /* ” 和 “ */ ”

将程序中需要注释的内容包含起来，其中“ /* ” 表示注释开始，而“ */ ”

表示注释结束。需要指出的是， Java 语言的多行注释不支持嵌套，而 Kotlin 语言的多行注释支持嵌套，这样用起来就更方便了。

/*
这里面的内容全部是多行注释
Kotlin 语言真的很简单
*/
fun main(args: Array<String>) {
    // 这是一行简单 的注释
    println("Hello World1")

    // print(”这行代码被注释了，将不会被编译、执行!”) 

    /* 这是第一个多行注释的开头 
       /* 这是第二个被嵌套的多行注释 */  
    这是第一个多行注释的结尾 */
}

3.2 文档注释

Kotlin 的文档注释和 Java 相同，同样使用 /** 和 */ 来进行文档注释，中间部分全部都是文档注释，会被提取到 API文档中。

/**
 * Description:
 * This program is protected by copyright laws.
 * Program Name:
 * Date:
 * @author Freeman
 * @version 1.0
 * @property name the name of this group.
 * @constructor Creates an empty group.
 */
public class DocTest {
	/**
	 * 两个数相加
	 * @param a 第一个数
	 * @param b 第二个数
	 * @return  两数之和
	 */
	public fun add(a: Int, b: Int): Int { 
		return a + b
	}
}

4 语句和表达式

Kotlin 代码是由关键字、标识符、语句和表达式等构造，语句和表达式是代码的重要组成部分。

4.1 语句

语句关注的是代码执行过程，如for、while、do-while等。在Kotlin语言中，一条语句结束后可以不加分号，也可以加分号，但是有一种情况必须加分号，那就是多条语句写在一行的时候，需要通过分号来区分语句。

var a1 : Int = 50; var a2: Int = 20;

4.2 表达式

表达式位于赋值符（=）的右边，并且会返回明确的结果。如：10、20是最简单形式的表达式

var a1 : Int = 10
var a2: Int = 20;

为了使代码更加简洁，Kotlin将Java中一些语句进行了简化，使之成为一种表达式，包括：控制结构表达式、try表达式、表达式函数和对象表达式

public fun main(args: Array<String>) {

    val englishScore = 95
    val chineseScore = 98

    // if 控制结构表达式
    val result = if (englishScore < 60) "不及格" else "及格"
    println(result)

    val totalScore = sum(englishScore, chineseScore)
    println(totalScore)

    // try 表达式
    val score = try {
        //TODO
    } catch (e: Exception) {
        return
    }
}

fun sum(a: Int, b: Int): Int = a + b    //表达式函数体

Kotlin 语法基础