影落离风

The shadow falls away from the wind

0%

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

前言

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

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

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

最简单的线程使用示例

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

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

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

假如

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

步骤

  1. 按照Runnable创建接口 CollectResultInterface

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

    /**
    * 收集结果接口
    *
    * @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,去加载这个接口进行处理

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    /**
    * 计算方法
    *
    * @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. 测试方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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接口去加载

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    /**
    * 通用相加类
    *
    * @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. 测试方法

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

总结

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

资料

@FunctionalInterface函数注解使用

代码

上述代码路径