Kotlin基本语法之概述

摘要: 基本语法之概述

一、包名的定义

包名需要放在文件的开头部分。但是不需要匹配目录和包，源文件可以放在任意目录中。

package my.demo

import java.util.*
// ...

二、变量

Kotlin 变量分为** 可变变量** 和 不可变变量。

可变变量使用

var

声明。

不可变变量使用

val

声明。一旦声明，不可修改。(

const val

相当于 java 中的

final

)。

举例说明：

val a: Int = 1  // 显示指定常量的类型

val b = 2   // 自动推断类型为‘Int’

val c: Int  //  声明一个不初始化的常量，必须显示指定类型

c = 3     // 赋值后，值不可再更改

// 变量的声明方式同常量，唯一不同的是赋值后，值可改变

var x = 5 // 自动推断类型为‘Int’

x += 1

三、注释

kotlin的注释同Java/JavaScript:

// This is an end-of-line comment

/* This is a block comment
on multiple lines. */

五、字符串模板的使用

           见 Koltin(二)

六、空值处理

           见 Koltin(四)

七、类型检查和自动类型转换

           见 Koltin(五)

八、控制语句

           见 Koltin(六)

九、区间的使用

           见 Koltin(七)

十、集合的使用

           见 Koltin(八)

十一、数组

           见 Koltin(九)

十二、函数的定义

标准语法：

fun 方法名 （参数名1 : 参数类型1，参数名2 : 参数类型2，...）: 返回值类型 {

                 方法体

}

例子：

fun sum(a: Int, b: Int): Int {
return a + b
}

方便起见，我们也可以直接在方法后面直接加 = 表达式， 返回值的类型会自动推算出来：

fun sum(a: Int, b: Int) = a + b

当函数返回无意义值时，可以使用

Unit

类型（相当于Java中的void），也可以省略不写：

fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}

fun printSum(a: Int, b: Int) {
println("sum of $a and $b is ${a + b}")
}

函数在后面的文章中还会具体讲解。

十三、相等性

Kotlin 中有两种类型的相等性：

引用相等（两个引用指向同一对象）；

结构相等（用 equals() 检查）。

13.1 引用相等

引用相等是通过

=== 操作符

判断的，不相等判断使用

!==

操作符。

如：

a===b

只有

a

，

b

指向同一个对象是判别才成立。

13.2 结构相等（值相等）

结构相等由 ==（以及其否定形式 !=）操作判断。

按照惯例，像 a == b 这样的表达式会翻译成：

a?.equals(b) ?: (b === null)

也就是说如果

a

不是

null

则调用

equals(Any?)

函数，否则（即

a

是

null

）检查

b

是否与

null

引用相等。

请注意，当与

null

显式比较时完全没必要优化你的代码：

a == null

会被自动转换为

a=== null

。

以上实例可以参见 Koltin(二) “Kotlin 装箱以及字符串比较“”部分。

十四、异常处理

14.1 异常类

Kotlin 中所有异常类都是 Throwable 类的子孙类。 每个异常都有消息、堆栈回溯信息和可选的原因。

使用

throw-表达式

来抛出异常：

throw MyException("Hi There!")

使用

try-表达式

来捕获异常：

try {
// 一些代码
}
catch (e: SomeException) {
// 处理程序
}
finally {
// 可选的 finally 块
}

可以有零到多个 catch 块。finally 块可以省略。 但是 catch 和 finally 块至少应该存在一个。

14.2 Try 是一个表达式

try 是一个表达式，即它可以有一个返回值：

val a: Int? = try {
parseInt(input)
} catch (e: NumberFormatException) {
null
}

try-表达式的返回值是 try 块中的最后一个表达式或者是（所有）catch 块中的最后一个表达式。 finally 块中的内容不会影响表达式的结果。

14.3 受检的异常

Kotlin 没有受检的异常。这其中有很多原因，但我们会提供一个简单的例子:

以下是 JDK 中 StringBuilder 类实现的一个示例接口：

Appendable append(CharSequence csq) throws IOException;

这个签名是什么意思？ 它是说，每次我追加一个字符串到一些东西（一个 StringBuilder、某种日志、一个控制台等）上时我就必须捕获那些 IOException。 为什么？因为它可能正在执行 IO 操作（Writer 也实现了 Appendable）…… 所以它导致这种代码随处可见的出现：

try {
log.append(message)
}
catch (IOException e) {
// 必须要安全
}

这并不好，参见《Effective Java》 第 65 条：不要忽略异常。

Bruce Eckel 在《Java 是否需要受检的异常？》（Does Java need Checked Exceptions?） 中指出：

通过一些小程序测试得出的结论是异常规范会同时提高开发者的生产力和代码质量，但是大型软件项目的经验表明一个不同的结论——生产力降低、代码质量很少或没有提高。
其他相关引证：

《Java 的受检异常是一个错误》（Java’s checked exceptions were a mistake）（Rod Waldhoff）
《受检异常的烦恼》（The Trouble with Checked Exceptions）（Anders Hejlsberg）

14.4 Nothing 类型

在 Kotlin 中

throw

是表达式，所以你可以使用它（比如）作为

Elvis 表达式

的一部分：

val s = person.name ?: throw IllegalArgumentException("Name required")

throw 表达式的类型是特殊类型 Nothing。 该类型没有值，而是用于标记永远不能达到的代码位置。 在你自己的代码中，你可以使用 Nothing 来标记一个永远不会返回的函数：

fun fail(message: String): Nothing {
throw IllegalArgumentException(message)
}

当你调用该函数时，编译器会知道执行不会超出该调用：

val s = person.name ?: fail("Name required")
println(s)     // 在此已知“s”已初始化

可能会遇到这个类型的另一种情况是类型推断。这个类型的可空变体 Nothing? 有一个可能的值是 null。如果用 null 来初始化一个要推断类型的值，而又没有其他信息可用于确定更具体的类型时，编译器会推断出 Nothing? 类型：

val x = null           // “x”具有类型 `Nothing?`
val l = listOf(null)   // “l”具有类型 `List<Nothing?>