JuneLeo's Blog
0%

Kotlin学习1

发表于 更新于
  • vararg 可变长度类型
  • lambda 匿名函数
    1
    val sumLambda: (Int, Int) -> Int = { x, y -> x + y }

  • var 可变类型

  • val不可变类型

  • ?可以为空，!! 可以抛出空指针

    1
    var b: String = age ?: "aaa"

  • for

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    for (i in 1..100) { //1-100
        print("$i,")
    }

    for (i in 100 downTo 1){   // 100-1
        print(i)
    }

    for (i in 1..10 step 2){ //1-10    1，3，5，7，9
        print("$i,")
    }

    for (i in 1 until 10){ // 1-10 ,不包含10
        print("$i,")
    }

  • === 地址 ==值

    1
    2
    3
    4
    var a: Int? = 127
    var b: Int? = 127

    print(a === b)

  • 操作符

    1
    2
    3
    4
    5
    6
    7
    shl(bits) – 左移位 (Java’s <<)
    shr(bits) – 右移位 (Java’s >>)
    ushr(bits) – 无符号右移位 (Java’s >>>)
    and(bits) – 与
    or(bits) – 或
    xor(bits) – 异或
    inv() – 反向

  • 标签

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    loop@ for (i in 0 until 100) {
        for (j in 0..10) {
            print(j)
            break@loop
        }
    }

    a.forEach a@{
        print(it)
        return@a
    }

  • class

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    abstract class Person constructor(var name: String) {
        abstract var age: Int
        init {
            println("Person")
        }
    }

    class Chinese(name: String) : Person(name) {
        override var age: Int = 0
        lateinit var lazyName: String
        var scope: Int = 0
        constructor(scope: Int) : this("constructor name") {
            print("Chinese constructor")
            this.scope = scope
        }
        init {
            println(name)
            println(scope)
            println("Chinese")
        }
    }


    // 输出

    Person
    constructor name
    0
    Chinese
    Chinese constructor

  • 内部类inner

  • 类的修饰符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    abstract    // 抽象类  
    final       // 类不可继承，默认属性
    enum        // 枚举类
    open        // 类可继承，类默认是final的
    annotation  // 注解类

    private    // 仅在同一个文件中可见
    protected  // 同一个文件中或子类可见
    public     // 所有调用的地方都可见
    internal   // 同一个模块中可见

  • 拓展函数是静态解析的

  • 拓展函数，this拓展接收者优先

  • sealed

  • let

  • with

  • run

  • apply

  • also

  • 委托