Kotlin基础语法

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

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

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

---

• Kotlin实现 Hello World

fun main(args: Array<String>) {   // main函数,主程序的入口 
   println("Hello World!")         
}

Kotlin基础语法:

---

• 定义常量与变量

可变变量定义：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 的基本数值类型如下:
    类型        存储范围                    位宽度      
    Byte        整数-128~127                8
    Short       整数-32768~32767            16
    Int         整数-214783648~2147483647   32
    Long                                    64
    Double      小数,小数点精确到6位        64
    Float       小数,小数点精确到15-16位    32
    String      字符串,用双引号""引起来的字符串都可以存
    
> 注释
Kotlin 支持单行和多行注释，实例如下：
    // 我是单行注释
    /* 我是多行
       的注释 */
与 Java 不同, Kotlin 中的块注释允许嵌套

> 位操作符
    对于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'
    
> 布尔
    || – 短路逻辑或
    && – 短路逻辑与
    ! - 逻辑非

> 数组
数组用类 Array 实现
数组的创建两种方式：一种是使用函数arrayOf(); 另外一种是使用工厂函数.如下:
    fun main(args: Array<String>) {
        //[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
    }
除了类Array，还有ByteArray, ShortArray, IntArray，用来表示各个类型的数组，省去了装箱操作，因此效率更高，其用法同Array一样：
    val x: IntArray = intArrayOf(1, 2, 3)
    x[0] = x[1] + x[2] 

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

• 函数定义

函数定义使用关键字 fun

fun 函数名(参数名 : 参数类型) : 返回值类型{
    函数体
}
fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
    return a + b
}

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

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

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

2.无返回值的函数(类似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<String>) {
    vars(1,2,3,4,5)  // 输出12345
}

• lambda(匿名函数)

lambda表达式使用实例：

// 测试
fun main(args: Array<String>) {
    val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
    println(sumLambda(1,2))  // 输出 3
}

• 字符串

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

    for (c in str) {
        println(c)
    }

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

    fun main(args: Array<String>) {
        val text = """
        多行字符串
        多行字符串
        """
        println(text)   // 输出有一些前置空格
    }

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

    fun main(args: Array<String>) {
        val text = """
        |Ansen1
        |Ansen2
        |Ansen3
        """.trimMargin()
        println(text)    // 前置空格删除了
    }

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

• 字符串模板

$ 表示一个变量名或者变量值; $varName 表示变量值; ${varName.fun()} 表示变量的方法返回值:

fun main(args: Array<String>) {
        val i = 10
        val s = "i = $i" //模板表达式以美元符（$）开头
        println(s)      // 输入为 "i = 10"
    }

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

    fun main(args: Array<String>) {
        val s = "runoob"
        val str = "$s.length is ${s.length}" // 求值结果为 "runoob.length is 6"
        println(str)
    }

在原生字符串中表示字面值 $ 字符（它不支持反斜杠转义）,可以使用如下语法：

    fun main(args: Array<String>) {
        val price = """
        ${'$'}9.99
        """
        println(price)  // 求值结果为 $9.99
    }

• null空值处理

Kotlin对声明的参数有做不为空的检查机制; 如果需要进行空判断处理,有两种处理方式: 字段后加!!像Java一样抛出空异常,或在字段后加?参数可以为空

//类型后面加?表示可为空
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? {
      // ...
    }

以下实例演示如何使用一个返回