Kotlin 入门笔记

Kotlin 入门笔记

/// 0. 程序入口

fun main(args: Array<String>) {


    showMessage(null);
    showMessage("Today is Friday")

    showName("oyoung", 26) /// 调用形式1
    showName(name = "Xiaohong", age = 6) /// 调用形式2, 参数名称不分先后
    showName(age = 10, name = "Xiaogou")

    println("double of 1000 is ${doubleOf(1000)}")


    println(total(2.5, 6, 0.85)) /// 12.75

    println( '4' repeat 5) /// 44444

    println(4 * "123") /// 123123123123

    multiPrint("a", "b", "c", "d")

    ValOrVar()

    classUsage()

    useWhen()

    useLoops()

    useRange()

    useEquals()

    useConditionExpression()
}
/// 一、基本概念
/// 1. 函数
/// 1.1 基本形式
fun showMessage(message: String?): Unit {

    message?.let {
        println(it)
    }
}

/// 1.2 参数使用默认值

fun showName(name: String, age: Int = 2) : Unit {
    println("My name is $name, my age is $age years old")
}

/// 1.3 函数返回值

fun doubleOf(number: Int): Int {
    return number + number;
}

/// 1.4 函数简单形式

fun total(single: Double, count: Int, percent: Double) : Double = single * count * percent

/// 1.5 中缀函数, 类的成员函数, 并且参数个数为1, 调用形式比较特殊,
/// 函数的名字需要像操作符一样放在类对象和参数的中间用空格分开: obj op arg
/// 常用中缀函数 to, "age" to 18 结果为 Pair("age", 18)
infix fun Char.repeat(times: Int) = "${this}".repeat(times)

/// 1.6 操作符函数

/// 比如定义乘法操作符 *
/// 整数 * 字符串 => 重复(整数次)输入字符串的字符串
operator fun Int.times(message: String) = message.repeat(this)

/// 1.7 vararg参数
/// 表示数量不定的同类型参数
/// 在运行期间, vararg 标记的参数会表现为数组, 如果需要在函数内部传递给另一个vararg 参数的函数， 需要用 * 来引用
fun multiPrint(vararg messages: String) {
    for (i in messages) {
        print(i)
        print(if (i === messages.last()) "" else ", ")
    }
}


/// 2. 常量和变量

fun ValOrVar() {

    /// 2.1 常量的定义, 使用 val 关键字, 形式：  val 常量名[: 常量类型] = 常量值
    /// 定义时必须初始化, 可以通过类型推断省略常量的类型标志
    /// 常量定义后, 不可再修改常量的值, 否则编译报错
    val n: Int = 100
    val name = "God"

    /// 2.2 变量的定义, 使用 var 关键字, 形式： var 变量名[: 变量类型] = 初始值
    /// 变量同样在定义时必须给定初始值, 及时是可空/可选类型， 也要使用null进行初始化
    var number: String? = null
    var age: Int = 0
    var message = "Hahahaha"

    /// 3. 空值安全保障
    /// kotlin中规定：不可以对任何类型的变量赋值为null, 如果认定为该变量可以为null, 则必须将该变量定义为可空类型, 即在原来的类型后面加上?
    /// 并且可空类型的变量也不可传递到非可空类型参数的函数中
    /// 如果函数的参数类型有可能为空, 则应该使用可空类型的参数

    var myName = "oyoung"
    /// myName = null // 不允许

    var yourName: String? = "Big SB"
    yourName = null
}

/// 3. 类
/// 3.1 不包含任何属性和自定义构造函数的类

class One
/// 3.2 包含属性和自定义构造的类
class Two(val value: Int, var name: String)

fun  classUsage() {

    val one = One()
    var two = Two(0, "O")

    /// 3.3 访问类属性
    println(two.value)

    /// 3.4 修改类属性
    two.name  = "Fuck"
}

/// 4 泛型
/// 4.1 泛型类

class Queue<E>(vararg items: E) {
    private val children = items.toMutableList()

    fun enqueue(item: E) = children.add(item)

    fun dequeue(): E = children.removeAt(0)

    fun size() = children.size

    fun isEmpty() = children.isEmpty()
}

/// 4.2 泛型函数

fun <E> queueOf(vararg items: E) : Queue<E> = Queue(*items)

fun queueUsage() {

    val qa = Queue(1, 2, 3, 4)
    val qb = queueOf("a", "b", "c")

    qa.enqueue(8)
    qb.dequeue()

}

/// 5. 继承
/// 5.1 在Kotlin里面， 所有的类默认都是final的, 即不可继承的，
/// 如果需要将某各类设计成父类，需要加上open 关键字
/// 如果需要重载父类的成员函数, 父类的函数也要加上open关键字

open class Animal {
    open fun say() {
        println("Nothing")
    }
}

open class Dog(val name: String, var age: Int): Animal() {
    override fun say() {
        println("Wow Wow, My name is $name, I'm $age years old")
    }
}


/// 5.2 继承父类时，可以直接调用父类构造函数
class Keji: Dog("Keji", 0)

/// 二、流程控制
/// 2.1. when 语句, 加强版的 switch case
fun useWhen() {

    for (i in 0..9) println( when(i) {
        2 -> "i is 2"
        is Int -> "i is int"
        else -> "i is not 2"
    })

}

/// 2.2 循环

fun useLoops() {

    println("for 循环")
    /// 2.2.1 for 循环
    for (i in 0..9) {
        print(i)
        print(if (i == 9) "" else ", ")
    }

    println()
    println("while 循环")
    /// 2.2.2 while 循环
    var i = 0
    while (i < 10) {
        print(i++)
        print(if (i == 10) "" else ", ")
    }

    println()
    println("do {} while 循环")

    /// 2.2.3 do {} while
    do {
        print(i--)
        print(if (i == 0) "" else ", ")
    } while (i > 0)


    println()
    println("迭代器循环")

    /// 2.2.4 迭代器
    /// 当集合类型重载了 iterator() 接口并返回一个 iterator时，该集合类型的对象可以直接使用 for ( in ) 循环
    /// iterator的特征是 拥有以下两个接口函数
    /// hasNext() -> Boolean
    /// next() -> E

    val list = listOf(0, 1, 2, 3, 4)

    val it = list.iterator()

    while (it.hasNext()) {
        print(it.next())
        print(if (it.hasNext() ) ", " else "")
    }

    println()

}

/// 2.3. 范围

fun useRange() {

    /// 2.3.1 使用 ..
    val range1 = 0..5  // 0, 1, 2, 3, 4, 5
    /// 2.3.2 使用 .. + step
    val range2 = 0..6 step 2 // 0, 2, 4, 6
    /// 2.3.3 使用 downTo
    val range3 = 5 downTo 0 // 5, 4, 3, 2, 1, 0
    /// 2.3.4 使用 downTo + step
    val range4 = 50 downTo 0 step 10 // 50, 40, 30, 20, 10, 0

    println("Range: ")

    range1.forEach {
        print(it)
        print(if (it == range1.last) "" else ", ")
    }
    println()

    range2.forEach {
        print(it)
        print(if (it == range2.last) "" else ", ")
    }
    println()

    range3.forEach {
        print(it)
        print(if (it == range3.last) "" else ", ")
    }
    println()

    range4.forEach {
        print(it)
        print(if (it == range4.last) "" else ", ")
    }
    println()

}

/// 2.4 相等比较

fun useEquals() {

    val a = setOf(1, 2, 3)
    val b = setOf(3, 2, 1)

    /// 2.4.1 == 值比较
    println(a == b)

    /// 2.4.2 === 引用比较
    println(a === b)

}

/// 2.5 条件表达式 if else
/// kotlin 的条件表达式可以有返回值
/// 其他语言中的三目运算符 a ? b: c 在kotlin 中仍旧是 if (a) b else c

fun  useConditionExpression() {


    var  number = 9

    if (number % 2 == 0) {
        println("偶数")
    } else {
        println("奇数")
    }

    println( if(number % 3 == 0) "是3的倍数" else "不是3的倍数" )

}

//TODO: 未完待续