Kotlin速记-类与对象

类定义

Kotlin 类包含：构造函数和初始化代码块、函数、属性、内部类、对象声明。

Kotlin 中用关键字 class 声明类，后面紧跟类名：

// 类定义的格式
class 类名 {
    // 类的构成
}

// 在类中定义函数
class Example{
    fun test() {
        println("test")
    }   
}
// 定义空类
class Empty

类修饰符

修饰符	特性
open	类可继承，类默认final
final	类不可继承，默认属性
annotation	注解类
abstract	抽象类
enum	枚举类

类属性

• var 声明为可变的， val 声明为不可变
• getter setter
• var no: Int -> no = … 等号会被翻译成setter
• 延迟初始化可用 lateinit 关键字

主构造器

不能包含任何代码，可放在初始化代码段，init 关键字作前缀

class Test constructor(name: String) {
    // 通过构造函数传入 name
    val age: Int = 18
    val country: String = "CHINA"
​
    init {
        println("初始化 name $name")
    }
​
    fun test() {
        println("---类函数---")
    }
}
​
val t = Test("Simplation")
初始化 name Simplation

次构造函数

// 次构造函数
    constructor(name :String, sex: String) : this(name) {
        println(" sex is $sex")
    }
​
    fun test() {
        println("---类函数---")
    }
}

val t = Test("Simplation", "男")
初始化 name Simplation sex is 男

嵌套类

将类嵌套在其他的类中使用

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun exam() = 2
    }
}
​
// 调用及调用格式
val a = Outer.Nested().exam()    // 调用格式：外部类.嵌套类.嵌套类方法/属性
println(a)
2

内部类

使用 inner 关键字来表示，内部类会带有一个对外部类的对象的引用，故内部类可以访问外部类成员属性和成员函数

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        // 访问外部类成员
        fun exam() = bar  
        fun innerTest() {
            // 获取外部类的成员变量
            var o = this@Outer 
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}
​
val a1 = Outer().Inner().exam()
println(a1)
1
​
val a2 = Outer().Inner().innerTest()
println(a2)
内部类可以引用外部类的成员，如：成员属性 kotlin.Unit

嵌套类和内部类使用时的区别

1. 创建对象的不同

var test = Outter.Nested()// 嵌套类，Outter后边没有括号
var test = Outter().Inner();// 内部类，Outter后边有括号

2. 引用外部类的成员变量的方式不同

• 嵌套类：

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        var ot: Outer = Outer()
        println(ot.bar) // 嵌套类可以引用外部类私有变量，但要先创建外部类的实例，不能直接引用
        fun exam() = 2
    }
}

• 内部类：

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        fun exam() = bar  // 访问外部类成员
        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}

内部类可直接this@ 外部类名 形式引用外部类的成员变量，不用创建外部类对象

匿名内部类

用对象表达式来创建匿名内部类 必须用 object

class Test {
    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}
/**
 * 定义接口
 */
interface TestInterFace {
    fun example()
}

fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun example() {
            println("这是对象表达式创建匿名内部类的实例")
        }
    })
}