前言
在平时开发中,经常会遇到很多业务都有相同的处理逻辑;但是具体的处理规则又各不相同。
那我们就可以把相同的方法提取出来,规则可由调用者自己编写。
其实说到这里,用Thread跑过线程的同学就知道了;run方法里编写自己要用的业务,最后调用start方法
最简单的线程使用示例
1 | new Thread(new Runnable() { |
但其实在阿里规约中不建议这样显式创建线程,建议使用线程池创建;
这里只是方便理解匿名内部类,所以才这样写。
假如
我要计算两个数的值,通用的有加减乘除,但有可能也有两个数相乘再减去某个数;
步骤
按照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
*/
public interface CollectResultInterface {
/**
* 获取接结果
*
* @param x
* @param y
* @return
*/
Integer process(Integer x, Integer y);
}注意:使用@FunctionalInterface注解,表名CollectResultInterface里面只能有一个接口,可以在调用的时候使用lambda写法;没有@FunctionalInterface注解,有一个接口也可以使用lambda,多个接口不可以。
建一个计算类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;
}
}测试方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public static void main(String[] args) {
// 实现接口的匿名类
// 自定义规则
new ComputeMethod("自定规则", new CollectResultInterface() {
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接口去加载
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;
}
}测试方法
1
2
3
4public static void main(String[] args) {
// 通用方法可单独提出来
new ComputeMethod("加", new CommonAddCollectResult()).exec(1, 3);
}
总结
- 对计算x、y的值,计算规则相同的可以使用通用类去执行;规则不同的由调用者自己实现。
- 上述示例为对匿名内部类最简单的使用示例;
- 我们要打开自己的格局,传进去执行的也可以是对象,经过内部处理返回另一个对象。
- 也可能要在process方法执行前后处理一些东西,都可以很方便的加进去。
- 也可以将CollectResultInterface类建为抽象类,对业务的执行做更深层次的封装复用