Kotlin Android开发篇—环境搭建及基础法语

Kotlin被指定为Android开发语法后很多新项目都开始采用kotlin语言进行开发了，公司之前项目的重构及新项目都打算采用kotlin进行开发，所以又不得不重新深入学习下kotlin，下面这些只是本人在学习过程中的一些笔记。

环境搭建

kotlin被指定为Android开发语言后，Android studio开发工具已经将kotlin内置进来了，按照相应的开发插件就可以了，相对于其他的开发环境搭建还是比较简单的，这里的开发工具是Android studio3.4版本，之前的版本稍微有点点不一样。
打开Android studio 点击File--->Settings--->Plugins--->Marketplace，在输入框内输入kotlin，进行搜索，搜索到后找到kotlin插件点击install进行安装；

微信截图_20190427101720.png
安装后重启Android studio开发工具，和之前一样新建工程项目；在Language那里选择kotlin，点击finish，kotlin项目工程就建好了；整个项目的目录结构和java项目是一样的，打开app目录下的build.gradle，里面就自动引入了kotlin开发所需要的依赖和配置；
微信截图_20190427102354.png
如果之前是java工程，后期迭代想使用kotlin开发也是可以的，安装好插件，然后手动在app module中引入依赖和配置，还需要在项目的build.gradle进行配置； 微信截图_20190427102642.png
配置好后，就可以进行kotlin编写了，在编写前先看下kotlin的基本语言等内容，下面一个kotlin官网和官方学习文档；
官方网站
官方学习文档

基本类型

kotlin的基本类型包括：数字、字符、布尔和数组

数字

kotlin提供了如下的内置类型来表示数字：

微信截图_20190427104540.png

注意：在kotlin中字符不是数字
kotlin处理数字和java基本类似，但是kotlin中没有隐士转换，比如Int不能直接隐士转出成Double，而要通过调用toDouble()方法进行显示转换；

微信截图_20190427105158.png

通过上面这些内置方法可以进行对应的转换，kotlin中字面常量是不支持八进制，通过val关键字来定义字面常量，同时可以还可以定义一个可空的引用(Int?)或泛型，不过可空的引用或泛型会把数字装箱；

        val a:Int=100
        println(a===a)//true
        val boxA:Int?=a
        val boxB:Int?=a
        println(boxA===boxB)//false

        println(a==a)//true
        println(boxA==boxB)//true

字符及字符串

字符用Char表示，不能被直接当做数字，其他用法和java中差不多；
字符串用String表示，字符串是不可变的，kotlin中提供了字符串模板，模板表达式以$开头；

        val b:Int=10
        val c:String="b=$b"//表示b=10
        val d:String="b=${b}"//表示b=10

Boolean

布尔用Boolean类型表示，分为true和false
内置的运算符有：

微信截图_20190427110750.png

数组

数组用Array表示，可以使用arrayOf()来创建一个数组，并给它传递元素，也可以通过arrayOfNulls<Int>(5)来创建一个大小指定，但是元素都为空的数组；

//创建一个数组 并对数组进行遍历 计算
val array=Array<Int>(5,{i: Int -> (i*i) })

关于数组的遍历会在后面for或者while循环遍历讲到；

控制流

If表达式

在kotlin中，if就是一个表达式，即它会返回一个值，因此普通的if就能胜任三元表达式的角色，以获取两个数中的最大值为例看下if表达式的写法：

        //写法一
        if(a>b){
            return a
        }else{
            return b
        }

        //写法二
        var max=a
        if(a<b) max=b
        return max

        //写法三
        val max=if(a>b) a else b
        return max

        //写法四
        val max=if(a>b){
            a
        }else{
            b
        }
        return max

具体的写法有很多，就不一一写了，具体的可以根据项目的需要进行写，不过如果使用if作为表达式而不是语句，该表达式需要有else分支。

when表达式

kotlin中用when替换了switch，用法也比较简单：

when(x){
            1-> println("is 1")
            2-> println("is 2")
            else -> println("is other")
        }

如果在开发中每个分支的代码逻辑比较多，也可以使用{}方式将每个分支进行包裹：

when(x){
            1-> {println("is 1")}
            2-> {println("is 2")}
            else -> {println("is other")}
        }

如果碰到多分支需要同样的处理时，左边的条件那里可以写多个用,隔开：

when(x){
            1,2-> {println("is 1 or 2")}
            3-> {println("is 3")}
            else -> {println("is other")}
        }

左边的表达式不只可以是常量，还可以是方法、区间等各种方式:

when(x){
            y.toInt()-> {println("is 1 or 2")}//y字符串通过toInt 转成Int
            in 3..5-> {println("is 3")}//in 3..5表示3到5的区间条件都成立
            else -> {println("is other")}
        }

如果项目需要的话，还可以直接定义一个常量或者变量直接接受when表达式的值，从而可以直接使用when的值进行逻辑编写：

val value=when(x){
            y.toInt()-> {println("is 1 or 2")}//y字符串通过toInt 转成Int
            in 3..5-> {println("is 3")}//in 3..5表示3到5的区间条件都成立
            else -> {println("is other")}
        }

For循环

        val list= listOf<Int>(1,3,422,44)
        //第一种方式
        for(item in list){
            println("item=${item}")
        }
        //第二种方式
        for(i in list.indices){
            //i是对应的list的角标 通过list[i]的方式获取角标对应的value
           println("i=${i}item=${list[i]}")
        }
        //第三种方式
        for((i,value) in list.withIndex()){
            //i是对应list的角标 value是对应角标的value
            println("i=${i}value=${value}")
        }

以上就是for循环大致的写法，当然还有其他的写法，具体可以根据需要进行编写，同时kotlin中还提供了range区间；

        for(i in 0..10){
            //表示0-10区间的遍历 闭区间
            println("i=${i}")//打印的是0到10
        }
        for(i in 0 until 10){
            //表示0-10区间的遍历 左闭右开
            println("i=${i}")//打印的是0到9
        }
        for(i in 0..10 step 2){
            //表示0-10区间的遍历 闭区间 step步数为2 类似于javafor循环中的i++
            println("i=${i}")//打印的是0 2 4 6 8 10
        }
        for(i in 10 downTo 0){
            //表示10 0区间的遍历 闭区间
            println("i=${i}")//打印的是10 9 8 7 6 5 4 3 2 1 0
        }
        for(i in 10 downTo 0 step 2){
            //表示10 0区间的遍历 闭区间
            println("i=${i}")//打印的是10 8 6  4 2  0
        }

可以使用in和!in判断在或者不在该区间内；

while和do..while循环

while和do..while的使用和java中基本一致

        var x=100
        while (x > 0) {
            x--
            println("x=x${x}")

        }
        do {
            x--
            println("x=x${x}")
        }while (x>0)

break、continue和return

和java一样提供了下面三种结构化跳转表达式：

break：种植最直接包围它的循环
continue：继续下一次最直接包围它的循环
return：默认从最直接包围它的函数或者匿名函数返回

使用上面和java中一样，不过kotlin还提供了标签这个东西，对应单层循环或者单层函数来说没有什么区别，对于循环嵌套或者函数嵌套调用就会不一样了：

        val list= listOf<String>("aa","bb","cc","dd")
        looper@ for(i in list.indices){
            for(j in list.indices){
                if(list[j].equals("cc")){
                    //如果等于cc 就直接跳出双层for循环 终止所有循环
                    break@looper
                }
            }
        }
        
        loop@ for(i in list.indices){
            for(j in list.indices){
                if(list[j].equals("cc")){
                    //如果等于cc 就直接跳过双层for循环 从最外层继续循环
                    continue@loop
                }
            }
        }

大致具体的意思在注释中写了，相比之前没有lable标签，只是跳出或者跳过对应的for循环，在有些场景下回方便不少并且可以提高循环的效率，如果在方法中添加lable标签，return的时候也会不一样哦：

fun returnFun(){
        val list= listOf<String>("aa","bb","cc","dd")
        list.forEach lit@{  
            if(it.equals("cc")){
                //这里返回的只是返回list.forEach 的匿名函数 并不是返回returnFun函数 
                //list.forEach匿名函数后面的逻辑可以照样执行
                return@lit
            }
        }
    }