Kotlin与java8的SAM转换 Kotlin与java8的SAM转换对比(进阶)

时间:2021-04-22 DK_BurNIng 人气:0

什么是sam 转换

Single Abstract Method 实际上这是java8中提出的概念，你就把他理解为是 一个方法的接口的就可以了

看一下我们每天都在使用的线程池

ExecutorService executorService= Executors.newScheduledThreadPool(3);

  executorService.execute(new Runnable() {
   @Override
   public void run() {
    System.out.println("hello world");
   }
  });

用下面的java8中的lambda 来写也是可以的。

xecutorService.execute(()->System.out.println("hello world"));

所以说这两种写法是等价的。但是这里要强调的是 java中的lambda是没有类型的，所以他必须需要一个接口来接受他。

kotlin中的sam

 val executorService: ExecutorService = Executors.newScheduledThreadPool(3)
 //kotlin中的 匿名内部类的标准写法
 executorService.submit(object :Runnable{
  override fun run() {
   System.out.println("hello world")
  }
 })

kotlin中的lambda 这里可以这么写

executorService.submit { System.out.println("hello world") }

这里要注意的是 java的lambda是没有类型的，但是kotlin的lambda有类型 。

上文中的例子这个kotlin的lambda的类型就是 ()->Unit 是一个没有参数也没有返回值的类型

对于kotlin中的lambda来说，仔细看上面的图就可以知道。

这里实际上是创建了一个runnable 并且在这个runnable里面 包装了一下lambda，并不是直接转换的 。

//kotlin中 匿名内部类 还可以这么写
 executorService.submit(Runnable { println("hello world") })

上面的代码我们再解释一下，kotlin的编译器再遇到上面的代码的时候实际上是 帮我们生成了一个函数

这个函数的作用就是接收一个 lambda表达式然后帮我们生成对应的代码

kotlin中sam 转换的坑

java中的lambda是假的，只是一个sam而已。 kotlin的lambda是真的，只不过他还支持sam。是支持sam转换的。

下面定义一个kotlin的接口以及kotlin的方法

interface Invokable{
 fun invoke()
}


fun submit(invokable: Invokable){
 invokable.invoke()
}

然后我们看看调用：

看看报错的原因

Type mismatch: inferred type is () -> Unit but Invokable was expected

提示我们这里是需要一个invokable，但是给了一个lambda ，不符合要求，所以编译不能通过。

这个可以理解吧，前面已经讲过了。

fun submit2(block:()->Unit){
 block.invoke()
}

如果我们定义一个这样的函数那显然就是可以的了。就可以直接使用lambda了。

当然如果每次这么写，函数参数也比较难写，所以我们干脆就起个别名

typealias Funtionx = () -> Unit

fun submit2(block: Funtionx) {
 block.invoke()
}

另外就是在kotlin中使用sam转换的时候一定要小心remove的写法，例如：

我们定义一个简单的event类：

public class EventManager {
 interface OnEventListener {
  void onEvent(int event);
 }

 private List<OnEventListener> onEventListeners=new ArrayList<OnEventListener>();

 public void addOnEventListener(OnEventListener listener){
  onEventListeners.add(listener);
 }

 public void removeEventListener(OnEventListener listener){
  onEventListeners.remove(listener);
 }
}

现在 kotlin代码我们要add 一个监听

 val eventManager = EventManager()
 eventManager.addOnEventListener {
  println("onEvent$it")
 }

lambda写起来很方便，但是你要小心了，你这么写的话你是没办法remove的。你仔细想一想，上面的写法等于是

 eventManager.addOnEventListener(object : EventManager.OnEventListener {
  override fun onEvent(event: Int) {
   {
    println("onEvent$event")
   }()
  }
 })

也等于是

 eventManager.addOnEventListener(object : EventManager.OnEventListener {
  override fun onEvent(event: Int) {
   println("onEvent$event")
  }
 })

这个创建匿名对象的过程被编译器做了，你是接触不到这个object的。

所以自然也就没办法去remove了。

遇到这种需要remove的情况我们就可以用如下写法：

 val onEvent = EventManager.OnEventListener {
  println("onEvent$it")

 }

 eventManager.addOnEventListener(onEvent)
 eventManager.removeEventListener(onEvent)

或者

val onEvent2 = object : EventManager.OnEventListener {
  override fun onEvent(event: Int) {
   println("onEvent$event")
  }
 }

这种写法虽然丑是丑了一点，但是言简意赅，不会出歧义也不会出错。

加载全部内容