[移动开发]Kotlin基础语法

/*
Kotlin特点
* ·支持类型推导；
* ·代码末尾不需要分号；
* ·字符串模板；
* ·原始字符串，支持复杂文本格式；
* ·单一表达式函数，简洁且符合直觉；
* ·函数参数支持默认值，替代 Builder 模式的同时，可读性还很强；
* ·if 和 when 可以作为表达式。
同时，JetBrains 也非常清楚开发者在什么情况下容易出错，所以，它在语言层面也做了很多改进：
* ·强制区分“可为空变量类型”和“不可为空变量类型”，规避空指针异常；
* ·推崇不可变性（val），对于没有修改需求的变量，IDE 会智能提示开发者将“var”改为“val”；
* ·基础类型不支持隐式类型转换，这能避免很多隐藏的问题；
* ·数组访问行为与集合统一，不会出现 array.length、list.size 这种恼人的情况；
* ·函数调用支持命名参数，提高可读性，在后续维护代码的时候不易出错；
* ·when 表达式，强制要求逻辑分支完整，让你写出来的逻辑永远不会有漏洞。
*/

fun main(){
    /*
    关键字     变量类型
     ↓          ↓           */
    var price: Int = 100;   /*
         ↑            ↑
       变量名        变量值   */

    //var m : Int = 10

    //Kotlin支持类型推导，大部分情况下，变量类型可以省略不写
    var m = 10  // 默认推导类型为： Int


    /*
     * val 声明的变量，我们叫做不可变变量，它的值在初始化以后就无法再次被修改，它相当于Java里面的final变量。
     * var 声明的变量，我们叫做可变变量，它对应 Java 里的普通变量。
     */
    val b = 20
    //b = 25报错

    var a = 100
    a = 15


    /* 在Java 里面，基础类型分为原始类型(Primitive Types)和包装类型(Wrapper Type)。
       比如，整型会有对应的int 和Iinteger，前者是原始类型，后者是包装类型
            int i = 0; //原始类型
            Integer j = 1; //包装类型
     */
    //在Kotlin语言体系当中，是没有原始类型这个概念的。这也就意味着，在Kotlin里，一切都是对象。
    val n: Double = 1.toDouble() //整型数字"1"被看作是对象了，所以我们可以调用它的成员方法toDouble()


    /* Kotlin 强制要求开发者在定义变量的时候，指定这个变量是否可能为 null。
       对于可能为null的变量，我们需要在声明的时候，在变量类型后面加一个问号“?”
     */
    //val i: Double = null // 编译器报错
    val o: Double? = null // 编译通过


    //在数字类型上，Kotlin和Java几平是一致的
    /*
       整数默认会被推导为“int”类型；
       Long 类型，我们则需要使用“L”后缀；
       小数默认会被推导为“Double”，我们也可以使用“D”后缀；
       Float 类型，我们需要使用“F”后缀;
       使用“0x”，来代表十六进制字面量；
       使用“0b”，来代表二进制字面量。
     */
    //对于数字类型的转换，Kotlin 与 Java 的转换行为是不一样的。
    val int = 1
    val long = 1234567L
    val double = 13.14
    val float = 13.14F
    val hexadecimal = 0xAF
    val binary = 0b01010101


    //Java 可以隐式转换数宇类型，而 Kotlin 更推崇显式转换。
    val i = 100
    //val j: Long = i // 编译器报错
    val j: Long = i.toLong() // 编译通过
    //toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()、toChar()


    val c: Char = 'A'
    //val i: Int = c // 编译器报错
    val k: Int = c.toInt() // 编译通过
    println(k)


    val s = "Hello Kotlin!"
    val name = "Kotlin"
    print("Hello $name!")
    /*            ↑
        直接在字符串中访问变量
    */
    // 输出结果：
    // Hello Kotlin!


    val array = arrayOf("Java", "Kotlin")
    print("Hello ${array.get(1)}!")
    /*            ↑
          复杂的变量，使用${}
    */
    // 输出结果：
    // Hello Kotlin!


    val y = """
当我们的字符串有复杂的格式时
       原始字符串非常的方便
            因为它可以做到所见即所得。 """
    println(y)


    //在Kotlin中，一般用arrayOf()创建数组
    val arrayInt = arrayOf(1, 2, 3)
    val arrayString = arrayOf("apple", "pear")


    val array2 = arrayOf("apple", "pear")
    println("Size is ${array2.size}")
    println("First element is ${array2[0]}")
    // 输出结果：
    //  Size is 2
    //  First element is apple


    helloFunction("Kotlin")
    helloFunction(name = "Kotlin")


    createUser("Tom", 30, 1, 78, 2093, 10937, 3285)

    createUser(
        name = "Tom",
        age = 30,
        gender = 1,
        friendCount = 78,
        feedCount = 2093,
        likeCount = 10937,
        commentCount = 3285
    )

    createUser2(
        name = "Tom",
        age = 30,
        commentCount = 3285
    )



    val i1 = 1
    if (i1 > 0) {
        println("Big")
    } else {
        println("Small")
    }
    //还可以作为表达式来使用
    val message = if (i1 > 0) "Big" else "Small"
    println(message)
    //输出结果：
    //Big



    val i2: Int = 1

    when(i2) {
        1 -> print("一")
        2 -> print("二")
        else -> print("i 不是一也不是二")
    }
    //输出结果：
    //一

    //Kotlin 的 when 更加强大，它同时也可以作为表达式，为变量赋值
    val i3: Int = 1
    val message2 = when(i3) {
        1 -> "一"
        2 -> "二"
        else -> "i 不是一也不是二" // 如果去掉这行，会报错
    }
    print(message2)


    //while 循环在使用上和 Java 也没有什么区别
    //对于 for 语句，Kotlin 和 Java 的用法就明显不一样
    //以下代码就代表了迭代 array 这个数组里的所有元素
    val array1 = arrayOf(1, 2, 3)
    for (i in array1) {
        println(i)
    }

    //Kotlin 还支持迭代一个“区间”，
    //我们可以使用“..”来连接数值区间的两端，比如“1..3”就代表从 1 到 3 的闭区间，左闭右闭
    val oneToThree = 1..3 // 代表 [1, 3]

    for (i in oneToThree) {
        println(i)
    }
    //输出结果：
    //1
    //2
    //3

    //还可以逆序迭代一个区间
    //
    for (i in 6 downTo 0 step 2) {
        println(i)
    }
    //以上代码的含义就是逆序迭代一个区间，从 6 到 0，每次迭代的步长是 2，这意味着 6 迭代过后，到 4、2，最后到 0。
    //输出结果：
    //6
    //4
    //2
    //0
}



/*
关键字    函数名          参数类型   返回值类型
 ↓        ↓                ↓       ↓      */
fun helloFunction(name: String): String {
    return "Hello $name !"
}/*   ↑
   花括号内为：函数体
*/

//单一表达式函数
//fun helloFunction(name: String): String = "Hello $name !"
//fun helloFunction(name: String) = "Hello $name !"



fun createUser(
    name: String,
    age: Int,
    gender: Int,
    friendCount: Int,
    feedCount: Int,
    likeCount: Long,
    commentCount: Int
) {
    //..
}


/*
* gender、friendCount、feedCount、likeCount、commentCount 这几个参数都被赋予了默认值。
* 这样做的好处就在于，我们在调用的时候可以省很多事情。比如说，下面这段代码就只需要传 3 个参数，
* 剩余的 4 个参数没有传，但是 Kotlin 编译器会自动帮我们填上默认值。
    createUser2(
        name = "Tom",
        age = 30,
        commentCount = 3285
    )
*/
fun createUser2(
    name: String,
    age: Int,
    gender: Int = 1,
    friendCount: Int = 0,
    feedCount: Int = 0,
    likeCount: Long = 0L,
    commentCount: Int = 0
) {
    //..
}


/*
   Kotlin 当中明确规定了类型分为“可空类型”“不可空类型”，
   因此，我们会经常遇到可空的变量，并且要判断它们是否为空。
*/
fun getLength(text: String?): Int {
    return if (text != null) text.length else 0
}

//Elvis 表达式写法————
fun getLength2(text: String?): Int {
    //上述第一个问号，如果text为空，就不会执行后面获取长度的操作，返回默认值-1。
    /*
        语法格式为“表达式?:表达式”的，如果左侧表达式非空，
        则返回左侧表达式的值，否则返回右侧表达式的值。
        当且仅当左侧为空时，才会对右侧表达式求值。
     */
    return text?.length ?: 0
}