Kotlin学习笔记（一）【基础语法】

Hello World！

fun main(args: Array<String>) {
    println("Hello World")
}

Kotlin的基础语法

Kotlin文件以.kt为结尾

包声明

代码文件的开头一般为包开头

package com.runoob.main

import java.util.*

fun test() {}
class Runoob {}

kotlin源文件不需要相匹配的目录和包，源文件可以放在任何文件目录。
以上例中 test() 的全名是 com.runoob.main.test、Runoob 的全名是 com.runoob.main.Runoob。
如果没有指定包，默认为 default 包。

默认导入

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

• kotlin.*
• kotlin.annotation.*
• kotlin.collections.*
• kotlin.comparisons.*
• kotlin.io.*
• kotlin.ranges.*
• kotlin.sequences.*
• kotlin.text.*

函数定义

函数定义使用关键字 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 sum(a: Int, b: Int):Unit {//Unit代表无返回值，也可以省略
    println("$a + $b = ${a+b}")
}

//对于public方法也适用，无返回值，Unit可以省略
fun sum(a: Int, b: Int) {
    println("$a + $b = ${a+b}")
}

可变长参数函数

可变长参数用vararg表示

fun main(args: Array<String>) { 
   printSth("a","b","c","d")//打印a,b,c,d
}

fun printSth(vararg vars: String): Unit {
    for (v in vars) {
        println(v)
    }
}

lambda(匿名函数)

lambda表达式使用

fun main(args: Array<String>) { 
    val sumLambda:(Int,Int) -> Int = {x,y -> x+y}
    val result = sumLambda(1,1)
    println(result) // print 2
}

定义常量与变量

可变变量定义var

    var <变量名> : <类型> = <初始值>
    var a : Int = 1

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

    val <变量名> : <类型> = <初始值>
    val a : Int = 1

常量与变量都可以没有初始化值,但是在引用前必须初始化
编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

fun main(args: Array<String>) { 
    val a: Int = 1
    val b = 1 //系统自动判断值为Int
    val c : Int //如果在声明时不初始化，则必须要提供类型！
    c = 1 //明确赋值

    var x = 5; //系统判断为Int
    x ++; //变量可修改

    println("a = $a b = $b c = $c x = $x")
}

注释

// 这是一个单行注释

/* 这是一个多行的
   块注释。 */

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

字符串模板

fun main(args: Array<String>) { 
    val name: String = "qfxl"
    println("my name is $name")
    changeName(name)
}

fun changeName(name: String):Unit {
    println("my name is $name but was changed to ${name.replace("q","a")}")
}

Log:
my name is qfxl
my name is qfxl but was changed to afxl

NULL检查机制

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

fun main(args: Array<String>) { 
    //表示name可为空
    var age : String ? = "100"
    //如果age为空抛出空指针异常
    var ageInt = age!!.toInt()
    //如果age为空直接返回null
    var ageNull = age?.toInt()
    //如果age为空，则返回-1
    var ageIntIfNull = age?.toInt() ?: -1
}

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

fun main(args: Array<String>) { 
    val result = parseInt("a")
    println(result)
}

fun parseInt(str: String): Int ? {//如果要返回null则要标记可为null
    if (str in "0".."9") {
        return str.toInt()
    }
    return null
}

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

fun main(args: Array<String>) { 
    if (args.size < 2) {
        println("需要两个参数")
        return
    }

    val a = parseInt(args[0])
    val b = parseInt(args[1])
    // 直接使用 `a + b` 会导致错误, 因为它们可能为 null.
    if (a != null && b != null) {
        // 在进行过 null 值检查之后, a 和 b 的类型会被自动转换为非 null 变量
        println("$a + $b = ${a + b}")
    }
}

fun parseInt(str: String): Int ? {
    if (str in "0".."9") {
        return str.toInt()
    }
    return null
}

类型检测和类型自动转换

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

fun main(args: Array<String>) { 
    val length = getStringLength("qfxl")
    println("length is $length")// print length is 4
}

fun getStringLength(obj: Any): Int ? {
    if (obj is String) {
        //经过类型转换之后obj自动转换成String
        return obj.length 
    }
    //这里obj依然还是Any类型
    return null
}

或者

fun getStringLength(obj: Any): Int ? {
    if (obj !is String) {      
        return null 
    }
    //这里自动转换成String类型
   return obj.length 
}

设置还可以

fun getStringLength(obj: Any): Int ? {
    //&&后面的obj已经转换成String类型
    if (obj is String && obj.length > 0) {      
        return obj.length 
    }   
   return null
}

区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。
区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:

fun main(args: Array<String>) { 
    for (i in 1..4) println(i) //输出1,2,3,4

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

    for (i in 4 downTo 1) println(i) //输出4,3,2,1

    for (i in 4 downTo 1 step 2) println(i) //输出4,2   

    for (i in 1 until 4) println(i) //输出1,2,3
}

摘自:http://www.runoob.com/kotlin/kotlin-basic-syntax.html