Android 谷歌官方Kotlin语言入门教程（一）基础语法

深藏阁楼爱情的钟 2021-09-12 07:12 453阅读 0赞

# Kotlin简介 #

>  
> 
> Kotlin是一门与Swift类似的静态类型JVM语言，由JetBrains设计开发并开源。与Java相比，Kotlin的语法更简洁、更具表达性，而且提供了更多的特性，比如，高阶函数、操作符重载、字符串模板。它与Java高度可互操作，可以同时用在一个项目中

# #

## Kotlin官方学习文档: ##

[1、教程 - Kotlin 语言中文站 （优化版）][1_ - Kotlin _]

[2、官方 - Kotlin 中文文档 （原版）][2_ - Kotlin _]

## Kotlin 基础语法 ##

### 1、函数的使用 ###

定义函数使用fun关键字，如下代码所示：

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

函数add有两个Int型的参数，冒号后跟的是函数的返回值，一条代码语句的末尾不用加分号，当然加上分号也没有问题。

上面的add函数还可以简写成如下形式：

fun add(a: Int, b: Int) = a + b;

没有显式指定函数的返回值，会自动推断函数的返回值。

如果一个函数没有返回值，可以写成如下两种形式：

//没有返回值的函数，显式指定Unit为返回值  
    fun showAddResult(a: Int, b: Int): Unit {  
        println(a + b)  
    }  
      
    //没有返回值的函数，省略Unit的写法  
    fun showAddResult2(a: Int, b: Int) {  
        println(a + b)  
    }

## 2、常量和变量 ##

使用val关键字声明一个常量（只读，不可修改），使用var关键字声明一个变量，下面是具体用法：

fun test() {  
        //使用val关键字声明一个常量（只读），声明常量时必须初始化  
        val a: Int = 1 //显式指定常量的类型  
        val b = 2  //自动推断类型  
        val c: Int //声明一个不初始化的常量，必须显式指定类型  
    //    b = 3  //常量值不可修改，这句代码会报错  
      
        //a = 3  //不可以修改常量的值，此句代码会报错  
      
        //使用var关键字声明一个变量，变量的值可以修改  
        var year: Int = 2016 //显式指定变量的类型  
        var month = 5 //自动推断变量类型  
        var day: Int //声明一个不初始化的变量，必须显式指定类型  
        month = 6 //变量值可以被修改  
    }

### 3、注释 ###

Kotlin中的注释和Java中类似，如下所示：与Java不同的是，Kotlin中的注释可以嵌套。

fun comments() {  
    //    注释一行代码  
    //    var s = "hello world"  
        /*注释一段代码  
        var a = 8  
        a++  
        a--*/  
    }

# #

### 4、字符串模板 ###

//字符串模板的用法  
    fun stringTempl(args: Array<String>) {  
        if(args.size > 0)  
            println("args[0] = ${args[0]}")  
    }  
      
    //main方法是整个程序的入口  
    fun main(args: Array<String>){  
        var arr = arrayOf("hello", "world")  
        stringTempl(arr)  
    }

上面的代码执行后，在控制台打印如下内容：

![Center][]

5、条件表达式

常规的条件表达式可以是这么写的：

//常规写法的条件表达式，这里的函数返回值不能省略  
    fun max(a: Int, b: Int): Int {  
        if(a > b)  
            return a  
        else  
            return b  
    }

Kotlin可以简写条件表达式，如下所示：

//简写的条件表达式  
    fun max2(a: Int, b: Int) = if(a > b) a else b

### 6、可空类型 ###

fun nullableTest() {  
        //在变量类型后面加上问号，代表该变量是可空变量  
        var name: String? = "zhangsan"  
        name = null //可以将null赋值给name变量  
        var person: String = "tom"  
    //    person = null  //这句代码会报错，不可以将null赋值给一个不可空变量  
    }

函数返回值为可空的例子如下代码：

/*  
    函数返回值为Int?，表示返回值可为空  
    当参数为空或者为""时，则返回null，否则使用Java中的字符串转整型的方法  
    这里也体现了kotlin代码和Java代码无缝集成  
     */  
    fun parseInt(s: String): Int? {  
        if(s == null || s == "")  
            return null;  
        return Integer.parseInt(s);  
    }

##  ##

### 7、类型检查和自动类型转换 ###

Kotlin中使用is运算符来检查数据类型和做类型转换，如下代码所示：

/*  
    当函数参数为字符串类型时，就返回字符串的长度，否则返回空  
     */  
    fun getStringLength(n: Any): Int? {  
        if(n is String)  
            return n.length //这里会自动将n转化为字符串类型  
        return null  
    }

上面的代码还可以写成：

/*  
    当函数参数为字符串类型时，就返回字符串的长度，否则返回空  
     */  
    fun getStringLength(n: Any): Int? {  
        if(n !is String)  
            return null  
        return n.length //这里会自动将n转化为字符串类型  
    }

##  ##

### 8、for循环和while循环 ###

//for循环的测试代码  
    fun testFor() {  
        var arr = arrayOf(1, 3, 4, 5, 6)  
        for(i in arr.indices) { //通过索引循环  
            println(arr[i])  
        }  
        for(num in arr) { //直接使用数组中的对象循环  
            println(num)  
        }  
    }  
      
    //while循环的测试代码  
    fun testWhile() {  
        var i = 0;  
        while(i < 10) {  
            print(" " + i)  
            i++  
        }  
    }

##  ##

### 9、when表达式 ###

when表达式就类似于Java中的switch表达式，如下代码所示：

fun main(args: Array<String>) {  
        testCase("hello world")  
    }  
      
    fun testCase(obj: Any) {  
        when(obj) {  
            is String -> {  
                print("this is string")  
            }  
            is Int -> {  
                print("this is integer")  
            }  
            else -> {  
                print("unkown value")  
            }  
        }

10、ranges的使用

（1）使用in操作符检查一个数是否在某个范围内

/*  
    判断分数是否大于等于90，小于等于100  
     */  
    fun isGood(score: Int) {  
        if(score in 90..100) //ranges是闭区间  
            println("very good")  
        else  
            println("not so good")  
    }

（2）检查索引是否越界

/*  
    检查index是否在数组arr的索引范围内  
     */  
    fun checkIndex(index: Int, arr: Array<Int>) {  
        if(index in 0..arr.lastIndex) //arr.lastIndex返回的是数组的最后一位的下标  
            println("index in bounds")  
        else  
            println("index out of bounds")  
    }

（3）遍历一个范围

for(i in 1..5) {  
        println(i)  
    }

也可以通过in运算符遍历一个集合，如下代码：

//in运算符遍历一个字符串数组  
    fun testStr(arr: Array<String>) {  
        for(str in arr)  
            println(str)  
    }

### 10、Kotlin 双冒号 :: 使用 ###

双冒号表示引用。

fun main(args: Array<String>) {
        println(lock("param1", "param2", ::getResult))
    }
    
    /**
     * @param str1 参数1
     * @param str2 参数2
     */
    fun getResult(str1: String, str2: String): String = "result is {$str1 , $str2}"

调用其他 Class 类中的某一个方法是：

fun main(args: Array<String>) {
        var d = Test()
        println(lock("param1", "param2", d::getResult))
    }

调用当前 Class 的内部方法时调动方式为：

class Test1 {
        fun isOdd(x: Int) = x % 2 != 0
    
        fun test() {
            var list = listOf(1, 2, 3, 4, 5)
            println(list.filter(this::isOdd))
        }
    }

\*为了防止作用域混淆 ， :: 调用的函数如果是类的成员函数或者是扩展函数，必须使用限定符,比如this。

[1_ - Kotlin _]: https://www.kotlincn.net/docs/reference/
[2_ - Kotlin _]: http://www.kotlindoc.cn/
[Center]: /images/20210802/b74aec91acb845358c2f794e35e3615b.png