Kotlin 教程

Kotlin 教程

/kotlin/

Kotlin 教程

Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，被称之为 Android 世界的Swift，由 JetBrains 设计开发并开源。

Kotlin 可以编译成Java字节码，也可以编译成 JavaScript，方便在没有 JVM 的设备上运行。

在Google I/O 2017中，Google 宣布 Kotlin 成为 Android 官方开发语言。

我的第一个 Kotlin 程序

Kotlin 程序文件以 .kt 结尾，如： 、。

最简版

package hello // 可选的包头 fun main(args: Array) { // 包级可见的函数，接受一个字符串数组作为参数 println("Hello World!") // 分号可以省略 }

面向对象

class Greeter(val name: String) { fun greet() { println("Hello,

$name") } } fun main(args: Array) { Greeter(args[0]).greet() // 创建一个对象不用 new 关键字 }

为什么选择 Kotlin？

•

•

简洁: 大大减少样板代码的数量。

安全: 避免空指针异常等整个类的错误。

•

•

互操作性: 充分利用 JVM、Android 和浏览器的现有库。

工具友好: 可用任何 Java IDE 或者使用命令行构建。

参考链接

•

•

•

•

官方网站

官方示例

官方网站 - 中文翻译

Kotlin 在线工具

Kotlin IntelliJ IDEA环境搭建

IntelliJ IDEA 免费的社区版下载地址：/idea/download/

下载安装后，我们就可以使用该工具来创建项目，创建过程需要选择 SDK， Kotlin 与

JDK 1.6+ 一起使用。

在右侧的下拉菜单中勾选 Kotlin (Java) 复选框。

接下来我们取一个项目名:HelloWorld

项目创建完后，文件结构如下，跟 Java 的还是很类似的。

接下来 我们点击 src 文件夹，创建一个 Kotlin 文件，它可以任意命名，这里我们创建

接下来，我们在 文件中写点代码。IntelliJ IDEA 为我们提供了一个快速完成此操作的模板，只需键入 main 然后按 Tab 即可。

现在我们添加一行代码来打印出"Hello, World!"吧。

接下来我们可以鼠标点击编辑器右上角 kotlin图标并选择 Run 'AppKt'来运行代码：

运行成功后就可以在窗口 Run 中看到结果。

这样我们第一个 Kotlin 代码就运行起来了。

Kotlin Eclipse 环境搭建

Eclipse 通过 Marketplace 安装 Kotlin 插件，打开 Eclipse，选择 Help -> Eclipse

Marketplace… 菜单，搜索 Kotlin 插件：

然后重启 Eclipse 选择 Window -> Open Perspective -> ，如果看到了 Kotlin 选项表明安装成功。

创建新项目

选择 File -> New -> Kotlin Project 来创建 Kotlin 项目：

创建成功后，项目结构如下：

接下来 我们点击 src 文件夹，创建一个 Kotlin 文件，不用写 ".kt" ，默认自动添加，它可以任意命名，这里我们创建 hello

接下来，我们在 文件中写点代码。Eclipse 为我们提供了一个快速完成此操作的模板，只需键入 main 然后按 Enter 即可。

运行应用

接下来我们在 的编辑框内右击鼠标选择 Run As -> Kotlin Application 即可运行：

运行成功后就可以在窗口 Console 中看到结果。

这样我们第一个 Kotlin 代码就运行起来了。

Kotlin 使用命令行编译

Kotlin 命令行编译工具下载地址：/JetBrains/kotlin/releases/tag/v1.1.2-2，目前最新为 1.1.2-2。

你可以选择一个最新的稳定版下载。

下载完成后，解压到指定目录，然后将 bin 目录添加到系统环境变量。bin 目录包含编译和运行 Kotlin 所需的脚本。

SDKMAN!

在 OS X、Linux、Cygwin、FreeBSD 和 Solaris 系统上也可以使用更简单的安装方法，命令如下：

$ curl -s | bash

$ sdk install kotlin

Homebrew

在 OS X 下，你可以使用 Homebrew 安装：

$ brew update

$ brew install kotlin

MacPorts

如果你是 MacPorts 用户，可以使用以下命令安装：

$ sudo port install kotlin

创建和运行第一个程序

创建一个名为 文件，代码如下：

fun main(args: Array) { println("Hello, World!") }

使用 Kotlin 编译器编译应用:

$ kotlinc -include-runtime -d

•

•

-d: 用来设置编译输出的名称，可以是 class 或 .jar 文件，也可以是目录。

-include-runtime : 让 .jar 文件包含 Kotlin 运行库，从而可以直接运行。

如果你想看所有的可用选项，运行:

$ kotlinc -help

运行应用

$ java -jar

Hello, World!

编译成库

若需要将生成的 jar 包供其他 Kotlin 程序使用，可无需包含 Kotlin 的运行库：

$ kotlinc -d

由于这样生成的 .jar 文件不包含 Kotlin 运行库，所以你应该确保当它被使用时，运行时在你的 classpath 上。

你也可以使用 kotlin 命令来运行 Kotlin 编译器生成的 .jar 文件

$ kotlin -classpath HelloKt

HelloKt 为编译器为 文件生成的默认类名。

运行 REPL（交互式解释器）

我们可以运行如下命令得到一个可交互的 shell，然后输入任何有效的 Kotlin 代码，并立即看到结果

使用命令行执行脚本

Kotlin 也可以作为一个脚本语言使用，文件后缀名为 .kts 。

例如我们创建一个名为 list_，代码如下：

import

val folders = File(args[0]).listFiles { file -> ctory() }

folders?.forEach { folder -> println(folder) }

执行时通过 -script 选项设置相应的脚本文件。

$ kotlinc -script list_

$ kotlinc -script list_

Kotlin Android 环境搭建

安装 Kotlin 插件

Android Studio 从 3.0（preview）版本开始将内置安装 Kotlin 插件。

打开 Settings ( Mac 为 Preferences) 面板，在右侧找到 Plugins 选项 (快捷键 Ctrl+,

Mac 下为 command+)，搜索框输入 "Kotlin" 查找，点击 Search in repositories(仓库中搜索)，然后安装即可，安装完成之后需要重启 Android Studio。

创建新工程

选择 Start a new Android Studio project 或者 File | New project，大多数选项均有默认值 ，只需要按几次"回车"键即可。

Android Studio 3.0 在当前对话框中提供启用 Kotlin 支持的选项，勾选后可以跳过 "配置

Kotlin 工程（Configuring Kotlin in the project）"的步骤。

选择 Android 版本:

选择需要创建的 Activity 样式:

命名该 Activity:

在 Android Studio 3.0 中，可以选择使用 Kotlin 创建 activity，因此也不需要"将Java 代码转换为 Kotlin（Converting Java code to Kotlin）"这一步骤。

早期版本中则会先使用 Java 创建 activity，然后再使用自动转换工具 进行转换。

将 Java 代码转换为 Kotlin

重新打开Android Studio，新建一个Android项目吧，添加一个默认的MainActivity

打开 文件，通过菜单栏依次调出 Code | Convert Java File to Kotlin

File：

转换完成后即可看到使用 Kotlin 编写的 activity。

工程中配置 Kotlin

在开始编辑此文件时，Android Studio 会提示当前工程还未配置 Kotlin，根据提示完成操作即可，或者可以在菜单栏中选择 Tools

选择配置时有如下对话框，选择已安装的最新版本即可。

Kotlin 配置完成后，应用程序的 文件会更新。 你能看到新增了 apply

plugin: 'kotlin-android' 及其依赖。

同步工程，在提示框中点击"立即同步（Sync Now）"或者使用 Sync Project with Gradle

Files命令。

Kotlin 基础语法

Kotlin 文件以 .kt 为后缀。

包声明

代码文件的开头一般为包的声明：

package

import .*

fun test() {}

class Runoob {}

kotlin源文件不需要相匹配的目录和包，源文件可以放在任何文件目录。

以上例中 test() 的全名是 、Runoob 的全名是

。

如果没有指定包，默认为 default 包。

默认导入

有多个包会默认导入到每个 Kotlin 文件中：

•

•

•

•

•

•

•

•

kotlin.*

tion.*

tions.*

isons.*

.*

.*

ces.*

.*

函数定义

函数定义使用关键字 fun，参数格式为：参数 : 类型

fun sum(a: Int, b: Int): Int { // Int 参数，返回值 Int

return a + b

}

表达式作为函数体，返回类型自动推断：

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

public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型

无返回值的函数(类似Java中的void)：

fun printSum(a: Int, b: Int): Unit {

print(a + b)

}

// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：

public fun printSum(a: Int, b: Int) {

print(a + b)

}

可变长参数函数

函数的变长参数可以用 vararg 关键字进行标识：

fun vars(vararg v:Int){

for(vt in v){

print(vt)

}

}

// 测试

fun main(args: Array) {

vars(1,2,3,4,5) // 输出12345

}

lambda(匿名函数)

lambda表达式使用实例：

// 测试

fun main(args: Array) {

val sumLambda: (Int, Int) -> Int = {x,y -> x+y}

println(sumLambda(1,2)) // 输出 3

}

定义常量与变量

可变变量定义：var 关键字

var <标识符> : <类型> = <初始化值>

不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)

val <标识符> : <类型> = <初始化值>

常量与变量都可以没有初始化值,但是在引用前必须初始化

编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

val a: Int = 1

val b = 1 // 系统自动推断变量类型为Int

val c: Int // 如果不在声明时初始化则必须提供变量类型

c = 1 // 明确赋值

var x = 5 // 系统自动推断变量类型为Int

x += 1 // 变量可修改

注释

Kotlin 支持单行和多行注释，实例如下：

// 这是一个单行注释

/* 这是一个多行的

块注释。 */

与 Java 不同, Kotlin 中的块注释允许嵌套。

字符串模板

$ 表示一个变量名或者变量值

$varName 表示变量值

${()} 表示变量的方法返回值:

var a = 1

// 模板中的简单名称：

val s1 = "a is $a"

a = 2

// 模板中的任意表达式：

val s2 = "${e("is", "was")}, but now is $a"

NULL检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

//类型后面加?表示可为空

var age: String? = "23"

//抛出空指针异常

val ages = age!!.toInt()

//不做处理返回 null

val ages1 = age?.toInt()

//age为空返回-1

val ages2 = age?.toInt() ?: -1

当一个引用可能为 null 值时, 对应的类型声明必须明确地标记为可为 null。

当 str 中的字符串内容不是一个整数时, 返回 null:

fun parseInt(str: String): Int? {

// ...

}

以下实例演示如何使用一个返回值可为 null 的函数:

fun main(args: Array) {

if ( < 2) {

print("Two integers expected")

return

}

val x = parseInt(args[0])

val y = parseInt(args[1])

// 直接使用 `x * y` 会导致错误, 因为它们可能为 null.

if (x != null && y != null) {

// 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量

print(x * y)

}

}

类型检测及自动类型转换

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。

fun getStringLength(obj: Any): Int? {

if (obj is String) {

// 做过类型判断以后，obj会被系统自动转换为String类型

return

}

//在这里还有一种方法，与Java中instanceof不同，使用!is

// if (obj !is String){

// // XXX

// }

// 这里的obj仍然是Any类型的引用

return null

}

或者

fun getStringLength(obj: Any): Int? {

if (obj !is String)

return null

// 在这个分支中, `obj` 的类型会被自动转换为 `String`

return

}

甚至还可以

fun getStringLength(obj: Any): Int? {

// 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`

if (obj is String && > 0)

return

return null

}

区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。

区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:

for (i in 1..4) print(i) // 输出“1234”

for (i in 4..1) print(i) // 什么都不输出

if (i in 1..10) { // 等同于 1 <= i && i <= 10

println(i)

}

// 使用 step 指定步长

for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

// 使用 until 函数排除结束元素

for (i in 1 until 10) { // i in [1, 10) 排除了 10

println(i)

}

实例测试

fun main(args: Array) {

print("循环输出：")

for (i in 1..4) print(i) // 输出“1234”

println("n----------------")

print("设置步长：")

for (i in 1..4 step 2) print(i) // 输出“13”

println("n----------------")

print("使用 downTo：")

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

println("n----------------")

print("使用 until：")

// 使用 until 函数排除结束元素

for (i in 1 until 4) { // i in [1, 4) 排除了 4

print(i)

}

println("n----------------")

}

输出结果：

循环输出：1234

----------------

设置步长：13

----------------

使用 downTo：42

----------------

使用 until：123

----------------

Kotlin 基本数据类型

Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于Java的是，字符不属于数值类型，是一个独立的数据类型。

类型 位宽度

Double

Float

Long

Int

Short

Byte

64

32

64

32

16

8

字面常量

下面是所有类型的字面常量：

•

•

•

•

•

十进制：123

长整型以大写的 L 结尾：123L

16 进制以 0x 开头：0x0F

2 进制以 0b 开头：0b00001011

注意：8进制不支持

Kotlin 同时也支持传统符号表示的浮点数值：

•

•

Doubles 默认写法:

123.5,

123.5e10

Floats 使用 f 或者 F 后缀：123.5f

你可以使用下划线使数字常量更易读：

val oneMillion = 1_000_000

val creditCardNumber = 1234_5678_9012_3456L

val socialSecurityNumber = 999_99_9999L

val hexBytes = 0xFF_EC_DE_5E

val bytes = 0b11010010_01101001_10010100_10010010

比较两个数字

Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，所有在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。

在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

fun main(args: Array) {

val a: Int = 10000

println(a === a) // true，值相等，对象地址相等

//经过了装箱，创建了两个不同的对象

val boxedA: Int? = a

val anotherBoxedA: Int? = a

//虽然经过了装箱，但是值是相等的，都是10000

println(boxedA === anotherBoxedA) // false，值相等，对象地址不一样

println(boxedA == anotherBoxedA) // true，值相等

}

类型转换

由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。 这意味着在不进行显式转换的情况下我们不能把 Byte 型值赋给一个 Int 变量。

val b: Byte = 1 // OK, 字面值是静态检测的

val i: Int = b // 错误

我们可以代用其toInt()方法。

val b: Byte = 1 // OK, 字面值是静态检测的

val i: Int = () // OK

每种数据类型都有下面的这些方法，可以转化为其它的类型：

toByte(): Byte

toShort(): Short

toInt(): Int

toLong(): Long

toFloat(): Float

toDouble(): Double

toChar(): Char

有些情况下也是可以使用自动类型转化的，前提是可以根据上下文环境推断出正确的数据类型而且数学操作符会做相应的重载。例如下面是正确的：

val l = 1L + 3 // Long + Int => Long

位操作符

对于Int和Long类型，还有一系列的位操作符可以使用，分别是：

shl(bits) – 左移位 (Java’s <<)

shr(bits) – 右移位 (Java’s >>)

ushr(bits) – 无符号右移位 (Java’s >>>)

and(bits) – 与

or(bits) – 或

xor(bits) – 异或

inv() – 反向

字符

和 Java 不一样，Kotlin 中的 Char 不能直接和数字操作，Char 必需是单引号''包含起来的。比如普通字符 '0'，'a'。

fun check(c: Char) {

if (c == 1) { // 错误：类型不兼容

// ……

}

}

字符字面值用单引号括起来: '1'。 特殊字符可以用反斜杠转义。 支持这几个转义序列：t、 b、n、r、'、"、 和 $。 编码其他字符要用 Unicode 转义序列语法：'uFF00'。

我们可以显式把字符转换为 Int 数字：

fun decimalDigitValue(c: Char): Int {

if (c !in '0'..'9')

throw IllegalArgumentException("Out of range")

return () - '0'.toInt() // 显式转换为数字

}

当需要可空引用时，像数字、字符会被装箱。装箱操作不会保留同一性。

布尔

布尔用 Boolean 类型表示，它有两个值：true 和 false。

若需要可空引用布尔会被装箱。

内置的布尔运算有：

|| – 短路逻辑或

&& – 短路逻辑与

! - 逻辑非

数组

数组用类 Array 实现，并且还有一个 size 属性及 get 和 set 方法，由于使用 [] 重载了

get 和 set 方法，所以我们可以通过下标很方便的获取或者设置数组对应位置的值。

数组的创建两种方式：一种是使用函数arrayOf()；另外一种是使用工厂函数。如下所示，我们分别是两种方式创建了两个数组：

fun main(args: Array) {

//[1,2,3]

val a = arrayOf(1, 2, 3)

//[0,2,4]

val b = Array(3, { i -> (i * 2) })

//读取数组内容

println(a[0]) // 输出结果：1

println(b[1]) // 输出结果：2

}

如上所述，[] 运算符代表调用成员函数 get() 和 set()。

注意: 与 Java 不同的是，Kotlin 中数组是不型变的（invariant）。

除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：

val x: IntArray = intArrayOf(1, 2, 3)

x[0] = x[1] + x[2]

字符串

和 Java 一样，String 是可不变的。方括号 [] 语法可以很方便的获取字符串中的某个字符，也可以通过 for 循环来遍历：

for (c in str) {

println(c)

}

Kotlin 支持三个引号 """ 扩起来的字符串，支持多行字符串，比如：

fun main(args: Array) {

val text = """

多行字符串

多行字符串

"""

println(text) // 输出有一些前置空格

}

String 可以通过 trimMargin() 方法来删除多余的空白。

fun main(args: Array) {

val text = """

|多行字符串

|软件开发网

|多行字符串

|Runoob

""".trimMargin()

println(text) // 前置空格删除了

}

默认 | 用作边界前缀，但你可以选择其他字符并作为参数传入，比如 trimMargin(">")。

字符串模板

字符串可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 模板表达式以美元符（$）开头，由一个简单的名字构成:

fun main(args: Array) {

val i = 10

val s = "i = $i" // 求值结果为 "i = 10"

println(s)

}

或者用花括号扩起来的任意表达式:

fun main(args: Array) {

val s = "runoob"

val str = "$ is ${}" // 求值结果为 " is 6"

println(str)

}

原生字符串和转义字符串内部都支持模板。 如果你需要在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义），你可以用下列语法：

fun main(args: Array) {

val price = """

${'$'}9.99

"""

println(price) // 求值结果为 $9.99

}

Kotlin 条件控制

IF 表达式

一个 if 语句包含一个布尔表达式和一条或多条语句。

// 传统用法

var max = a

if (a < b) max = b

// 使用 else

var max: Int

if (a > b) {

max = a

} else {

max = b

}

// 作为表达式

val max = if (a > b) a else b

我们也可以把 IF 表达式的结果赋值给一个变量。

val max = if (a > b) {

print("Choose a")

a

} else {

print("Choose b")

b

}

这也说明我也不需要像Java那种有一个三元操作符，因为我们可以使用它来简单实现：

val c = if (condition) a else b

实例

fun main(args: Array) {

var x = 0

if(x>0){

println("x 大于 0")

}else if(x==0){

println("x 等于 0")

}else{

println("x 小于 0")

}

var a = 1

var b = 2

val c = if (a>=b) a else b

println("c 的值为 $c")

}

输出结果为：

x 等于 0

c 的值为 2

使用区间

使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y ：

实例

fun main(args: Array) {

val x = 5

val y = 9

if (x in 1..8) {

println("x 在区间内")

}

}

输出结果为：

x 在区间内

When 表达式

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。

when 类似其他语言的 switch 操作符。其最简单的形式如下：

when (x) {

1 -> print("x == 1")

2 -> print("x == 2")

else -> { // 注意这个块

print("x 不是 1 ，也不是 2")

}

}

在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。

如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

when (x) {

0, 1 -> print("x == 0 or x == 1")

else -> print("otherwise")

}

我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

when (x) {

in 1..10 -> print("x is in the range")

in validNumbers -> print("x is valid")

!in 10..20 -> print("x is outside the range")

else -> print("none of the above")

}

另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。注意： 由于智能转换，你可以访问该类型的方法和属性而无需 任何额外的检测。

fun hasPrefix(x: Any) = when(x) {

is String -> With("prefix")

else -> false

}

when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

when {

() -> print("x is odd")

() -> print("x is even")

else -> print("x is funny")

}

实例

fun main(args: Array) {

var x = 0

when (x) {

0, 1 -> println("x == 0 or x == 1")

else -> println("otherwise")

}

when (x) {

1 -> println("x == 1")

2 -> println("x == 2")

else -> { // 注意这个块

println("x 不是 1 ，也不是 2")

}

}

when (x) {

in 0..10 -> println("x 在该区间范围内")

else -> println("x 不在该区间范围内")

}

}

输出结果：

x == 0 or x == 1

x 不是 1 ，也不是 2

x 在该区间范围内

when 中使用 in 运算符来判断集合内是否包含某实例：

fun main(args: Array) {

val items = setOf("apple", "banana", "kiwi")

when {

"orange" in items -> println("juicy")

"apple" in items -> println("apple is fine too")

}

}

输出结果：

apple is fine too

Kotlin 循环控制

For 循环

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:

for (item in collection) print(item)

循环体可以是一个代码块:

for (item: Int in ints) {

// ……

}

如上所述，for 可以循环遍历任何提供了迭代器的对象。

如果你想要通过索引遍历一个数组或者一个 list，你可以这么做：

for (i in s) {

print(array[i])

}

注意这种"在区间上遍历"会编译成优化的实现而不会创建额外对象。

或者你可以用库函数 withIndex：

for ((index, value) in dex()) {

println("the element at $index is $value")

}

实例

对集合进行迭代：

fun main(args: Array) {

val items = listOf("apple", "banana", "kiwi")

for (item in items) {

println(item)

}

for (index in s) {

println("item at $index is ${items[index]}")

}

}

输出结果：

apple

banana

kiwi

item at 0 is apple

item at 1 is banana

item at 2 is kiwi

while 与 do...while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {

//循环内容

}

do…while 循环 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {

//代码语句

}while(布尔表达式);

do { //代码语句 }while(布尔表达式);

实例

fun main(args: Array) {

println("----while 使用-----")

var x = 5

while (x > 0) {

println( x--)

}

println("----do...while 使用-----")

var y = 5

do {

println(y--)

} while(y>0)

}

输出结果：

5

4

3

2

1

----do...while 使用-----

5

4

3

2

1

返回和跳转

Kotlin 有三种结构化跳转表达式：

•

•

•

return。默认从最直接包围它的函数或者匿名函数返回。

break。终止最直接包围它的循环。

continue。继续下一次最直接包围它的循环。

在循环中 Kotlin 支持传统的 break 和 continue 操作符。

fun main(args: Array) {

for (i in 1..10) {

if (i==3) continue // i 为 3 时跳过当前循环，继续下一次循环

println(i)

if (i>5) break // i 为 6 时 跳出循环

}

}

输出结果：

1

2

4

5

6

Break 和 Continue 标签

在 Kotlin 中任何表达式都可以用标签（label）来标记。 标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签。 要为一个表达式加标签，我们只要在其前加标签即可。

loop@ for (i in 1..100) {

// ……

}

现在，我们可以用标签限制 break 或者continue：

loop@ for (i in 1..100) {

for (j in 1..100) {

if (……) break@loop

}

}

标签限制的 break 跳转到刚好位于该标签指定的循环后面的执行点。 continue 继续标签指定的循环的下一次迭代。

标签处返回

Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。 最重要的一个用途就是从 lambda 表达式中返回。回想一下我们这么写的时候：

fun foo() {

h {

if (it == 0) return

print(it)

}

}

这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。） 如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。

fun foo() {

h lit@ {

if (it == 0) return@lit

print(it)

}

}

现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。

fun foo() {

h {

if (it == 0) return@forEach

print(it)

}

}

或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回

fun foo() {

h(fun(value: Int) {

if (value == 0) return

print(value)

})

}

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@a 1

意为"从标签 @a 返回 1"，而不是"返回一个标签标注的表达式 (@a 1)"。

Kotlin 类和对象

类定义

Kotlin 类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明。

Kotlin 中使用关键字 class 声明类，后面紧跟类名：

class Runoob { // 类名为 Runoob

// 大括号内是类体构成

}

我们也可以定义一个空类：

class Empty

可以在类中定义成员函数：

class Runoob() {

fun foo() { print("Foo") } // 成员函数

}

类的属性

属性定义

类的属性可以用关键字 var 声明为可变的，否则使用只读关键字 val 声明为不可变。

class Runoob {

var name: String = ……

var url: String = ……

var city: String = ……

}

我们可以像使用普通函数那样使用构造函数创建类实例：

val site = Runoob() // Kotlin 中没有 new 关键字

要使用一个属性，只要用名称引用它即可

// 使用 . 号来引用

Koltin 中的类可以有一个 主构造器，以及一个或多个次构造器，主构造器是类头部的一部分，位于类名称之后:

class Person constructor(firstName: String) {}

如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。

class Person(firstName: String) {

}

getter 和 setter

属性声明的完整语法：

var [: ] [= ]

[]

[]

getter 和 setter 都是可选

如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，以为它是只读的。

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法

var initialized = 1 // 类型为 Int, 默认实现了 getter 和 setter

val simple: Int? // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化

val inferredType = 1 // 类型为 Int 类型,默认实现 getter

实例

以下实例定义了一个 Person 类，包含两个可变变量 lastName 和 no，lastName 修改了 getter 方法，no 修改了 setter 方法。

class Person {

var lastName: String = "zhang"

get() = rCase() // 将变量赋值后转换为大写

set

var no: Int = 100

get() = field // 后端变量

set(value) {

if (value < 10) { // 如果传入的值小于 10 返回该值

field = value

} else {

field = -1 // 如果传入的值大于等于 10 返回 -1

}

}

var heiht: Float = 145.4f

private set

}

// 测试

fun main(args: Array) {

var person: Person = Person()

me = "wang"

println("lastName:${me}")

= 9

println("no:${}")

= 20

println("no:${}")

}

输出结果为：

lastName:WANG

no:9

no:-1

Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器，如以上实例：

var no: Int = 100

get() = field // 后端变量

set(value) {

if (value < 10) { // 如果传入的值小于 10 返回该值

field = value

} else {

field = -1 // 如果传入的值大于等于 10 返回 -1

}

}

非空属性必须在定义的时候初始化,kotlin提供了一种可以延迟初始化的方案,使用 lateinit 关键字描述属性：

class LazyProperty(val initializer: () -> Int) {

var value: Int? = null

val lazy: Int

get() {

if (value == null) {

value = initializer()

}

return value!!

}

}

主构造器

主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码段使用

init 关键字作为前缀。

class Person constructor(firstName: String) {

init {

("FirstName is $firstName")

}

}

注意：主构造器的参数可以在初始化代码段中使用，也可以在类主体n定义的属性初始化代码中使用。 一种简洁语法，可以通过主构造器来定义属性并初始化属性值（可以是var或val）：

class People(val firstName: String, val lastName: String) {

//...

}

如果构造器有注解，或者有可见度修饰符，这时constructor关键字是必须的，注解和修饰符要放在它之前。

实例

创建一个 Runoob类，并通过构造函数传入网站名：

class Runoob constructor(name: String) { // 类名为 Runoob

// 大括号内是类体构成

var url: String = "//"

var country: String = "CN"

var siteName = name

init {

println("初始化网站名: ${name}")

}

fun printTest() {

println("我是类的函数")

}

}

fun main(args: Array) {

val runoob = Runoob("软件开发网")

println(me)

println()

println(y)

est()

}

输出结果为：

初始化网站名: 软件开发网

软件开发网

//

CN

我是类的函数

次构造函数

类也可以有二级构造函数，需要加前缀 constructor:

class Person {

constructor(parent: Person) {

(this)

}

}

如果类有主构造函数，每个次构造函数都要，或直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字：

class Person(val name: String) {

constructor (name: String, age:Int) : this(name) {

// 初始化...

}

}

如果一个非抽象类没有声明构造函数(主构造函数或次构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有公共的构造函数，你就得声明一个空的主构造函数：

class DontCreateMe private constructor () {

}

注意：在 JVM

虚拟机中，如果主构造函数的所有参数都有默认值，编译器会生成一个附加的无参的构造函数，这个构造函数会直接使用默认值。这使得 Kotlin

可以更简单的使用像 Jackson

或者 JPA

这样使用无参构造函数来创建类实例的库。

class Customer(val customerName: String = "")

实例

class Runoob constructor(name: String) { // 类名为 Runoob

// 大括号内是类体构成

var url: String = "//"

var country: String = "CN"

var siteName = name

init {

println("初始化网站名: ${name}")

}

// 次构造函数

constructor (name: String, alexa: Int) : this(name) {

println("Alexa 排名 $alexa")

}

fun printTest() {

println("我是类的函数")

}