初识Kotlin<上>

前边就不用过多的介绍了，自从Google选择Kotlin，有一波开发者开始学习了。下边记录一下第一次学习Kotlin的一些笔记。

1、变量及常量的定义

说一个var和val的区别
var是定义一个变量,以后这个值是可以变的
val是定义一个常量,在以后的操作过程中,这个值是不能变的.

    val a: Int = 1  // 立即初始化
    val b = 2   // 推导出Int型
    val d = 2.357   // 小数，默认为doulbe类型
    var c: Int? = null    // 当没有初始化值时必须声明类型

2、元组

这个貌似是个新鲜的东西，之前在java语言里边是没有这个东西的。看一下怎么用。

        /**
         * 元组   三元元组
         */
        var (name, move, number) = kotlin.Triple("小米", "左", 3)
        LogUtils.Loge("${name}向${move}边移动了${number}步")

        /**
         * 二元元组
         */
        var (name1, move2) = Pair("小明", "右")
        LogUtils.Loge("${name1}向${move2}边移动了5步")

        /**
         * 二元元组
         */
        var move3 = Pair("小红", "前")
        LogUtils.Loge("${move3.first}向${move3.second}边移动了10步")

然后看一下控制台的输出的效果：

11-16 13:51:31.648 3728-3728/com.example.lql.kotlindemo E/###: 小米向左边移动了3步###
11-16 13:51:31.648 3728-3728/com.example.lql.kotlindemo E/###: 小明向右边移动了5步###
11-16 13:51:31.648 3728-3728/com.example.lql.kotlindemo E/###: 小红向前边移动了10步###

定义一个三元元组使用Triple关键字，定义一个二元元组使用Pair关键字。如果不想给元组定义多个变量，可以使用第三个写法中的方式，然后在使用元组中的参数的时候，使用"变量名.first" .
嗯嗯，这里大家还可以看到一个骚操作，如果要把字符串和变量拼接起来，是用${变量名}来在字符串中拼接。

3、集合

在Kotlin中集合分为三种形式：
Set: 无序不重复、List：有序可重复，索引从0开始、Map(映射)：无序不重复，键值对

kotlin_集合.png

3.1先看Set、看代码：

        //定义一个不可变的Set集合
        var mStringSet1: Set<String> = setOf("E", "F", "B", "C", "A", "D", "F", "B")
        //定义一个可以变的Set集合
        var mStringSet2: Set<String> = mutableSetOf("E", "F", "B", "C", "A", "Z")
        //创建一个空的Set集合
        var mStringSet3: Set<String> = emptySet()

        LogUtils.Loge("数量：" + mStringSet1.count())
        LogUtils.Loge("是否为空：" + mStringSet3.isEmpty())
        for (item in mStringSet1) {
            LogUtils.Loge(item + ">>>mStringSet1")
        }
        //是否包含某个元素
        LogUtils.Loge("判断是否包含某个元素：" + mStringSet1.contains("A"))
        //是否包含某个集合
        LogUtils.Loge("判断是否包含某个集合：" + mStringSet1.containsAll(mStringSet2))
        //转换成list
        val toTypedArray = mStringSet1.toTypedArray()
        for (s in toTypedArray) {
            LogUtils.Loge("集合转换成数组：" + s)
        }

        //集合之间的操作
        val intersect = mStringSet1.intersect(mStringSet2)
        LogUtils.Loge("交集：" + intersect)

        val union = mStringSet1.union(mStringSet2)
        LogUtils.Loge("全集：" + union)

        val subtract = mStringSet1.subtract(mStringSet2)
        LogUtils.Loge("差集：" + subtract)

        val minus = mStringSet1.minus(mStringSet2)
        for (minus1 in minus) {
            LogUtils.Loge("补集：" + minus1)
        }

        //转换成ToMutableSet
        val toMutableList = mStringSet2.toMutableList()
        for (s in toMutableList) {
            LogUtils.Loge("toMutableList：" + s)
        }

        //MutableSet:大小可变的集合

        //增加一个
        toMutableList.add("K")
        for (s in toMutableList) {
            LogUtils.Loge("新增加了一个：" + s)
        }

        //增加一堆
        toMutableList.addAll(mStringSet1)
        for (s in toMutableList) {
            LogUtils.Loge("新增加了一堆：" + s)
        }

        //删除第0个
        toMutableList.removeAt(0)
        for (s in toMutableList) {
            LogUtils.Loge("删除第0个：" + s)
        }
        //删除某一个
        toMutableList.remove("K")
        for (s in toMutableList) {
            LogUtils.Loge("删除某一个：" + s)
        }

set集合是不可重复的且无序的集合，但是在上述代码mStringSet1集合中出现了重复的元素，大家可以看一下效果，虽然在初始化的时候，集合中包含重复元素，但是在使用的时候是不会出现重复元素的。看一下控制台输出：

11-16 14:05:28.898 4579-4579/com.example.lql.kotlindemo E/###: E>>>mStringSet1###
11-16 14:05:28.898 4579-4579/com.example.lql.kotlindemo E/###: F>>>mStringSet1###
11-16 14:05:28.898 4579-4579/com.example.lql.kotlindemo E/###: B>>>mStringSet1###
11-16 14:05:28.898 4579-4579/com.example.lql.kotlindemo E/###: C>>>mStringSet1###
11-16 14:05:28.898 4579-4579/com.example.lql.kotlindemo E/###: A>>>mStringSet1###
11-16 14:05:28.898 4579-4579/com.example.lql.kotlindemo E/###: D>>>mStringSet1###

然后在set集合中咱们可以求两个set集合交集、差集、并集、补集。具体的操作在上述代码中有体现，大家可以去自行试试效果。
还有一点，在初始话set集合的时候，是一个不可变的集合，在后续操作中不能对集合进行增加、删除元素等操作。如果我们想要去操作集合，就要调用集合的.toMutableList()方法，然后再去对集合进行add()、addAll()、remove()等操作。

3.2 再看List集合：

list集合是一个有序，可重复的集合。
所以在list集合比set集合多了拿到第几个元素的方法，调用 stationsList[index])或者stationsList.get(index)就可以拿到集合中的第index个元素。
还有一个集合的切割方法： stationList3.subList(2, 4)或者stationList3.slice(2..3)
解释一下两个方法的：
subList()方法，包含第2个元素和第3个元素但是不包含第4个元素
slice()方法，包含第2和第3个元素
然后其他的对集合操作的方法和Set集合类似，这里就不赘述了。

 //定义一个数组
        var stationsList = arrayOf("石家庄", "北京", "南京", "上海", "苏州", "上海")
        for (s in stationsList) {
            LogUtils.Loge("stationList:" + s)
        }
        //创建一个有默认值的数组
        var stationList2 = Array(20, { "默认站的名字" })
        for (s in stationList2) {
            LogUtils.Loge("默认名称：stationList2:" + s)
        }

        //创建一个从1--100的数组
        var oneToHundred = Array(100, { i -> i + 1 })
        for (s in oneToHundred) {
            LogUtils.Loge("0到100》oneToHundred:" + s)
        }

        //元素的个数  判断是否为空
        if (oneToHundred.isNotEmpty()) {
            LogUtils.Loge(oneToHundred.count().toString())
        }

        //获取某一个数据
        LogUtils.Loge("站名的第一个" + stationsList.first())
        LogUtils.Loge("站名的最后一个" + stationsList.last())
        LogUtils.Loge("前两个" + stationsList.component1() + stationsList.component2())
        LogUtils.Loge("第两个" + stationsList[2 - 1])
        LogUtils.Loge("第两个" + stationsList.get(2 - 1))

        //筛选重复（把重复的去掉）
        var stationList3 = stationsList.distinct()
        for (s in stationsList) {
            LogUtils.Loge("不重复的数组" + s)
        }

        //把一个数组转化成集合
        val toSet = stationsList.toSet()
        for (s in toSet) {
            LogUtils.Loge("不重复的集合" + s)
        }


        //数组切割  从第二个到第三个，包含前边，不包含后边
        val subList = stationList3.subList(2, 4)
        for (s in subList) {
            LogUtils.Loge("截取数组：" + s)
        }

        //切割数组  从第二个到第三个,包含前边，也包含后边
        val slice = stationList3.slice(2..3)
        for (s in slice) {
            LogUtils.Loge("切割数组：" + s)
        }
//#################################################以上是不可变的数组#############################


        //定义大小可变的数组
        val mutableList2 = mutableListOf("a", "b", "c")
        for (s in mutableList2) {
            LogUtils.Loge("可变数组：" + s)
        }

        //增加一个
        mutableList2.add(2, "e")
        for (s in mutableList2) {
            LogUtils.Loge("可变数组，新增加一个：" + s)
        }

        val mutableList1 = mutableListOf("1", "2", "3")
        //增加一堆
        mutableList2.addAll(mutableList1)
        for (s in mutableList2) {
            LogUtils.Loge("可变数组，新增加一堆：" + s)
        }

        //移除第几个
        mutableList2.removeAt(0)
        for (s in mutableList2) {
            LogUtils.Loge("可变数组，移除第几个：" + s)
        }

        //移除某一个
        mutableList2.remove("e")
        for (s in mutableList2) {
            LogUtils.Loge("可变数组，移除某一个：" + s)
        }

        for (index in mutableList2.indices) {
            LogUtils.Loge("换种写法写循环：" + mutableList2.get(index))
        }

        val list3 = ArrayList<String>()

        list3.add("李")
        list3.add("小")
        list3.add("米")

        list3.remove("李")
        list3.add(0, "牛")
        list3.removeAt(1)
        for (item in list3) {
            LogUtils.Loge("List3集合：" + item)
        }

3.3 最后Map集合：

Map集合和java中的Map相差不大，具体用法可以参照下边的代码。

//创建一个map
        var stationMap = mapOf(Pair("shijiazhuang", "石家庄"), Pair("nanjing", "南京"),
                Pair("suzhou", "苏州"), Pair("shanghai", "上海"), Pair("zhangjiakou", "张家口")
                , Pair("taiyuan", "太原"), Pair("tianjin", "天津"))

        LogUtils.Loge("map数量：" + stationMap.count())
        LogUtils.Loge("map是否位空：" + stationMap.isEmpty())

        //根据key获取values
        LogUtils.Loge(stationMap.get("tianjin"))
        //获取所有的key
        val keys = stationMap.keys
        for (s in keys) {
            LogUtils.Loge("所有的key:" + s)
        }
        //获取所有的values
        val values = stationMap.values
        for (s in values) {
            LogUtils.Loge("所有的values:" + s)
        }

        val toMutableMap = stationMap.toMutableMap()

        toMutableMap.remove("shijiazhuang")
        for (mutableEntry in toMutableMap) {
            LogUtils.Loge("移除某一个:" + mutableEntry)
        }

        toMutableMap["nanjing"] = "南京市"
        for (mutableEntry in toMutableMap) {
            LogUtils.Loge("根据key修改values:" + mutableEntry)
        }
        toMutableMap["cangzhou"] = "沧州"
        for (mutableEntry in toMutableMap) {
            LogUtils.Loge("这样能新增一个:" + mutableEntry)
        }

4、函数/方法

4.1基本方法

 //基本函数
    fun init() {
        /**
         * 调用一个方法
         */
        LogUtils.Loge("调用一个方法：" + makeIntData(1))

        LogUtils.Loge("调用求和方法：" + sum(1, 2).toString())

        LogUtils.Loge("调用求和方法，第二个参数不传递：" + sum(1).toString())

        LogUtils.Loge("调用求和方法，可变参数,第一个：" + sum1(1, 2, 3, 4, 5).toString() + ",第二个：" + sum1(1, 2, 3))

        var intArrayOf = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8)
        LogUtils.Loge("调用求和方法，可变参数,也可以穿一个数组进去：" + sum1(*intArrayOf).toString())

    }


    /**
     * 定义一个入参为int类型的，返回值为String 类型的方法
     */
    private fun makeIntData(number: Int): String {
        return (number + 1).toString()
    }

    /**
     * 定义一个入参为两个int类型 ,第一个必选，第二个不传的时候默认为0,返回只为int 类型，但是可以为null
     * 以及三元运算符的使用
     */
    private fun sum(number: Int?, number1: Int = 0): Int? {
//        if (number != null) {
//            return number + number1
//        } else {
//            return null
//        }
        
        return if (number != null) number + number1 else null
    }

    /**
     * 定义一个可变参数
     */
    private fun sum1(vararg x: Int): Int {
        var sumNumber = 0
        for (i in x) {
            sumNumber += i
        }
        return sumNumber
    }

看一下输出的效果：

11-16 14:35:04.368 4579-4579/com.example.lql.kotlindemo E/###: 调用一个方法：2###
11-16 14:35:04.368 4579-4579/com.example.lql.kotlindemo E/###: 调用求和方法：3###
11-16 14:35:04.368 4579-4579/com.example.lql.kotlindemo E/###: 调用求和方法，第二个参数不传递：1###
11-16 14:35:04.368 4579-4579/com.example.lql.kotlindemo E/###: 调用求和方法，可变参数,第一个：15,第二个：6###
11-16 14:35:04.368 4579-4579/com.example.lql.kotlindemo E/###: 调用求和方法，可变参数,也可以穿一个数组进去：36###

4.2高阶函数

高阶函数：
1、参数或者返回值的类型是函数型
函数型：（参数）--》返回值
lambda: 一种无名函数的简写{ （参数）--》函数执行语句}
其他语言称为闭包，即有能力访问其自身范围外的变量
2 、描述任务的结果，而不是使用循环详细推算
map：常用于对集合类型的元素类型整体元转
其lambda中的参数的约定称为it

       //想要把数字转化为汉字
        val a = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        val b = a.map { "第${it}" }
        for (s in b) {
            LogUtils.Loge("整数转换位字符串" + s)
        }


        //闭包
        //filter:对集合类型进行筛选
        //把偶数筛选出来，然后求和
        var sum = 0
        val c = a.filter {
            it % 2 == 0
        }.forEach {
            sum += it
            LogUtils.Loge("闭包中的：" + sum)
        }

        //分组
        val groupBy = a.groupBy { it % 2 == 0 }
        LogUtils.Loge("groupBy" + groupBy)

5、控制流 for\while\when

这个就没啥好说的了，大家看下代码，然后看一下输出的结果，就明白是啥意思，记住具体的写好就好了。

        //循环中的控制   ： continue 结束本次循环    ，break结束整个循环
        var stringList = arrayOf("小牛", "太阳", "鹈鹕", "黄蜂" )
        //依次操作一个序列（如集合类型）中的每一项，执行次数是可预测的
        for (s in stringList) {
            LogUtils.Loge("循环：" + s)
        }

        //重复执行
        //a in 0..10 等价与 a in 1.rangeTo(10)
        for (a in 0..10) {
            if (a == 5) {
                continue
            }
            LogUtils.Loge("一直在重复执行" + a)
        }

        //while:循环执行操作，直到条件不成立.例子：计算从1开始，加到多少，和是5050
        var sum = 0//和
        var number = 1//起始数
        var timer = 0//次数
        while (sum < 5050) {
            if (number == 5) {
                break
            }
            timer += 1
            number += 1
            sum += number + 1
            LogUtils.Loge("while:循环" + timer)
        }

        var a = 10
        if (a == 10)
            LogUtils.Loge("a等于10")
        else
            LogUtils.Loge("a不等于10")

        LogUtils.Loge(if (a == 10) "a等于10" else "a!=10")


        //在wen语句中，满足了一个条件，就不去执行下边的了
        when (a) {
//            in 0..11 -> {
//                LogUtils.Loge("a在0到11之间")
//            }

            (20 - 11) -> {
                LogUtils.Loge("a==10")
            }

            is Int->{
                LogUtils.Loge("a是Int类型")
            }

            else -> {
                LogUtils.Loge("a不在0到11之间")
            }
        }


        when (a) {
           1,2,3,4,5->{
                LogUtils.Loge("a==1,2,3,4,5")
          }
            else -> {
                LogUtils.Loge("a不在1到5之间")
            }
        }


    var list= mutableListOf<String>()
    list.add("a")
    list.add("b")
    list.add("c")

    for ((index,value ) in list.withIndex()) {
        println("index:${index}--value:${value}")
    }

然后看一下输出的结果：

11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 循环：小牛###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 循环：太阳###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 循环：鹈鹕###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 循环：黄蜂###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行0###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行1###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行2###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行3###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行4###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行6###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行7###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行8###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行9###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: 一直在重复执行10###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: while:循环1###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: while:循环2###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: while:循环3###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: while:循环4###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: a等于10###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: a等于10###
11-16 14:56:17.408 4994-4994/com.example.lql.kotlindemo E/###: a是Int类型###


index:0--value:a
index:1--value:b
index:2--value:c

5.1标签

我们在Lambda表达式开头处添加了标签here@，可以这么理解：该标签相当于记录了Lambda表达式的指令执行入口地址，然后在表达式内部使用return@here跳转至Lambda表达式中的该地址处。

  var list= mutableListOf<String>()
    list.add("a")
    list.add("b")
    list.add("c")
    list.forEach here@{
        if(it.equals("b")){
            return@here
        }
        println("value:${it}")
    }
    // 使用continue跳出此次循环和使用标签效果相同
    for ((index,value ) in list.withIndex()) {
        if(value.equals("b")){
            continue
        }
        println("index:${index}--value:${value}")
    }

6、面向对象编程

这里介绍类的定义、属性、方法以及继承、数据类、枚举类、对象生命和表达式的写法：

 private fun init() {
        var mBook1 = ShoppingBook("如何购物", 50)
        var mBook2 = FoodBook("吃东西", 20, "food")
        LogUtils.Loge(mBook1.toString())
        LogUtils.Loge(mBook2.toString())
        LogUtils.Loge("mBook1.colors" + mBook1.colors)
        LogUtils.Loge("mBook1.address" + mBook1.address)
        LogUtils.Loge("mBook1.number" + mBook1.number)
        LogUtils.Loge("mBook1.newPrice" + mBook1.newPrice)
        mBook1.colors = "绿色"
        LogUtils.Loge("mBook1.colors" + mBook1.colors)
        LogUtils.Loge("mBook1.address" + mBook1.address)
        LogUtils.Loge("mBook1.number" + mBook1.number)
        LogUtils.Loge("mBook1.newPrice" + mBook1.newPrice)

        mBook1.cook()
        mBook2.cook()


        //数据类
        var mUser = User("小米", "123456")
        LogUtils.Loge(mUser.toString())

        //复制
        var mUser2 = mUser.copy(password = "123")
        LogUtils.Loge(mUser2.toString())

        //数据类对象的结构
        var (name, password) = mUser
        LogUtils.Loge("username:$name,$password")

        //列举熟悉
        LogUtils.Loge("${mUser.component1()}${mUser.component2()}")

        LogUtils.Loge("枚举类：" + SexType.values().joinToString())

        val sizeOrdinal = Size.valueOf("M").ordinal
        val sizeName = Size.valueOf("M").name
        LogUtils.Loge("带有构造器的枚举类：" + sizeOrdinal + sizeName)

        val joinToString = Size.values().joinToString { it.name + ":" + it.height }

        LogUtils.Loge("带有构造器的枚举类：" + joinToString)


        //对象表达式
        val baako = object : Chinese("Baako Zaid") {
            override var skin = "black"
        }

        LogUtils.Loge(baako.skin)

        //纯对象表达式：是临时用，无需继承任何类
        val temParking = object {
            var x = 100
        }

        //封装一个类
        NetWorkRequestManager.register()
        //伴生方法与类的关联性强
        IDCard.creat()
    }


    /**
     * 伴生对象：一般用于创建一个类的实例的“工厂”方法
     * 相当于java的静态成员
     */

    class IDCard {
        companion object {
            fun creat() = IDCard()
        }
    }

    //对象声明
    object NetWorkRequestManager {
        fun register() {
            LogUtils.Loge("连接网络")
        }
    }

    /**
     * 对象表达式
     */
    open class Chinese(var name: String) {
        open var skin = "yellow"
    }

    /**
     * 定义一个书的实体
     * 关键字open   ,如果一个类想要被集成，需要在class前加上open关键字
     */

    /**
     * 访问修饰符：
     * private
     * protected  仅子类可见
     * internal  当前模块内可见
     * public
     */
    open class Book constructor(var name: String, var price: Int, var type: String) {
        //普通属性
        open var colors: String = "红色"
        var newPrice: Int = 0
        //组合属性
        var address: String = ""
            get() {
                when (this.colors) {
                    "红色" -> {
                        return "石家庄"
                    }
                    else -> {
                        return "其他"
                    }
                }
            }

        //组合属性也可以影响其他属性
        var number: Int
            get() {
                when (this.address) {
                    "石家庄" -> {
                        return 100
                    }
                    else -> {
                        return 200
                    }
                }
            }
            set(value) {
                when (value) {
                    in 0..199 -> {
                        newPrice = 100
                    }
                    else -> {
                        newPrice = 200
                    }
                }
            }


        //类中的方法
        open fun cook() {
            val menu = arrayOf("番茄炒蛋", "炒土豆", "小米粥")
            val reduce = menu.reduce { s1, s2 -> s1 + "," + s2 }
            LogUtils.Loge("类中的方法：${reduce}")
        }


    }

    /**
     * 类的继承
     */
    class ShoppingBook(name: String, price: Int, type: String = "shopping") : Book(name, price, type) {
        var content = "教你如何购物"

        override fun cook() {
            super.cook()
            var menu = arrayOf("毛血旺", "烤鱼")
            val reduce = menu.reduce { s1, s2 -> s1 + "," + s2 }
            LogUtils.Loge("子类继承父类的方法：${reduce}")
        }
    }

    /**
     * 类的继承
     */
    class FoodBook(name: String, price: Int, type: String) : Book(name, price, type) {
        var content = "如何吃东西才健康"
        //在子类中如果要重写父类的属性，要在父类属性中添加open关键字
        override var colors = "食物黄色"
    }

    /**
     * 数据类
     */
    data class User(var username: String, var password: String)

    /**
     * 枚举类
     */
    enum class SexType {
        男, 女
    }

    /**
     * 带有构造器的枚举类
     */
    enum class Size(val height: Int) {
        S(150), M(160), L(170), XL(180)
    }

7、异常处理以及类型转换

7.1异常处理：

分为两种方式：一种是重要的异常，对程序产生重要影响的，我们要捕获异常，并且处理一下。
第二种是不重要的，在java中是抛出异常，这里抛出异常的写法和java不太一样。
具体看代码：

//捕获异常
        try {
            "g".toInt()
        } catch (e: Exception) {
            LogUtils.Loge(e.toString())
        }

        //抛出异常
        val a: Int? = try {
            "g".toInt()
        } catch (e: Exception) {
            null
        }

        LogUtils.Loge(a.toString())

Log:

11-16 15:09:47.668 4994-4994/com.example.lql.kotlindemo E/###: java.lang.NumberFormatException: Invalid int: "g"###
11-16 15:09:47.678 4994-4994/com.example.lql.kotlindemo E/###: null###

7.2类型检查和类型转换：

这里值得说的是类型转换，在kotlin中分为强制类型转换和安全转换，
比如在代码中吧变量C转换成String类型，如果你非常确定C是一个String,那么你就可以使用强制类型转换。但是如果你不确定C是一个String,那么你可能就需要安全转换了。在安全转换中，如果出现错误，最后拿到的值是一个null.但是不影响程序的运行。

        val a = 5
        val b = 6
        val c = if (a > b) "大于" else a - b

        //类型检查
        if (c is String) {
            LogUtils.Loge("长度" + c.length)
        }

        if (c !is String) {
            LogUtils.Loge("整数" + c)
        }


        //类型转换
        try {
            //强制转换
            var d = c as String
            LogUtils.Loge("强制转换：" + d)
        } catch (e: Exception) {
            LogUtils.Loge("强制转换报错了" + e.toString())
        }

        //安全转换
        var e = c as? String
        LogUtils.Loge("安全转换：" + e)