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

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

环境搭建

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

Kotlin Android开发篇—环境搭建及基础法语_第1张图片
微信截图_20190427101720.png

安装后重启Android studio开发工具,和之前一样新建工程项目;在Language那里选择kotlin,点击finish,kotlin项目工程就建好了;整个项目的目录结构和java项目是一样的,打开app目录下的build.gradle,里面就自动引入了kotlin开发所需要的依赖和配置;
Kotlin Android开发篇—环境搭建及基础法语_第2张图片
微信截图_20190427102354.png

如果之前是java工程,后期迭代想使用kotlin开发也是可以的,安装好插件,然后手动在app module中引入依赖和配置,还需要在项目的build.gradle进行配置;
Kotlin Android开发篇—环境搭建及基础法语_第3张图片
微信截图_20190427102642.png

配置好后,就可以进行kotlin编写了,在编写前先看下kotlin的基本语言等内容,下面一个kotlin官网和官方学习文档;
官方网站
官方学习文档

基本类型

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

数字

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


Kotlin Android开发篇—环境搭建及基础法语_第4张图片
微信截图_20190427104540.png

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


Kotlin Android开发篇—环境搭建及基础法语_第5张图片
微信截图_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(5)来创建一个大小指定,但是元素都为空的数组;

//创建一个数组 并对数组进行遍历 计算
val array=Array(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
        //写法三
        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(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("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("aa","bb","cc","dd")
        list.forEach lit@{  
            if(it.equals("cc")){
                //这里返回的只是返回list.forEach 的匿名函数 并不是返回returnFun函数 
                //list.forEach匿名函数后面的逻辑可以照样执行
                return@lit
            }
        }
    }

你可能感兴趣的:(Kotlin Android开发篇—环境搭建及基础法语)