kotlin 函数式接口和匿名接口、lambda

package com.example.blog

import java.util.ArrayList

//kotlin lambda作为函数参数时：
//1. 函数作为另外一个函数的形参，可以直接写()-> xxx的形式，不用额外再定义一个函数式接口
//2. 在调用时， 世界将形参替换成lambda.
//问题：那还有必要保留函数式接口么？

//函数式接口
fun interface Even{
    fun isEven(e: Int): Boolean
}
//非函数式接口
interface  Odd{
    fun isOdd(e: Int): Boolean
}

class MyNumbers{
    private val numberList = listOf(1,2,3,4,5,6,7,8,9)
    private val evenNumList = mutableListOf<Int>()
    private val oddNumList = mutableListOf<Int>()

    //传递一个函数第一种方式： 传递一个函数式接口
    fun getAllEven(predictor: Even): List<Int>{

        numberList.forEach {
            if (predictor.isEven(it)) {
                evenNumList.add(it)
            }
        }
        return evenNumList
    }
    //第二种方式，直接传递一个函数。这两种方式实质是一样的，只不过这种方式不需要额外在外部定义一个函数接口了，直接以匿名方式定义了一个接口，也就相当于直接传递了一个函数。
    fun getAllOdd(predictor: (Int) -> Boolean): List<Int>{
        numberList.forEach {
            if (predictor(it)) {
                oddNumList.add(it)
            }
        }
        return oddNumList
    }
}

fun main(){
    var myNumbers = MyNumbers()
//    for (i in myNumbers.getAllEven()) {
//        println(i)
//    }

  var evenPredictor = object : Even {
      override fun isEven(e: Int): Boolean {
          return e % 2 == 0
      }
  }
    //SAM 表示方法,只能用在fun interface修饰的接口
    val evenPredictor2 = Even{
        it % 2 == 0
    }
    //从调用方看，不管是函数接受接口还是函数，调用房都可以传lambda，间接印证传函数式接口和函数是一回事。
    var allEven = myNumbers.getAllEven(evenPredictor2)
    //另一种方式
    var allEven2 = myNumbers.getAllEven { it % 2 == 0 }
    println("The even numbers are: ")
    for (i in allEven) {
        println(i)
    }
    println("The odd numbers are: ")
    var allOdd = myNumbers.getAllOdd { it % 2 != 0 }
    for (i in allOdd) {
        println(i)
    }

}