Java,Kotlin,Dart中实现回调的区别

实现回调首先要弄清楚几个概念： 匿名函数，Lambda表达式，函数类型，高阶函数

匿名函数：多数函数是有名字的， 也可以创建没有名字的函数，这种函数被称为 匿名函数。
Lambda表达式：匿名函数的另一种替代写法，被称为 lambda 或者 closure 。
函数类型 ：如果一个变量的类型是函数，那么这个变量是函数类型，
高阶函数：参数或者返回值可以是函数类型的函数

Java回调实现

Java 8中新增了Lambda表达式和函数可以作为值。Lambda表达式由参数、箭头和主体组成；函数作为值是，通过使用方法引用 :: 语法（即“把这个方法作为值”）来传递。Java 的Lambda表达式是在函数式接口上实现的，函数式接口就是只定义一个抽象方法的接口。不像Dart和Kotlin有函数类型，所以Java 实现回调很麻烦，需要先定义接口。如： Runnable接口

Runnable接口的实现：匿名函数写法或者Lambda表达式形式

new Runnable() {  
    public void run() {  
    //your code
        }  
}
//或者
() -> { //your code}

Java的Lambda的基本语法是

//单条语句
(parameters) -> expression
//或（多条语句）
(parameters) -> { statements; }

Java中回调的定义和回调的使用

	/*----回调定义----*/
    static class CallBackImp {
        interface CallBack {
            void callBack(int code, String msg);
        }

        void callBackMethod(CallBack callBack) {
            callBack.callBack(1, "msg");
        }
    }
    /*----回调使用----*/
        //回调用匿名类调用
        new CallBackImp().callBackMethod(new CallBackImp.CallBack() {
            @Override
            public void callBack(int code, String msg) {
                //your code
            }
        });
        //回调用lambda
        new CallBackImp().callBackMethod((code, msg) -> {
            //your code
        });

Kotlin回调实现

Kotlin的Lambda的基本语法是

{ [[Type] param1[, …]] ->
      codeBlock
 }

Kotlin中回调的定义

	/*----回调定义----*/
class CallBackImpByKotlin {
    interface CallBack {
        fun callBack(code: Int, msg: String)
    }

    //回调不能为空
    fun callBackMethod1(callBack: (code: Int, msg: String) -> Unit) {
        callBack.invoke(1, "msg")
    }

    //回调可以为空
    fun callBackMethod2(callBack: ((code: Int, msg: String) -> Unit)?) {
        callBack?.invoke(1, "msg")
    }

    //有返回值的回调
    fun callBackMethod3(callBack: ((code: Int, msg: String) -> Boolean)) {
        callBack.invoke(1, "msg")
    }

    fun callBackMethod4(callBack: CallBack) {
        callBack.callBack(1, "msg")
    }
}

Kotlin中回调的使用

//回调用lambda
CallBackImpByKotlin().callBackMethod1 { code, msg ->
    //your code
}
//有返回值的回调匿名函数写法
CallBackImpByKotlin().callBackMethod3(fun(code, msg): Boolean {
    return true
})
//有返回值的回调lambda写法
CallBackImpByKotlin().callBackMethod3 { code, msg ->
    return@callBackMethod3 true
}
//错误的匿类写法  ---------报错-------------
CallBackImpByKotlin().callBackMethod4(CallBackImpByKotlin.CallBack() {
    @Override
    fun callBack(code: Int, msg: String) {

    }
})
//不像java能用lambda代替匿名类 ---------报错-------------
CallBackImpByKotlin().callBackMethod4 { code, msg ->
    //your code
}
//是不是很抓狂，到底要我怎么写

//Kotlin匿名类的正确写法
CallBackImpByKotlin().callBackMethod4(object : CallBackImpByKotlin.CallBack {
    override fun callBack(code: Int, msg: String) {
        //your code
    }

})

Dart回调实现

Dart 的Lambda的基本语法是

([[Type] param1[, …]]) { 
  codeBlock; 
}; 

Dart 中回调的定义

//xx.dart文件
//typedef 只能定义在class CallBackImp外面，要在 top level；note:这个是为callBackMethod2中回调定义
typedef CallBack = void Function(int code, String msg);

class CallBackImp {
  ///通过var来实现回调
  void callBackMethod1(var callBack) {
    callBack(1, "msg");
  }

  ///通过typedef 定义Function 别名 来实现回调
  void callBackMethod2(CallBack callBack) {
    callBack(1, "msg");
  }

  ///通过定义函数类型
  void callBackMethod3(void callBack(int code, String msg)) {
    callBack(1, "msg");
  }

  ///callBackMethod3的另一种写法，返回值void可以省略不写，参数类型可以推断得出也可以省略不写
  void callBackMethod4(callBack(code, msg)) {
    callBack(1, "msg");
  }
}

Dart 中回调的使用

  new CallBackImp().callBackMethod1((int code, String msg) {
    //your code
  });

  new CallBackImp().callBackMethod2((int code, String msg) {
    //your code
  });
  new CallBackImp().callBackMethod3((int code, String msg) {
    //your code
  });

  //和上面的不同，不能加上具体的类型声明
  new CallBackImp().callBackMethod4((code, msg) {
    //your code
  });
  //或者
  new CallBackImp().callBackMethod4((var code, var msg) {
    //your code
  });

总结：主要区别是能否定义函数变量，Dart和Kotlin支持函数变量，Java8 不支持，回调的实现需要定义接口，不是很方便