参考链接
Kotlin官方文档
/docs/home.html
中文网站
/docs/reference/properties.html
本系列为参考Kotlin中文文档
/download/u011109881/21418027
整理的笔记
pdf也可以在这里下载
/docs/kotlin-docs.pdf
部分示例来自bilibili 动脑学院的Kotlin 泛型的视频讲解
第二章 第十二节 object
知识点
0 对象声明
1 对象表达式常用场景
2 对象表达式也可运用于接口
3 object 继承多个类demo
4 创建一个简单对象
5 object 匿名对象作为返回值
//6 对象声明
7 对象声明可以有父类
8 object没有构造方法
9 对象是一个单例
//10 使用object对象
11 伴生对象
12 使用Companion引用伴生对象
13 使用类的名称引用伴生对象
14 伴生对象可以继承接口
笔记
// object关键字作用有三// 1 对象声明 : object单独使用// 2 对象表达式 :object 对象作为参数或者被用于赋值 例如匿名内部类// 3 伴生对象: object与companion一起使用 伴生对象的初始化时机与类实例绑定在一起fun main() {// 0 对象声明AppConfig.setSth()println(AppConfig)println(AppConfig)// 单例myPrint(PrintMessage())// 1 对象表达式常用场景// 要创建一个对某个类做了轻微改动的类的对象// object 使用demo// 对PrintMessage类稍作修改myPrint(object : PrintMessage() {override fun printA() {println("printAAAAA")// 6 对象表达式可以访问继承对象的属性和方法println(x)}})// 2 对象表达式也可运用于接口// Android 中的callback onClickListener就是这种思路useInter(object : InterfacePrint {override fun printInter() {println("print interface")}})// 3 object 继承多个类demoprintln(ClassA(10).y)println(aAndB.y)// 4 创建一个简单对象foo()// 5 object 匿名对象作为返回值// 作用不大 感觉没什么意义println(ClassC().publicFoo().javaClass)ClassC().callPrivateFoo()ClassC().bar()// 10 使用object对象DataProviderManager2.printDataProviderManager2()// 11 伴生对象// 伴生对象只存在于class中 且每个class只有一个// 调用伴生对象的成员MyClass.create()// 使用类名引用伴生对象println(MyClass.Factory)// 12 使用Companion引用伴生对象// 省略伴生对象的类名 直接引用伴生对象println(panion)// 13 使用类的名称引用伴生对象// 使用类的名称作为伴生对象的引用// 无论伴生对象是否具名 都可以使用类的名称作为伴生对象的引用val x = MyClass3println(x)val y = MyClass4println(y)// 14 伴生对象可以继承接口val f: Factory<MyClass5> = MyClass5// MyClass5就是伴生对象}interface Factory<T> {fun create(): T}class MyClass5 {companion object : Factory<MyClass5> {override fun create(): MyClass5 = MyClass5()}}// 13 使用类的名称作为伴生对象的引用class MyClass3 {companion object Named {}}class MyClass4 {companion object {}}// 12 省略伴生对象的类名 直接引用伴生对象class MyClass2 {// 伴生对象的声明companion object {fun create(): MyClass = MyClass()}}// 伴生对象class MyClass {// 伴生对象的声明companion object Factory {fun create(): MyClass = MyClass()}}// 报错//val objectVal = object MyData{}open class Base1 {fun funBase() {}}// 6 对象声明// 7 对象声明可以有父类// 8 object没有构造方法// 9 对象是一个单例 且对象声明的初始化过程是线程安全的并且在首次访问时进行object DataProviderManager2 : Base1() {init {println("init object")}// 10fun printDataProviderManager2() {println("printDataProviderManager2")}}// 5 object 匿名对象作为返回值class ClassC {// 私有函数，所以其返回类型是匿名对象类型private fun foo() = object {val x: String = "x"}fun callPrivateFoo() {println(foo().javaClass)}// 公有函数，所以其返回类型是 Anyfun publicFoo() = object {val x: String = "x"}fun bar() {val x1 = foo().x // 没问题 作用域为println(x1)//val x2 = publicFoo().x // 错误：未能解析的引用“x” Any没有属性x}}// 4 创建一个简单对象fun foo() {val simpleObject = object {var x: Int = 1var y: Int = 0}println(simpleObject.x + simpleObject.y)}// 3 object 继承多个类demoopen class ClassA(x: Int) {open val y: Int = x}interface InterfaceB {fun printB() {println("printB")}}val aAndB: ClassA = object : ClassA(1), InterfaceB {override val y = 15}// 2 对象表达式也可运用于接口fun useInter(interfaceOnj: InterfacePrint) {interfaceOnj.printInter()}interface InterfacePrint {fun printInter()}// 1 object 使用demofun myPrint(printObj: PrintMessage) {printObj.printA()printObj.printB()}open class PrintMessage() {var x = 10open fun printA() {println("printA")}fun printB() {println("printBB")}}// 0 对象声明object AppConfig {init {println("init config")}fun setSth() {println("set something")}}
第二章 第十三节 类型别名
知识点
1 为类型提供别名1
2 为类型提供别名2
3 为函数类型提供另外的别名
4 内部类和嵌套类创建新名称
5 为函数类型提供另外的别名2
笔记
import java.io.File// 1 为类型提供别名1typealias NodeAB = HashMap<NodeA, NodeB>// HashMap<NodeA,NodeB> 取名别名NodeABval map_AB1 = NodeAB()val map_AB = HashMap<NodeA, NodeB>() // 等价// 2 为类型提供别名2typealias FileTable<K> = MutableMap<K, MutableList<File>>interface MapInterface2 : FileTable<String> {}interface MapInterface : MutableMap<String, MutableList<File>> {// 等价}// 3 为函数类型提供另外的别名typealias MyHandler = (Int, String, Any) -> Unitfun three1(parameter: MyHandler) = parameter(1,"AAAAAA",1.9)fun three2(parameter: (Int, String, Any) -> Unit) = parameter(1,"AAAAAA",1.9)class RealHandler1 {fun invoke(p1: Int, p2: String, p3: Any): Unit {println(p1)println(p2)println(p3)}}// MyHandler 也可以理解为一个接口class RealHandler2 : MyHandler {// 这里的override不能删除 invoke方法名称无法修改override fun invoke(p1: Int, p2: String, p3: Any): Unit {println(p1)println(p2)println(p3)}}// 4 内部类和嵌套类创建新名称class AAA {inner class Inner {fun printAAA() {println("AAA Inner printAAA")}}}private class BBB {class Inner {fun printBBB() {println("BBB Inner printBBB")}}}typealias AAAInner = AAA.Inner// private typealias 才能给private类的内部类取别名private typealias BBBInner = BBB.Inner// 5 为函数类型提供另外的别名2typealias Predicate<T> = (T) -> Boolean// 因为上面的定义 所以下面的代码有等价表达fun foo1(parameter: Predicate<Int>) = parameter(42)fun foo2(parameter: (Int) -> Boolean) = parameter(42)fun main() {// 3 为函数类型提供另外的别名val p1: (Int, String,Any) -> Unit = { i: Int, s: String, any: Any ->println(i)println(s)println(any)}three1(p1)val p2: MyHandler = { i: Int, s: String, any: Any ->println(i)println(s)println(any)}three2(p2)// 讲MyHandler理解为一个接口RealHandler1().invoke(1,"ABC",1.33)RealHandler2().invoke(1,"ABC",1.33)// 4 内部类和嵌套类创建新名称//val aaaInner = AAAInner() // 报错 内部类只能在包含内部类的类中创建BBBInner().printBBB()// 嵌套类可以在外部创建// 5 为函数类型提供另外的别名2val f1: (Int) -> Boolean = { it > 0 }println(foo1(f1)) // 输出 "true"// 等价val f2: Predicate<Int> = { it > 0 }println(foo2(f2)) // 输出 "true"val p3: (Int) -> Boolean = { it > 0 }println(listOf(1, -2, 3, 0).filter(p3)) // 输出 "[1,3]"// 等价val p4: Predicate<Int> = { it > 0 }println(listOf(1, -2, 3, 0).filter(p4)) // 输出 "[1,3]"}class NodeA {}class NodeB {}
