匿名类简化多业务场景下处理相同逻辑的封装

前言

在平时开发中，经常会遇到很多业务都有相同的处理逻辑；但是具体的处理规则又各不相同。

那我们就可以把相同的方法提取出来，规则可由调用者自己编写。

其实说到这里，用Thread跑过线程的同学就知道了；run方法里编写自己要用的业务，最后调用start方法

最简单的线程使用示例

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 编写自己的业务
                System.out.println("线程测试");
            }
        }).start();

但其实在阿里规约中不建议这样显式创建线程，建议使用线程池创建；

这里只是方便理解匿名内部类，所以才这样写。

假如

我要计算两个数的值，通用的有加减乘除，但有可能也有两个数相乘再减去某个数；

步骤

1. 按照Runnable创建接口 CollectResultInterface

   /**
    * 收集结果接口
    *
    * @author MinWeikai
    * @date 2021/10/22 10:23
    */
   @FunctionalInterface
   public interface CollectResultInterface {
       /**
        * 获取接结果
        *
        * @param x
        * @param y
        * @return
        */
       Integer process(Integer x, Integer y);
   
   }

   注意：使用@FunctionalInterface注解，表名CollectResultInterface里面只能有一个接口，可以在调用的时候使用lambda写法；没有@FunctionalInterface注解，有一个接口也可以使用lambda，多个接口不可以。

2. 建一个计算类ComputeMethod，去加载这个接口进行处理

   /**
    * 计算方法
    *
    * @author MinWeikai
    * @date 2021/10/22 10:30
    */
   public class ComputeMethod {
   
       public ComputeMethod() {
       }
   
       public ComputeMethod(String name, CollectResultInterface collectResultInterface) {
           this.name = name;
           this.collectResultInterface = collectResultInterface;
       }
   
       /**
        * 方法名
        */
       private String name;
   
       private CollectResultInterface collectResultInterface;
   
       /**
        * 执行构建的方法
        * @param x
        * @param y
        */
       public void exec(Integer x, Integer y) {
           System.out.println("----------------开始-------------------");
           // 处理数据
           int result = collectResultInterface.process(x, y);
           System.out.println(x + " " + name + " " + y + " = " + result);
           System.out.println("----------------结束-------------------");
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public CollectResultInterface getCollectResultInterface() {
           return collectResultInterface;
       }
   
       public void setCollectResultInterface(CollectResultInterface collectResultInterface) {
           this.collectResultInterface = collectResultInterface;
       }
   }
   

3. 测试方法

   public static void main(String[] args) {
           // 实现接口的匿名类
           // 自定义规则
           new ComputeMethod("自定规则", new CollectResultInterface() {
               @Override
               public Integer process(Integer x, Integer y) {
                   // 业务加工过程
                   return x + y * x - y;
               }
           }).exec(14, 250);
   
           // lambda写法
           new ComputeMethod("自定规则", (x, y) -> (x * y) - x).exec(14250, 6);
   
       }

4. 通用处理方法可以实现CollectResultInterface接口去加载

   /**
    * 通用相加类
    *
    * @author MinWeikai
    * @date 2021/10/22 11:31
    */
   public class CommonAddCollectResult implements CollectResultInterface {
       @Override
       public Integer process(Integer x, Integer y) {
           return x + y;
       }
   }

5. 测试方法

   public static void main(String[] args) {
        // 通用方法可单独提出来
        new ComputeMethod("加", new CommonAddCollectResult()).exec(1, 3);
   }

总结

1. 对计算x、y的值，计算规则相同的可以使用通用类去执行；规则不同的由调用者自己实现。
2. 上述示例为对匿名内部类最简单的使用示例；
3. 我们要打开自己的格局，传进去执行的也可以是对象，经过内部处理返回另一个对象。
4. 也可能要在process方法执行前后处理一些东西，都可以很方便的加进去。
5. 也可以将CollectResultInterface类建为抽象类，对业务的执行做更深层次的封装复用

资料

@FunctionalInterface函数注解使用

代码

上述代码路径

本文由博客群发一文多发等运营工具平台 OpenWrite 发布