匿名类简化多业务场景下处理相同逻辑的封装_相同的业务处理逻辑不一样-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_41187876/article/details/120907820

前言

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

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

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

最简单的线程使用示例

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

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

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

假如

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

步骤

按照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，多个接口不可以。

建一个计算类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;
    }
}

测试方法

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);

    }

通用处理方法可以实现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;
    }
}

测试方法

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

总结

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

资料

@FunctionalInterface函数注解使用

代码

上述代码路径

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