Kotlin基础语法

fun main(){
    
    var price: Int = 100;   

    //var m : Int = 10

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


    
    val b = 20
    //b = 25报错

    var a = 100
    a = 15


    
    //在Kotlin语言体系当中，是没有原始类型这个概念的。这也就意味着，在Kotlin里，一切都是对象。
    val n: Double = 1.toDouble() //整型数字"1"被看作是对象了，所以我们可以调用它的成员方法toDouble()


    
    //val i: Double = null // 编译器报错
    val o: Double? = null // 编译通过


    //在数字类型上，Kotlin和Java几平是一致的
    
    //对于数字类型的转换，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
) {
    //..
}



fun createUser2(
    name: String,
    age: Int,
    gender: Int = 1,
    friendCount: Int = 0,
    feedCount: Int = 0,
    likeCount: Long = 0L,
    commentCount: Int = 0
) {
    //..
}



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
}