前言
本文主要讲述kotlin高阶相关的内容,如果对kotlin基础还不了解的,
可以参考文章Android Kotlin 基础详解_袁震的博客-CSDN博客
1,与Java的相互调用
1.1在kotlin中调用java代码
大多数的java代码都可以直接在kotlin中调用,没有问题,但是有一些代码是不能直接调用的,这里需要注意一下
1.1.1 含有关键字的方法
某些kotlin关键字在java中是合法的标识符,in, object,is等等,如果java类中使用kotlin关键字作为方法名,我们仍然可以调用这个方法,只要使用反引号`对方法名转义即可:
在java中:
public class JavaTest {
public void in(){
System.out.println("输出in");
}
}
在kotlin中调用:
var javaTest =JavaTest()
javaTest.`in`()
1.1.2null值安全性与平台数据类型
Java 中的所有引用都可以为 null 值, 因此对于来自 Java 的对象,
Kotlin 的严格的 null 值安全性要求就变得毫无意义了.
Java 中定义的类型在 Kotlin 中会被特别处理,
被称为 平台数据类型(platform type). 对于这些类型,
Null 值检查会被放松, 因此对它们来说, 只提供与 Java 中
相同的 null 值安全保证
比如:
val list =ArrayList<String>()//非null值 因为是构造器方法的返回结果
list.add("yuanzhen")
val size =list.size //非null值 因为是基本数据类型int
//报异常 Index 1 out of bounds for length 1
val item =list.get(1)//类型自动推断结果为平台类型,通常的java对象
item.substring(2)//
1.1.3@Nullable 和@NotNull
带有@Nullable 和@NotNull的注解的Java类型在kotlin中不会被当作平台数据类型,而会被识别为可为null的,或非null的kotlin类型
@NotNull
Set<@NotNull String> toSet(@NotNull Collection<@NotNull String> elements) {
...
}
在kotlin中如下:
fun toSet(elements: (Mutable)Collection<String>) : (Mutable)Set<String> { ... }
fun toSet(elements: (Mutable)Collection<String!>) : (Mutable)Set<String!> { ... }
(Mutable)Collection<T>! 代表 “元素类型为 T 的Java 集合,
内容可能可变, 也可能不可变,
值可能允许为 null, 也可能不允许为null”,
Array<(out) T>! 代表 “元素类型为 T (或 T 的子类型)的 Java 数组,
值可能允许为 null, 也可能不允许为 null”
1.1.4 数据类型映射
kotlin会对某些java类型进行特殊处理,这些类型会被从java中原封不动的装载进来,但被映射为对应的kotlin类型。映射过程只会在编译时发生,运行时的数据表达不会发生变化。映射关系如下:
![](https://img-blog.csdnimg.cn/bc6f2fe4addb48cf97f170713616aeb2.png)
![](https://img-blog.csdnimg.cn/5c1927120e2b446dbb7fc5a3b0d5c71c.png)
![](https://img-blog.csdnimg.cn/9f5d0c385a6f44efa16e499506509bcf.png)
1.1.5泛型
if (a is List<Int>) // 错误: 无法判断它是不是 Int 构成的 List
// 但是
if (a is List<*>) // OK: 这里的判断不保证 List 内容的数据类型
1.1.6 获得java类
要在kotlin中,获取java类,有两种写法:
val clazz = javaTest::class.java
val clazz1 = javaTest.javaClass
1.2 在java中调用kotlin代码
kotlin.jvm.JvmClassMappingKt.getKotlinClass(MainView.class)
java中访问Kotlin文件中的函数,需要使用:文件名Kt.函数名进行访问
MyClassKt.test();
在Kotlin中,可以把很多具有相似功能的函数放到同一个kotlin文件中,如果想要以Java中类似静态方法的形式访问Kotlin文件中的函数(不使用文件名Kt进行访问),可以通过使用@file:JvmName("任意名称")注解来达成目标。需要注意的是,@file:JvmName("名称") 一定要放在文件的最开始,要在包声明之前
@file:JvmName("Test")
package com.yuanzhen.kotlinstudy
fun test1(){
println("测试JvmName")
}
在java中调用:
Test.test1();
2.动态代理
Kotlin原生支持了动态代理语法,通过by关键字实现,省略了Java中要手写代理类实现InvocationHandler 接口, 通过Proxy获取代理类调用方法等一系列步骤。
interface Animal{
fun bark()
}
class Dog : Animal{
override fun bark() {
println("Wang")
}
class Duck : Animal{
override fun bark() {
println("Ga ga")
}
}
class Zoo(animal : Animal) : Animal by animal
fun main(){
Zoo(Dog()).bark()
Zoo(Duck()).bark()
}
注意:如果在Zoo中重写了代理接口中的方法,则会执行重写方法中的代码,不会再执行代理类中的方法了
Kotlin的动态代理会在编译以后将动态代理转换为**静态代理**以后来使用,所以Kotlin中的动态代理要比java中的效率高。java动态代理请参考Java 代理模式之静态代理与动态代理_袁震的博客-CSDN博客
3,密闭类
kotlin很少使用枚举类,通常使用更强大的密闭类。密闭类使用关键字sealed来定义
一个密闭类可以有多个子类,但是密闭类必须和其子类都在同一个kt文件中
密闭类可以有成员变量,但必须是abstract的
sealed class Fruit{
abstract var name:String
}
class Apple:Fruit(){
override var name: String = "Apple not good"
}
class Pear:Fruit(){
override var name: String = "Pear good"
}
fun echoFruitName(fruit:Fruit){
when(fruit){
is Apple -> println(fruit.name)
is Pear -> println(fruit.name)
}
}
fun main() {
echoFruitName(Pear())
echoFruitName(Apple())
}
4,泛型
5,init代码块
init代码块会在类每次实例化时都执行一次,执行顺序为 主构造>init代码块>次级构造,因此可以在init代码块中执行一部分主构造中无法执行的逻辑代码。
class People(var name:String){
constructor(name:String, age:Int):this(name){
println("in constructor")
}
init {
name = name + "00"
println("in init block name = $name")
}
}
fun main(){
People("zhangsan", 123)
}
结果:
in init block name = zhangsan00
in constructor
6,lateinit 修饰符
Kotlin中类的属性必须初始化,否则编译器会报错。为了让大家更适应类似Java中的写法,Kotlin提供了一个关键字lateinit,可以告诉编译器稍后我会初始化这个字段。但是需要注意:如果这个属性没有初始化就使用的话,会报空指针异常
7,扩展函数,扩展属性
Kotlin中可以给一个类扩展它的成员方法或成员变量,常用于扩展系统内置库、三方SDK等不受控的类
无论是Kotlin中的类,还是Java中的类,kotlin都可以对他们的成员方法进行扩展
fun 被扩展方法的类名.扩展方法名(参数列表):返回值 = 实现{ 函数体 }
class TestKtClass{
}
fun TestKtClass.echoMsg(str:String) = println(str)
fun TestKtClass.getStrValue(str1:String, str2:String):Int{
return (str1+str2).length
}
fun main(){
TestKtClass().echoMsg("12345")
println(TestKtClass().getStrValue("12345", "000"))
}
注意点:
1.扩展函数时静态的给一个类添加成员方法,不具备运行时多态效应
2.扩展函数和类内部定义的成员函数重名时,执行的是类的成员函数
扩展属性和扩展函数类似,
var 类名.属性名称:类型
get(){
}
set(value){
}
var StringBuilder.firstLetter:Char
get(){
return get(0)
}
set(value){
this.setCharAt(0, value)
}
fun main(){
println(StringBuilder("123456").firstLetter)
}
8,静态对象
使用关键字object定义的对象是静态对象,此对象类似于静态对象仅能被实例化一次,相当于单例并且线程安全
object类不能有构造函数
object TestObj{
fun echoName(){
}
}
fun main(){
TestObj.echoName()
}
在kotlin中调用object对象的方法,使用类名.方法名调用
在Java中调用object对象的方法,使用类名.INSTANCE.方法名调用
TestObj.INSTANCE.echoName();
9,伴生对象
伴生对象使用companion object关键字定义,并且仅能在一个类的内部使用,因此才叫伴生对象,伴生对象中的方法和属性都是相当于静态(并不是真正的静态,而是包含在一个静态实例中)的。
class TestCompanionObj{
companion object{
fun echoMsg(){
println("111111111111111111")
}
}
}
与object类似,在kotlin中使用类名.方法名调用, 在Java中使用类名.Companion.方法名调用
//kotlin
TestCompanionObj.echoMsg()
//java
TestCompanionObj.Companion.echoMsg();
10,幕后字段
幕后字段用关键字field表示,仅能用在get和set方法中使用。在Kotlin中,field这个字段代表这个属性本身,与class中的this相似。
需要注意的是:在get和set方法中,一定不要使用属性本身。因为一旦使用属性本身会被再次展开为get和set方法,造成无限递归,最终引发stack over flow。如果要使用属性(无论读或者写),一定使用幕后字段。
class Test{
var name = ""
set(value) {
//错误的示范,在set使用了name属性本身,应该使用field
name = value
}
}
class Test{
var name = ""
private set(value) {
field = value
}
}
11,常用的集合操作符
**元素操作类**
- contains :判断是否有指定元素
- elementAt:返回对应元素,越界会抛出IndexOutOfBoundsException
- firstOrNull:返回符合条件的第一个元素,没有返回null
- lastOrNull:返回符合提交的最后一个元素,没有返回null
- indexOf:返回指定元素的下标,没有返回-1
- singleOrNull:返回符合条件的单个元素,如果没有符合或超过1个,返回Null
**判断类**
- any:判断集合中是否有满足条件的元素
- all:判断集合中的元素是否都满足条件
- none:判断集合中是否都不满足条件
- count:查询集合中满足条件的个数
- reduce:从第一项累加到最后一项
**过滤类**
- filter:过滤所有满足条件的元素
- filterOrNot:过滤所有不满足条件的元素
- filterNotNull:过滤NULL元素
- take:返回前N个元素
**转换类**
- map:转换成另外一个集合
- mapIndexed:转换成另外一个集合,还可以拿下标
- mapNotNull:执行转换前先过滤掉为NULL的元素
- flatMap:自定义逻辑合并两个集合
- groupBy:按照某个条件分组,返回map
**排序类**
- reversed:反序
- sorted:升序
- sortedBy:自定义排序
- sortedDescending:降序
12,运算符重载与中缀表达式
运算符重载要使用关键字operator,重载运算符有一个要求:只能重载Kotlin中定义好的运算符。
operator 将一个函数标记为重载一个操作符或者实现一个约定。运算符重载就是对已有的运算符赋予他们新的含义。
Kotlin中的 && 、 || 、 ?: 、 === 、 !== 是不能被重载的
data class Person(var name: String, var age: Int)
operator fun Int.plus(b: Person): Int {
return this - b.age
}
fun main() {
val person1 = Person("A", 3)
val testInt = 5
println("testInt+person1=${testInt +person1}")
}
输出结果
testInt+person1=2
运算符在Kotlin中是有数量上限的,当kotlin中已有的运算符不能满足我们使用的时候,我们需要对运算符进行扩展,这里就用到了中缀表达式(如step),定义中缀表达式使用关键字:infix
infix 类型.函数() 是中缀函数的声明形式,就是扩展函数前面使用了indfix关键字,函数签名的类型,称为函数的接收者类型,换言之只有该类型才能调用这个函数。
中缀也可以被通过正常的函数调用来使用:类对象.中缀函数()
sealed class CompareResult{
object More : CompareResult(){
override fun toString(): String {
return "大于"
}
}
object Less : CompareResult(){
override fun toString(): String {
return "小于"
}
}
object Equal : CompareResult(){
override fun toString(): String {
return "等于"
}
}
}
infix fun Int.vs(value : Int) : CompareResult =
if(this - value > 0){
CompareResult.More
}else if(this - value < 0){
CompareResult.Less
}else{
CompareResult.Equal
}
fun main(){
println(5 vs 6)
println(8.vs(7))
}
需要注意一点是,如果在一个类中重载了别的类的运算符,那么这个重载运算符仅能在这个类及其子类中使用,在这个类的外部、派生类、object修饰的类均不能使用
13,解构
kotlin允许将一个类拆解,并分别赋值。
class User(var name:String, var age:Int){
operator fun component1() = name //这里的operator是约定的意思,就是约定name是component1()
operator fun component2() = age
}
fun main(){
var(name, age) = User("111",2)
println("name = $name, age = $age")
}
解构常用于遍历MAP和List中,能够一次性拿到所有值
val map = mapOf("key1" to "value1", "key2" to "value2", 3 to "value3")
for((key, value) in map){
println("$key----------------$value")
}
//使用map的话可以直接拿 index和value,使用list必须使用withIndex()
val list = arrayListOf<String>("1", "2", "3", "4")
for((index, value) in list.withIndex()){
println("index = $index, value = $value")
}
14,typealias
这个类似于C/C++上面的typedef,将一个类映射到另一个类上,不同点C/C++是宏定义展开,在Kotlin中是完全映射。用于在跨平台上有一个更好的兼容性
Android JNI1--C语言基础_袁震的博客-CSDN博客
public typealias 别名 = 映射到的对象
//给File类创建了一个别明类TestFile, 使用TestFile与使用File是完全一样的
public typealias TestFile = File
这个特性被广泛运用在各种集合的定义中,比如Kotlin的HashMap其实就是映射的java的HashMap
@SinceKotlin("1.1") public actual typealias HashMap<K, V> = java.util.HashMap<K, V>
15,Callback
public interface JavaCallback {
void show(String info);
}
public class JavaManager {
public void setCallback(JavaCallback javaCallback) {
javaCallback.show("yuanzhenjava");
}
}
interface KTCallback {
fun show(name: String)
}
class KtManager {
fun setCallback(callback: KTCallback) {
callback.show("yuanzhen")
}
}
kotlin调用java CallBack:
//第一种写法
JavaManager().setCallback(JavaCallback {
println(it)
})
// 第二种写法
JavaManager().setCallback(object : JavaCal
override fun show(info: String?) {
println(info)
}
})
// 第三种写法
val callback = JavaCallback {
println(it)
}
JavaManager().setCallback(callback)
// 第四种写法
val callback2 = object : JavaCallback{
override fun show(info: String?) {
println(info)
}
}
JavaManager().setCallback(callback2)
kotlin调用kotlin CallBack
//第一种写法
KtManager().setCallback(object : KTCallback{
override fun show(name: String) {
}
})
// 第二种写法
val c = object : KTCallback{
override fun show(name: String) { }
}
KtManager().setCallback(c)
16,Lambda表达式
最基本的lambda表达式格式:
val lambda表达式名称 : (参数类型,...) -> (返回值类型)={参数名称,... -> 函数实现(返回值)}
val lambda闭包名称 = { 参数名称:类型 -> 函数实现(返回值) }
调用:
闭包名称.invoke(参数列表)
闭包名称(参数列表)
下面来看使用:
这种情况不能调用,因为没有具体的实现,但是可以定义
再来看这种情况:
val method2 :(Int, Int)-> Int
method2(1,2)
这种情况可以调用吗?
答案是不能,因为它虽然有入参和返回值,但是依然没有具体实现
再来看下面的例子:
val method : (Int,Int) ->Int ={a,b->a+b}
println("${method(1,2)}")
这种情况是可以调用的,并且输出3
因为它有具体的实现
下面来看一下lambda表达式的第二种写法:
val method3 ={a:Int ,b:Int ->a+b}
println("${method3.invoke(1,2)}")
println("${method3(2,3)}")
输出3 5
这种写法还可以自动转型:
val method4 ={a:Int ,b:Int ->a.toDouble()+b.toDouble()}
println("${method4(2,3)}")
输出5.0
:格式返回空的写法:
val method5 : (String,String) ->Unit ={a,b-> println("a:$a,b:$b") }
method5("yuan","zhen")
输出:a:yuan,b:zhen
再来看一个例子:
val method6 : (Int) ->String ={
when(it){
in 1 ..200 ->"在1到200 之间"
in 201 ..300 ->"在201到300之间"
else ->"在300以上"
}
}
println(method6(120))
输出:在1到200 之间
再来看一个最简洁的使用:
val method7 ={ println("method7") }
method7()
lambda表达式可以进行覆盖操作:
var method8 ={a:Int, b:Int -> println("$a,$b") }
method8 ={ a:Int, b:Int ->println("覆盖了") }
method8(1,2)
输出:覆盖了
如果想要打印,并且想要返回值,怎么操作?
var method9 ={a:Int -> println("$a")
a
}
println("结果:${method9(10)}")
输出:10 结果:10
会返回最后一行的结果,如果是空,返回Unit
Lambda闭包三原则:
①,如果lamdba闭包没有参数,可以省略箭头符号(仅写实现部分);如果lamdba仅有一个参数,可以省略声明,并在使用时使用`it`来代替
②,如果lambda闭包是函数的最后一个参数,则可以将大括号放到小括号(函数名称的小括号)外
③,如果函数只有一个参数并且这个参数是lambda,则可以省略小括号
下面来看一个例子:
val txt = findViewById<TextView>(R.id.txt)
txt.setOnClickListener(object :View.OnClickListener {
override fun onClick(v: View?) {
println("${v?.id}")
}
})
如果我们用lambda表达式来写的话:
txt.setOnClickListener({v->println("${v?.id}")})
如果使用原则①的话:
txt.setOnClickListener({println("${it?.id}")})
如果使用原则②的话:
txt.setOnClickListener(){println("${it?.id}")}
如果使用原则③的话:
txt.setOnClickListener{println("${it?.id}")}
17,高阶函数
函数的参数或者函数返回值是Lamdba闭包的函数,我们称之为高阶函数
Kotlin的高阶函数有点类似于C++的函数指针
光说字面意思,我们可能会有点懵,下面我们就来看一个简单的高阶函数用法:
拿一个简单的登录操作来说,正常写法是:
fun login(name:String,pwd :String):Boolean{
if (name == "yuanzhen" && pwd == "123") {
println("登陆成功")
return true
} else {
println("登录失败")
return false
}
}
val result =login("yuanzhen","123")
println(result)
输出登录成功 true
如果用高阶函数怎么来写呢?
fun login1(name: String,pwd: String, yy: (String,String)->Boolean){
yy(name,pwd)
}
login1("yuanzhen","123",{name,pwd ->
if (name == "yuanzhen" && pwd == "123") {
println("登陆成功")
true
} else {
println("登录失败")
false
}
})
输出:登录成功
这样使用起来比较麻烦,我们可以使用typealias来定义lambda参数名称
typealias LambdaMethod =(String,String)->Boolean
fun login2(name:String,pwd:String){
login1(name,pwd){name,pwd->
if (name == "yuanzhen" && pwd == "123") {
println("登陆成功")
true
} else {
println("登录失败")
false
}
}
}
fun login1(name: String,pwd: String, yy: LambdaMethod){
yy(name,pwd)
}
调用:
login2("yuanzhen","123")
下面我们来给一个万能的类型增加一个扩展函数
fun <T> T.outMethod(yy: T.() ->T){
println(yy())
}
val name ="yuanzhen"
val age =30
fun main() {
name.outMethod {
if(this =="yuanzhen"){
"22222"
}else{
"33333"
}
}
age.outMethod {
if(this ==30){
30
}else{
20
}
}
}
输出:22222 30
是不是有点懵?
下面我们来解释一下:
T.outMethod() 是一个扩展函数,yy: T.() ->T 是一个lambda表达式,作为参数,就是高阶函数了
T.()是一个匿名函数,就相当于this
println(yy())就相当于调用了参数yy
因为T是任意类型的,所以name和age都可以调用。
this在name中,就是"yuanzhen" 在age中,就是30。
再来看一个升级版的用法:
fun <T,R> T.outMethod1(yy: T.() ->R):R = yy()
val name1 =name.outMethod1 {
if(this=="yuanzhen"){
80
}else{
10
}
}
println("name1:$name1")
输出:name1:80
这个相当于给方法outMethod1增加了一个返回值,返回值与yy一样
下面继续升级:
fun <T,R> T.outMethode2(yy: T.(T) -> R):R =yy(this)
val name2 =name.outMethode2 {
println(this)
println(it)
200
}
println(name2)
输出:
yuanzhen
yuanzhen
200
所以,我们可以看到,在这里,this和it是一样的
上面的高阶函数,我们还可以链式调用
val name2 =name.outMethode2 {
println(this)
println(it)
200
}.outMethode2 {
100
}.outMethode2 {
"1111"
}
println(name2)
输出:
yuanzhen
yuanzhen
1111
下面我们来一个实战: 自定义一个线程
fun myThread(yy:() ->Unit) :Thread{
val thread =object :Thread(){
override fun run() {
super.run()
yy()
}
}
thread.start()
return thread
}
myThread {
name.outMethode2 {
println(this)
println(it)
200
}
}
关于高阶函数,就讲这么多,更多的是自己去敲,去想怎么使用,光看的话很容易蒙圈。
总结
kotlin的高阶用法差不多就是上面这些,关于协程,可以查看文章