协程中的延迟Delay
//高仿协程中的延迟 suspend fun pkDelay(time: Long, unit: TimeUnit = TimeUnit.MILLISECONDS) { suspendCoroutine<Unit> { executor.schedule({ it.resume(Unit) }, time, unit) } } private val executor = Executors.newScheduledThreadPool(1) { runnable -> Thread(runnable, "pk4pkThread").apply { isDaemon = true } } fun main() { GlobalScope.launch(Dispatchers.IO) { println("pkDelay start before") pkDelay(//高仿协程中的延迟 // delay(100) println("pkDelay start after") } Thread.sleep(10000) }协程监听取消
//协程监听取消 suspend fun getUserInfo(): String { return suspendCancellableCoroutine { continuation -> thread { Log.d(TAG, "getUserInfo() called thread : ${Thread.currentThread().name}") Thread.sleep(3000) continuation.resume("this is userInfo result") } //监听取消 cancel continuation.invokeOnCancellation { Log.d(TAG, "getUserInfo() invokeOnCancellation called") } } }SAM 接口
//SAM 接口 fun interface TestInterface { // fun test(ab: Int) fun test() }Inner
class InnerClassTest { fun get() { val notInnerClass = NotInnerClass() val innerClass = InnerClass() } //静态内部类 public class NotInnerClass //内部类 public inner class InnerClass }伴生对象
//Kotlin 之所以能抛弃静态成员，主要原因在于它允许包级属性和函数的存在， //而且 Kotlin 为了维持与 Java 完全的兼容性，为静态成员提供了多种替代方案： //使用 包级属性和包级函数：主要用于 全局常量 和 工具函数 ； //使用 伴生对象：主要用于与类有紧密联系的变量和函数； //使用 @JvmStatic 注解：与伴生对象搭配使用，将变量和函数声明为真正的 JVM 静态成员。 class CompanionObject { companion object { const val name: String = "" fun getAge(): Int { return 10 } @JvmField val name2: String = ""//等效于 const val name2:String="" @JvmStatic fun getAge2(): Int { // return 10 } } }属性 Field
@file:JvmName("Field_Name") //java代码中就可以直接用Field_Name访问字段 package com.example.java val name: String = "100" //包级属性 私有常量值 --> FieldKt.name const val sex: Int = 0//包级属性 公共常量值 --> public static final int sex = 0; //需要自定义 setter 或 getter 的属性，不能放在类头里定义，必须在类体内定义 //getter 是一个没有参数、返回类型与属性类型相同的函数 //setter 的参数列表一般有一个与属性类型相同的参数，没有返回值。 class Field { val age: Int = 0// 成员属性 --> Field().age }类属性
//@Transient 这个关键字表示该属性是「瞬时」的，不参与类的序列化 //@Volatile 这个关键字用于多线程，可以视为「轻量化的 synchronized」 //@JvmField 这个关键字将 Kotlin 类的属性直接暴露出来,不生成getter方法,直接访问属性 //field : Backing Fields (幕后属性) class PersonEntity(@JvmField val name: String, @Transient val age: Int) { var likes:String="abc" // get() {return likes+"dd"} // 错误的写法 -->递归调用内存溢出 Exception in thread "main" java.lang.StackOverflowError get() {return field+"dd"} //正确的写法 val otherName get() = name + "_other" }构造函数 – 重载
class StudentEntity constructor(val name: String) { //@JvmOverloads 重载构造函数，非必须的参数要设置默认值 //class StudentEntity @JvmOverloads constructor(val name: String, var age: Int=0,var sex: Int = 0) { //lateinit修饰符只能修饰不可空类型，并且不允许修饰基础类型（四类八种基础类型int， double，boolean等）。 // lateinit var age: String //正确 // lateinit var age: String //错误 var age: Int = 0 //次构造函数不能在参数列表中声明并初始化成员变量， //这也是“age: Int”前面为什么没有 val 的原因 constructor(age: Int, name: String) : this(name) { this.age = age CompanionObject.name } override fun toString(): String { return "StudentEntity(name='$name', age=$age)" } }改良 Elvis
/** * 改良 Elvis * Elvis 操作符很方便，但只能连接表达式，我们可以写一个扩展函数来作为加强版的 Elvis 操作符。 */ inline infix fun <T : Any> T?.ifNull(block: (T?) -> T): T { if (this == null) { return block(this) } return this }使用
fun testIfNull() { var testAny: String? = "jjj" val resultStr = testAny ifNull { val a = 1 + 2 println("a is $a") "卧槽。。。2" } println("resultStr is $resultStr") }接口 Interface
//kotlin 接口可以有默认实现 //Kotlin 通过静态内部类 + 添加默认实现方法的方式实现了 JDK 1.6 中不支持的接口默认方法，给接口的设计带来了便利。 interface KotlinInterface { fun getName(): String fun getAge(): Int {//默认实现 return 1 } } //实现类 -- 实现接口方法 class KotlinInterfaceImpl : KotlinInterface { override fun getName(): String { return "KotlinInterfaceImpl" } } //实现类 -- 复写默认实现 class KotlinInterfaceImpl2 : KotlinInterface { override fun getName(): String { return "KotlinInterfaceImpl2" } override fun getAge(): Int { // return super.getAge() return 2 } }Java实现kotlin的接口
public class KotlinInterfaceImpl3 implements KotlinInterface { @NotNull @Override public String getName() { return "KotlinInterfaceImpl3"; } @Override public int getAge() { return DefaultImpls.getAge(this);//通过DefaultImpls调用默认的接口实现 } }小知识点测试
object MySomeTestClass { @JvmStatic fun main(args: Array<String>) { //List 过滤操作 // val testList = listOf<String>("banner", "po", "KUI", "apply", "hello") // testList.filter { // it.length>2 // }.map { // it.toUpperCase() // }.forEach { // println("it is $it") // } // //Map打印快捷方式 // val testMap = mapOf<String, String>( // "a" to "a", // "b" to "b", // "c" to "c" // ) // for ((S, K) in testMap) { // println("S:$S K:$K") // } // var isNull: String? = null // println(isNull?.toUpperCase()?.length ?: "KK") // // var oneValue: String? = "oneValue" // println("oneValue let is ${oneValue?.let { transformValue(oneValue) }}") // val mapped = oneValue?.let { // transformValue(oneValue) "---->let is return " // } ?: "--->let is null" // println("mapped is $mapped") //Integer中 -128到127是常量值，所以装箱后===也相等，超过范围以外是非常量 // val a: Int = -128 // val boxedA: Int? = a // val anotherBoxedA: Int? = a // // val b: Int = 127 // val boxedB: Int? = b // val anotherBoxedB: Int? = b // // val c: Int = 128 // val boxedC: Int? = c // val anotherBoxedC: Int? = c // println(boxedA === anotherBoxedA) // true // println(boxedB === anotherBoxedB) // true // println(boxedC === anotherBoxedC) // false // println() // //===的另一种写法 equals // println(boxedA?.equals(anotherBoxedA)) // true // println(boxedB?.equals(anotherBoxedB)) // true // println(boxedC?.equals(anotherBoxedC))// false // println() // // == 比较数值 // println(boxedA == anotherBoxedA) // true // println(boxedB == anotherBoxedB) // true // println(boxedC == anotherBoxedC) // true //改良 Elvis // var testAny: String? = "jjj" // val resultStr = testAny ifNull { // val a = 1 + 2 // println("a is $a") // "卧槽。。。2" // } // println("resultStr is $resultStr") // //无限递归调用，导致报错 // println("like is " + PersonEntity("", 1).likes) // //循环 break 标签@ continue return // //标签名@ 表达式 //标签名为合法的标识符，与变量名和函数名格式相同 // loop@ for (i in 1..10) { // for (j in 1..100) { // println("i is $i --> j is $j") if (j == 10) break//终止最近的for循环-->这里是j循环 // if (j == 10) break@loop //终止 i 循环 // } // } // // //Kotlin 为了简化程序，会给每个高阶函数添加一个 隐式标签，这个标签与函数同名 // val testList = listOf<Int>(1, 2, 3) // val returnResult = testList.forEach { // if (it == 2) return@forEach // println("forEach it is $it") // } // println("returnResult is $returnResult") // val returnResult2 = testList.let { // return@let 1 //return@标签 返回值 // } // println("returnResult2 is $returnResult2") //invoke函数定义 // add(1, 3) { // println("add it is $it") // } // //数据类型转变 // val testList = listOf(1, 2, 3) // val destination = mutableListOf<String>() // testList.mapTo(destination, { // it.toString() + "_mapTo" // }) // println("des is $destination") } //某种操作后转换 fun transformValue(value: String): Int? { // return value.length return null } //invoke() 函数定义了“调用”这个行为，它同时重载了括号操作符( () )，允许我们用括号来传入参数、得到返回值。 fun add(a: Int, b: Int, back: ((c: Int) -> Unit)) { back(a + b)// 等价于 back.invoke(a + b) } }