image.png

高内聚，低耦合。现在互联网体系经常提及的架构方案，目前很多框架也是遵从这个原则来实现整体的架构。而模块与模块之间的解耦也有很多方法。 回调函数，也是这样的一种方法。

关于回调函数，有这这样一个经典的例子。

有一天小王遇到一个很难的问题，问题是“1 + 1 = ?”，就打电话问小李，小李一下子也不知道，就跟小王说，等我办完手上的事情，就去想想答案，小王也不会傻傻的拿着电话去等小李的答案吧，于是小王就对小李说，我还要去逛街，你知道了答案就打我电话告诉我，于是挂了电话，自己办自己的事情，过了一个小时，小李打了小王的电话，告诉他答案是2

应用到具体的例子中，就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法。

首先，要定义一个接口

public interface Callback {
    public void solve();
}

image.png

• 首先，A有个问题，需要调用B的方法进行解决
• 然后B也不知道怎么解决，发现A中过来的方法有个方法实现了我们定义的接口，就去调用他。
• 然后就解决了问题。

简单的总结一下，就是我们本身去调用一个方法的时候，我们本身已经实现了具体的功能。然后让我们调用的方法，反过来调用我们的实现方法。这就是回调函数。

 public interface MyAdd{
        int addSolve(int a , int b);
    }

    // 解决1+1 等于几的函数
    public int OneAddOne(MyAdd myAdd){
        int a = 1;
        int b = 1;
       return myAdd.addSolve(a,b);
    }

    public void Tests(){
        /**
         * 现在我们这个方法有个需求，是解决1+1 等于几。
         * 然后我们自己定义的方法一加一等于几已经写好了
         * 但是，我们调用的是我们自己定义的接口，具体的实现还不知道。
         * 这时候，我们就需要把我们的实现一起带过去
         */
        int res = OneAddOne((a,b)->a+b);
        System.out.println(res);
        /**
         * 这样，我们就可以知道1+1等于几了，而带过去的lambda就是我们的回调函数
         * 我们调用OneAddOne方法，然后这个方法反过来调用我们带过去的具体实现
         * 这跟java8里面的行为参数化差不多
         */
    }

那我们为什么需要这样设计呢，就为了解决这个1+1这样简单的问题？
肯定不是啊，如果下次给你一个问题是2+2，3+3，你是不是都要还弄一个方法来具体的解决这个问题？如果我们把行为给参数化，再结合泛型的实现，基本上可以打造通用的模板实现。

public interface MyAdd<T>{
        T addSolve(T a , T b);
    }
    // 几加几的问题
    public <T> T OneAddOne(MyAdd<T> myAdd,T a,T b){
       return myAdd.addSolve(a,b);
    }

    public void Tests(){
        //1+1
        Integer res = OneAddOne((Integer a, Integer b) -> a + b, 1, 1);
        //2.2 + 2.2
        Double res1 = OneAddOne((Double a, Double b) -> a + b, 2.2, 2.2);
        
    }

再面对需求多变的时候，采用这样的方式，会让你的代码质量更上一层楼。

个人GitHub项目，记录学习Java知识的过程 欢迎star

image.png