类、控制流

类

//补充；可见性修饰符

java可见性修饰符.png

• private：内部可见

• protected：内部可见 + 子类可见

• internal ：模块内可见

• public：全部可见，如果不加修饰，默认是public

嵌套类

嵌套类相当于java的静态内部类（static class），kotlin取消了static关键字

• 嵌套类不能访问外部类的其他成员

class demo21 {
    class bb {
    }

    fun test() {
        val bb = demo21.bb()
    }
}

内部类

内部类相当于java中没有使用static修饰的内部类。使用inner关键字修饰。

• 内部类成员可以直接访问外部类的私有数据，因为内部类相当于外部类的成员之一；
• 外部类不能访问内部类的成员，如需访问，需要通过创建内部类对象，通过对象访问内部类成员。

class demo21 {
    var name = "ss"

    inner class aa {
        val cc = 1
        fun t() {
            name = "aa"
        }
    }

    fun test() {
        val aa = demo21().aa()
    }

}

匿名内部类

object关键字：创建一个类，并且创建这个类的对象

//对象表达式
object : [父类] {
    //对象表达式类体
}


open class OnClickListener {
    open fun click() {
    }
}
fun test() {
    val cc = object : OnClickListener() {
        override fun click() {
            //TODO
        }
    }
}

object还可以用于单例

object DataManager {

    lateinit var context: Context

    fun init(context: Context) {
        this.context = context
    }

    fun getName(): String {
        return "aa"
    }

}


fun main() {
    println(DataManager.getName())
}

伴生对象
当中的属性和方法是静态的，可以用类名.xx的方式调用

class Demo24 {
    companion object {
        val age = 100
        fun eat() {

        }
    }
}

fun test() {
    Demo24.age
    Demo24.eat()
}

数据类

• 主构造函数需要至少有一个参数；
• 主构造函数的所有参数需要标记为 val 或 var；
• 数据类不能是abstract、open、inner的

data class User(var name: String)

• equals(): 它可以比较两个对象的属性来确保他们是相同的。
• hashCode(): 我们可以得到一个hash值，也是从属性中计算出来的。
• copy(): 你可以拷贝一个对象，可以根据你的需要去修改里面的属性。

枚举类

enum class Color {
    RED, GREEN, BLUE
}

每个枚举常量都是一个对象，都是枚举类的实例，可以这样实例化

enum class Color(val rgb: Int) {
        RED(0xFF0000),
        GREEN(0x00FF00),
        BLUE(0x0000FF)
}

密封类

• 所有子类都必须在与密封类自身相同的文件中声明
• 一个密封类是自身抽象的，它不能直接实例化并可以有抽象（abstract）成员
• 密封类不允许有非private构造函数（其构造函数默认为 private）

sealed class Animal {
    abstract val name: String
}

class Bird : Animal() {
    fun eat() {
        println(name + "吃了虫子")
    }

    override val name: String
        get() = "Bird"
}

class Dog : Animal() {
    fun eat() {
        println(name + "吃了骨头")
    }

    override val name: String
        get() = "Dog"
}

使用密封类的关键好处在于使用 when表达式的时候，如果能够验证语句覆盖了所有情况，就不需要为该语句再添加一个 else 子句了

fun animalEat(animal: Animal) {
    when (animal) {
        is Bird -> animal.eat()
        is Dog -> animal.eat()
    }
}

拓展方法、属性

扩展一个类的新功能而无需继承该类

fun File.getMd5(): String {
    //计算MD5
    return ""
}

fun check() {
    val file = File("/data/aa.txt")
    if (file.exists()) {
        val md5 = file.getMd5()
    }
}

顶层声明

kotlin允许将方法和属性不写在类体里面

//Demo25.kt文件
package com.lq.kotlindemo.demo02

fun getName(): String {
    return NAME
}

const val NAME = "jack"

class Demo25 {

    fun test() {
        println(getName())
    }
}

条件控制 if、when

if表达式

//可以和java一样使用
fun test(a: Int) {
    val c: Int
    if (a > 0) {
        c = 1
    } else {
        c = 0
    }
}

//作为表达式使用，就有表达式对应的返回值
fun test1(a: Int) {
    val c: Int
    c = if (a > 0) {
        1
    } else {
        0
    }
}
//再简化，相当于三目运算符
fun test2(a: Int) {
    val c = if (a > 0) 1 else 0
}

when表达式

//类似于switch
fun test03(a: Int) {
    val c = when (a) {
        1 -> 100
        2 -> 200
        else -> 300
    }
}

//如果不提供参数，分支条件为bool表达式，则可以替换if..else使用
fun test2(a: Int) {
    val c = if (a > 0) 1 else 0

    val d = when {
        a > 0 -> 1
        else -> 0
    }
}

循环控制 for、while

for循环

//区间[0,10]
for (i in 0..10) {
}
//区间[0,10)
for (i in 0 until 10) {
}
//步长
val a = 0 until 10
for (i in a step 2) {
}
//倒序[10,1]
for (i in 10 downTo 1) {
}

while循环
与java相同