Kotlin学习一：基本知识1

 

---

资源：

官方文档：https://kotlinlang.org/docs/reference/

Kotlin源码：https://github.com/JetBrains/kotlin

Kotlin官博：https://blog.jetbrains.com/kotlin/

Kotlin公众号：Kotlin 推送的都是中文文章

Gradle文档：https://docs.gradle.org/current/userguide/userguide.html

《Kotlin Primer 中文教程》

https://github.com/kymjs/KotlinPrimer

一、Kotlin是什么

• Android官方开发语言
• 100%兼容java，并且具备一些java不具有的特性
• Kotlin-Js 前端开发
• Kotlin-Jvm 服务端开发
• Kotlin-Native 本地执行程序

Kotlin拥有成为全栈语言的潜力。

二、数据类型

1、Boolean数据类型

2、Number数据类型 

val aBoolean: Boolean = true
val anotherBoolean: Boolean = false

val anInt: Int = 8
val anotherInt: Int = 0xFF
val moreInt: Int = 0b00000011
val maxInt: Int = Int.MAX_VALUE
val minInt: Int = Int.MIN_VALUE

val aLong: Long = 12368172397127391
val another: Long = 123
val maxLong: Long = Long.MAX_VALUE
val minLong: Long = Long.MIN_VALUE

val aFloat: Float = 2.0F
val anotherFloat: Float = 1E3f
val maxFloat: Float = Float.MAX_VALUE
val minFloat: Float = -Float.MAX_VALUE

val aDouble: Double = 3.0
val anotherDouble: Double = 3.1415926
val maxDouble: Double= Double.MAX_VALUE
val minDouble: Double= -Double.MAX_VALUE

val aShort: Short = 127
val maxShort: Short = Short.MAX_VALUE
val minShort: Short = Short.MIN_VALUE

val maxByte: Byte = Byte.MAX_VALUE
val minByte: Byte = Byte.MIN_VALUE

fun main(args: Array<String>) {
    println(anotherInt)
    println(moreInt)

    println(maxInt)
    println(Math.pow(2.0, 31.0) - 1)
    println(minInt)
    println( - Math.pow(2.0, 31.0))

    println(maxLong)
    println(Math.pow(2.0, 63.0) - 1)
    println(minLong)
    println(- Math.pow(2.0, 63.0))

    println(aFloat)
    println(anotherFloat)
    println(maxFloat)
    println(minFloat)

    println(maxDouble)
    println(minDouble)

    println(maxShort)
    println(minShort)

    println(maxByte)
    println(minByte)
}

3、Char数据类型

val aChar: Char = '0'
val bChar: Char = '中'
val cChar: Char = '\u000f'

fun main(args: Array<String>) {
    println(aChar)
    println(bChar)
    println(cChar)
}

4、字符串类型

val string: String = "HelloWorld"
val fromChars: String = String(charArrayOf('H', 'e','l','l','o','W','o','r','l','d'))

fun main(args: Array<String>) {
    println(string == fromChars)
    println(string === fromChars)

    println("接下来我们要输出:" + string)

    val arg1: Int = 0
    val arg2: Int = 1
    println("" + arg1 + " + " + arg2 + " = " + (arg1 + arg2))
    println("$arg1 + $arg2 = ${arg1 + arg2}")

    //Hello "Trump"
    val sayHello : String = "Hello \"Trump\""
    println(sayHello)
    //salary
    val salary: Int = 1000
    //$salary
    println("\$salary")

    val rawString: String = """
        \t
        \n
\\\\\\$$$ salary
    """
    println(rawString)
    println(rawString.length)
}

5、类和对象初始化

class 妹子(性格: String, 长相: String, 声音: String): 人(性格, 长相, 声音)
class 帅哥(性格: String, 长相: String, 声音: String): 人(性格, 长相, 声音)

open class 人(var 性格: String, var 长相: String, var 声音: String){
    init {
        println("new 了一个${this.javaClass.simpleName}, ta性格:$性格, 长相:$长相, 声音:$声音")
    }
}


fun main(args: Array<String>) {
    val 我喜欢的妹子: 妹子 = 妹子("温柔", "甜美", "动人")
    val 我膜拜的帅哥: 帅哥 = 帅哥("彪悍", "帅气", "浑厚")
    println(我喜欢的妹子 is 人)
}

6、空类型和智能类型转换（Java里面没有）

fun getName(): String?{
    return null
}

fun main(args: Array<String>) {
//    val name: String = getName() ?: return
//    println(name.length)

    val value: String? = "HelloWorld"
    println(value!!.length)
}

7、区间（Range）

val range: IntRange = 0..1024 // [0, 1024]
val range_exclusive: IntRange = 0 until 1024 // [0, 1024) = [0, 1023]

val emptyRange: IntRange = 0..-1

fun main(args: Array<String>) {
    println(emptyRange.isEmpty())
    println(range.contains(50))
    println(50 in range)

    for(i in range_exclusive){
        print("$i, ")
    }
}

8、数组

val arrayOfInt: IntArray = intArrayOf(1,3,5,7)
val arrayOfChar: CharArray = charArrayOf('H', 'e','l','l','o','W','o','r','l','d')
val arrayOfString: Array<String> = arrayOf("我", "是", "码农")
val arrayOf书记: Array<市委书记> = arrayOf(市委书记("章"), 市委书记("赵"), 市委书记("黄"))

fun main(args: Array<String>) {
    println(arrayOfInt.size)
    for(int in arrayOfInt){
        println(int)
    }

    println(arrayOf书记[1])
    arrayOf书记[1] = 市委书记("方")
    println(arrayOf书记[1])

    println(arrayOfChar.joinToString())
    println(arrayOfInt.slice(1..2))
}

三、程序结构

3.1、常量与变量

常量：

变量：

类型推导：

3.2 函数（function）

 匿名函数：

3.3 Lambda表达式

 美 [ˈlæmdə]  匿名函数

Lambda表达式其实就是匿名函数

fun sum2(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}

fun sum3(arg1: Int, arg2: Int) = arg1 + arg2

val sum4 = { arg1: Int, arg2: Int -> arg1 + arg2 }

lambda类型表示举例：

调用： 

简化：

3.4 类成员

3.5 基本运算符

3.6  表达式

中缀表达式：

 if表达式：

 when表达式：

3.7  循环语句

fun main(args: Array<String>) {
    try {
        val arg1 = args[0].toInt() //1
        val arg2 = args[1].toInt() //2a
        println("$arg1 + $arg2 = ${sum(arg1, arg2)}")
    }catch (e: NumberFormatException){
        println("您确定输入的是整数吗？")
    }catch (e: ArrayIndexOutOfBoundsException){
        println("您确定输入的是两个整数吗？")
    }catch (e: Exception){
        println("程序出现了未知异常，可能是您的人品太差了。${e.message}")
    }finally {
        println("谢谢您使用我们的加法计算器")
    }
}

fun sum(arg1: Int, arg2: Int): Int{
    return arg1 + arg2
}

3.8  异常捕获

3.9  具名参数、变长参数、默认参数

3.10  小案例：命令行计数器开发

fun main(args: Array<String>) {
    println("请输入算式例如: 1 + 2")
    val input = readLine()
    try {
        if (input != null) {
            val splits = input.split(" ")
            //第一个参数
            val arg1 = splits[0].toDouble()
            //第二个参数
            val arg2 = splits[2].toDouble()
            //运算符
            val op = splits[1]
            println("$arg1 $op $arg2 = ${Operator(op)(arg1, arg2)}")
        }
    } catch (e: NumberFormatException) {
        println("您确定输入的是数字吗？")
    }


}

class Operator(op: String) {
    val opFun: (left: Double, right: Double) -> Double

    init {
        opFun = when (op) {
            "+" -> { l, r -> l + r }
            "-" -> { l, r -> l - r }
            "*" -> { l, r -> l * r }
            "/" -> { l, r -> l / r }
            "%" -> { l, r -> l % r }
            else -> {
                throw UnsupportedOperationException(op)
            }
        }
    }

    operator fun invoke(left: Double, right: Double): Double {
        return opFun(left, right)
    }
}

3.11  导出可执行程序