Kotlin学习系列——Kotlin 基础语法

r囧r小猫 2023-06-25 10:16 9阅读 0赞

## 一.介绍 ##

JetBrains公司根据多年Java平台开发经验,认为Java有一定局限性和问题,
    由于要向后兼容,这些问题很难得到解决,因此他们开发了Kotlin语言!
    
    Kotlin是基于JVM的新编程语言,和Groovy、Scala、Clojure等语言类似,被称为JVM语言!
    因为它们都编译成.clas字节码文件,可在java虚拟机JVM上运行!
    
    Kotlin特点:       
        Kotlin兼容Java,与Java 100%互相调用,并具备诸多Java尚不支持的新特性!
        比Java更安全,更简洁,更现代化,更强大！
        既面向对象又有函数式结构,支持高阶函数、操作符重载、字符串模板和lambda等！
        Kotlin比最成熟竞争者Scala简单易学,可轻松引入到现有java项目中!
        此外,还可编译成JavaScript代码, Kotlin也可与JavaScript互操作！
    
    Kotlin历史:   
        Kotlin由JetBrains公司在2010年开发,2011年开源:http://github.com/JetBrains/kotlin
        2016年发布1.0版,2017年4月发布1.1.2版！
        Kotlin语言的开发团队,目前大约40人,Andrey Breslav还是Kotlin语言的首席设计师!
        JetBrains公司对Kotlin愿景:
            用同一种语言,接多平台的不同应用的端对端开发,
            包括全栈Web应用、Android和iOS客户端、嵌入式/物联网等!
    
        谷歌Android团队和JetBrains公司关系密切,Android Studio就是基于IntelliJ IDEA社区版开发!
        谷歌和JetBrains公司为Kotlin成立一个非盈利基金会,Kotlin语言的开发，还是JB为主导!        
        谷歌在I/O 2017大会宣布:将Kotlin语言作为Android开发的一级编程语言!
    
    Android Studio 3.0预览版已支持Kotlin！
    下载AS3.0预览版后,打开现有Java文件,在Code菜单中选择Convert Java File to Kotlin File, 
    AS会添加Kotlin依赖,然后把Java代码转成Kotlin代码!
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28

## 二.Kotlin基础语法 ##

官方文档: [http://kotlinlang.org/docs/reference/basic-syntax.html][http_kotlinlang.org_docs_reference_basic-syntax.html]

### 1.Kotlin注释 ###

和Java一样，Kotlin支持行注释和块注释,
    与Java不同的是，Kotlin块注释可嵌套
        // 这是行注释
        /* 这是块注释 */
    
     
      
     
      
       1
       2
       3
       4

### 2.定义包名 ###

包名位于源码文件顶部,与java相同!
    但源码文件可在任意目录,不需要匹配包名
    package com.demo
    import java.util.*
    
     
      
     
      
       1
       2
       3
       4

### 3.定义函数 ###

#### ①.函数有两个Int参数,返回Int类型 ####

// 变量: 变量类型
    fun sum(a: Int, b: Int): Int {
        return a + b
    }
    
    // main函数,和java的main方法一样,作为程序入口
    fun main(args: Array<String>) { 
        // 调用sum函数
        println(sum(3, 5)) 
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

#### ②.函数表达式推断返回类型 ####

fun sum(a: Int, b: Int) = a + b 
    
    fun main(args: Array<String>) {
        println(sum(3, 5))
    }
    
     
      
     
      
       1
       2
       3
       4
       5

#### ③.函数返回类型Unit ####

// Unit类似java的void, $表示取变量值
    fun printSum(a: Int, b: Int): Unit {
        println("sum of $a and $b is ${a + b}")
    }
    
    fun main(args: Array<String>) {
        printSum(3, 5)
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

#### ④.函数可省略返回类型Unit ####

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

### 4.定义局部变量 ###

#### ①.只读变量val(只能赋值一次,之后不可变) ####

fun main(args: Array<String>) {
        val a: Int = 1 //立即初始化
        val b = 2      //Int类型可被推断出来
        val c: Int     //没有初始化,必须写类型
        c = 3          //延迟初始化
        println("a = $a, b = $b, c = $c")
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7

#### ②.可变变量var ####

fun main(args: Array<String>) {
        var x = 5 //Int类型可被推断出来
        x += 1    //x变量可以改变
        println("x = $x")
    }
    
     
      
     
      
       1
       2
       3
       4
       5

### 5.字符串模板 ###

fun main(args: Array<String>) {
        var a = 1       
        val s1 = "a is $a" // 简单变量模板
        val s2 = "replace: ${s1.replace("is", "was")}" // 表达式模板
        println(s1)
        println(s2)
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7

### 6.条件表达式 ###

#### ①.条件if ####

fun maxOf(a: Int, b: Int): Int {
        if (a > b) {
            return a
        } else {
            return b
        }
    }
    
    fun main(args: Array<String>) {
        println(maxOf(3, 5))
    }
    
    简写if表达式
    fun maxOf(a: Int, b: Int) = if (a > b) a else b
    
    fun main(args: Array<String>) {
        println(maxOf(3, 5))
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18

#### ②.条件when ####

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }
    
    fun main(args: Array<String>) {
        println(describe(1))
        println(describe("Hello"))
        println(describe(1000L))
        println(describe(2))
        println(describe("other"))
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16

### 7.可能空值时,检查null ###

当可能为null值时,引用变量必须添加?标记  
    fun parseInt(str: String): Int? {
        return str.toIntOrNull()
    }
    
     
      
     
      
       1
       2
       3
       4

### 8.类型检查和自动转换 ###

is运算符可检查一个变量是否为某类型的实例
    如果一个不可变的局部变量或属性是指定类型，则不需要显式转换：
    fun getStringLength(obj: Any): Int? {
        if (obj is String) {
            // Any类型自动转换为String类型
            return obj.length
        }       
        return null
    }
    
    上面代码，也可写成下面
    fun getStringLength(obj: Any): Int? {
        if (obj !is String) return null
        return obj.length
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15

### 9.循环 ###

#### ①.循环for ####

fun main(args: Array<String>) {
        val items = listOf("apple", "banana", "kiwi")
        for (item in items) {
            // 直接变量每一项
            println(item)
        }
    }
    
    上面代码，也可写成下面
    fun main(args: Array<String>) {
        val items = listOf("apple", "banana", "kiwi")
        for (index in items.indices) {
            // 遍历下标，输出相应项
            println("item at $index is ${items[index]}")
        }
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16

#### ②.循环while ####

fun main(args: Array<String>) {
        val items = listOf("apple", "banana", "kiwi")
        var index = 0
        while (index < items.size) {
            println("item at $index is ${items[index]}")
            index++
        }
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8

### 10.范围in运算符 ###

检查数字是否在指定范围内
    fun main(args: Array<String>) {
        val x = 3
        val y = 5
        if (x in 1..y+1) {
            println("$x在指定范围内")
        }
        if (0 !in 1..y+1) {
            println("0超出范围")
        }
    }
    
    用于迭代/循环
    fun main(args: Array<String>) {
        for (x in 1..3) {
            print(x)
        }
        println("***")
        for (x in 1..5 step 2) {
            println(x)
        }
        println("***")
        for (x in 5 downTo 1 step 2) {
            println(x)
        }
    }
    
    执行结果如下：
        1
        2
        3       
        ***
        1
        3
        5       
        ***     
        5
        3
        1
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39

### 11.集合 ###

迭代集合(循环遍历)
    fun main(args: Array<String>) {
        val items = listOf("apple", "banana", "kiwi")
        for (item in items) {
            println(item)
        }
    }
    
    检查集合是否包含一个对象
    fun main(args: Array<String>) {
        val items = setOf("apple", "banana", "kiwi")
        when {
            "orange" in items -> println("juicy")
            "apple" in items -> println("apple is fine too")
        }
    }
    
    集合函数lambda表达式(过滤,排序,循环遍历)
    fun main(args: Array<String>) {
        val fruits = listOf("banana", "avocado", "apple", "kiwi")
        fruits
        .filter { it.startsWith("a") }
        .sortedBy { it }
        .map { it.toUpperCase() }
        .forEach { println(it) }
    }
    
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26

[http_kotlinlang.org_docs_reference_basic-syntax.html]: http://kotlinlang.org/docs/reference/basic-syntax.html