Kotlin

val a: Int = 1 // 定義a為`Int`類型的唯讀變量，其值為1val b = 2 // 自動檢測b為`Int`類型

var x = 5 // App 定義一個`Int`，值為5x = 1 // 修改值為1

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

// Hello, world! 範例fun main() {    val scope = "World"    println("Hello, $scope!")}fun main(args: Array<String>) {    for (arg in args) {        println(arg)    }}

函数扩展

Kotlin与C#、JavaScript类似，能够扩展类别的新功能，而无需继承该类别，或使用像装饰器（decorator）这样的任何类型的设计模式（design pattern）。扩展函数可以称为Kotlin的核心，在标准库里到处充斥着扩展函数。

扩展函数是静态分发的，也就是说，它们不是以接收者类型为准的虚拟函数。这意味着调用的扩展函数是由函数调用所在的表达式的类型来决定的，而不是由表达式运行时求值结果决定的。

在下述例子中，String类别被扩展出一个成员lastChar。

package MyStringExtensionsfun String.lastChar(): Char = get(length - 1)>>> println("Kotlin".lastChar())

利用函数扩展，Kotlin也支持运算符重载：

// overloading '+' operator using an extension methodoperator fun Point.plus(other: Point): Point {    return Point(x + other.x, y + other.y)}>>> val p1 = Point(10, 20)>>> val p2 = Point(30, 40)>>> println(p1 + p2)Point(x=40, y=60)

getter和setter

Kotlin像C#一样支持属性（property）。

类似Python, 解包（unpack）指的是对实际参数的解包，只需在前面加一个星号* 即可，如test（*a）:

fun main(args: Array<String>) {     val list = listOf("args: ", *args)    println(list)}

函数嵌套

Kotlin支持函数嵌套（nested functions），允许函数内再定义函数，类似JavaScript、C#与Python语言。

class User(    val id:      Int,     val name:    String,     val address: String) {     fun saveUser(user: User) {       fun validate(user: User, value: String, fieldName: String) {           if (value.isEmpty()) {               throw IllegalArgumentException(                  "Can't save user ${user.id}: empty $fieldName")           }       }       validate(user, user.name, "Name")        validate(user, user.address, "Address")       // Save user to the database    }}

解构声明

Kotlin支持解构声明，这与Python的迭代解包相似。

例如, collection object 包含析构式可分离其元素:

for ((index, element) in collection.withIndex()) {      println("$index: $element")}

抽象类别

抽象类别（Abstract classes）定义抽象或纯虚拟（Pure Virtual）占位函数，需要被继承。抽象类别默认是open的。

// No need for the open keyword here, its already open by defaultabstract class Animated {    // This virtual function is already open by default as well    abstract fun animate()    open fun stopAnimating() { }    fun animateTwice() { }}

类别属性

Kotlin 提供下列的关键字来限制顶层（top-level）声明，用于控制类别与成员在继承时的可见性（作用域）。它们可用于类别及其成员:

publicinternalprotectedprivate

用于类别的成员声明时，含义如下：

用于顶层声明时，含义如下：

例如:

// Class is visible only to current moduleinternal open class TalkativeButton : Focusable {    // method is only visible to current class     private   fun yell() = println("Hey!")     // method is visible to current class and derived classes    protected fun whisper() = println("Let's talk!")}

主构造函数 vs. 二级构造函数

在Kotlin 中类别可以有一个主构造函数以及多个二级构造函数。如果主构造函数没有注解或可见性说明，则constructor关键字可以省略。如果构造函数中没有其它操作，大括号也可以省略。

// Example of class using primary constructor syntax// (Only one constructor required for this class)class User(    val nickname: String,     val isSubscribed: Boolean = true) {    ...}

Kotlin 的二级构造函数更类似于 C++, C#, 和 Java。

// Example of class using secondary constructor syntax// (more than one constructor required for this class)class MyButton : View {    // Constructor #1     constructor(ctx: Context) : super(ctx) {         // ...     }     // Constructor #2    constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) {         // ...     }}

Anko library

Anko 是一组为Kotlin 打造的函数库，其功能是用来开发Android UI 应用程序，现已弃用。

fun Activity.showAreYouSureAlert(process: () -> Unit) {    alert(      title   = "Are you sure?",      message = "Are you really sure?")     {      positiveButton("Yes") { process() }      negativeButton("No") { cancel() }    }}

Kotlin 交互模式

Kotlin除了编译成Java字节码运行，也可以作为脚本语言解释运行，此特性使得Kotlin可以以交互模式运行。交互模式是脚本语言具有的特性，解释器可以立即运行用户输入的代码，并反馈运行结果。典型的语言有Python、JavaScript（在V8引擎支持下）、Ruby。

$ kotlinc-jvmtype :help for help; :quit for quit>>> 2+24>>> println("Welcome to the Kotlin Shell")Welcome to the Kotlin Shell>>>

Kotlin 也是脚本语言

Kotlin 亦可视为脚本语言（scripting language）。其脚本存成 Kotlin source file (.kts)，即成为可执行档。

// list_folders.ktsimport java.io.Fileval folders = File(args).listFiles { file -> file.isDirectory() }folders?.forEach { folder -> println(folder) }

为了运行Kotlin 脚本，我们在运行编译器时再加上-script选项。

$ kotlinc -script list_folders.kts "path_to_folder_to_inspect"

Kotlin 的 hello world 例子

fun main(args: Array<String>) {        greet {        to.place    }.print()}//inline higher-order functionsinline fun greet(s: () -> String) : String = greeting andAnother s()  //infix functions, extensions, type inference, nullable types, lambda expressions, labeled this, elvis operatorinfix fun String.andAnother(other : Any?) = buildString() { append(this@andAnother); append(" "); append(other ?: "") } //immutable types, delegated properties, lazy initialization, string templatesval greeting by lazy { val doubleEl: String = "ll"; "he${doubleEl}o" }//sealed classes, companion objectssealed class to { companion object { val place = "world"} }//extensions, Unitfun String.print() = println(this)

空变量及其运算

Kotlin对可以为空（nullable）的变量和不可以为空（non-nullable）的变量作了区分。所有的可空对象（nullable objects）必须在定义时加上 "?" 后置于类型之后。开发人员遇到nullable objects时要先确认: null-check 须被运行过，才能赋值。可空性是Kotlin类型系统中帮助开发者避免以往Java的NullPointerException错误的特性。

Kotlin 提供空安全（null-safe）运算符给开发人员:

fun sayHello(maybe: String?, neverNull: Int) {   // use of elvis operator   val name: String = maybe ?: "stranger"   println("Hello $name")}

使用安全导引（safe navigation）运算符:

// returns null if...// - foo() returns null,// - or if foo() is non-null, but bar() returns null,// - or if foo() and bar() are non-null, but baz() returns null.// vice versa, return value is non-null if and only if foo(), bar() and baz() are non-nullfoo()?.bar()?.baz()

高阶函数与lambda

Kotlin 亦支持高阶函数和lambdas功能。lambda是一种匿名函数，允许开发者直接将表达式定义为函数，这类似于Python。

// the following function takes a lambda, f, and executes f passing it the string, "lambda"// note that (s: String) -> Unit indicates a lambda with a String parameter and Unit return typefun executeLambda(f: (s: String) -> Unit) {    f("lambda")}

Lambdas 可用大括弧 { } 来定义。如果lambda 夹带参数，他们可定义在大括弧内，并以->运算符区隔。

// the following statement defines a lambda that takes a single parameter and passes it to the println functionval l = { c : Any? -> println(c) }// lambdas with no parameters may simply be defined using { }val l2 = { print("no parameters") }

参考资料

外部链接

• 官方网站
• 官方示例 （页面存档备份，存于互联网档案馆）
• 官方网站 - 中文翻译 （页面存档备份，存于互联网档案馆）
• Kotlin教学 （页面存档备份，存于互联网档案馆）