Java Functional Programming
Java Functional Programming
前提
前两天看了Java的Functional接口，觉得很是好玩。然后今天在上TDD的课，然后有一个作业（等会聊），需求很简单，觉得用普通的面向对象写法没有什么进步，也觉得没啥意思。
于是尝试用Java写类似于函数式编程的方法去实现这个需求
需求
- 不超过8公里时每公里0.8元
- 超过8公里则每公里加收50%长途费
- 停车等待时加收每分钟0.25元
是不是感觉很简单，一会会就搞完了。我也是这么感觉的，想一想最近看的Java源码，试一试函数式的搞法。
普通实现
这里暂不关注测试，TDD是一定要先写测试的.
public class Taxi {
private static final double BASIC_UNIT_PRICE = 0.8;
private static final int NORMAL_DISTANCE = 8;
private static final double LONG_DISTANCE_UNIT_PRICE = BASIC_UNIT_PRICE * 0.5;
private static final double WAIT_TIME_UNIT_PRICE = 0.25;
// 需求一
private double getBasicFee(int distance) {
return distance * BASIC_UNIT_PRICE;
}
//需求二
private double getLongDistanceFee(int distance) {
return distance - NORMAL_DISTANCE <= 0 ? 0D : (distance - NORMAL_DISTANCE) * LONG_DISTANCE_UNIT_PRICE;
}
//需求三
private double getWaitTimeFee(int waitTime) {
return waitTime * WAIT_TIME_UNIT_PRICE;
}
// 计算方法
public double calculate(int distance, int waitTime) {
return getBasicFee(distance) + getLongDistanceFee(distance) + getWaitTimeFee(waitTime);
}
}
是不是很简答，一眼就能看明。这么做没问题，但是想一想，你工作要一直写这样的代码是不是很无聊，对于个人成长来说这相当于没成长呀。
这代码毕业生也能写出来，工作两年也写这代码？？？
纯函数式实现第一版
public class Taxi {
private static final double BASIC_UNIT_PRICE = 0.8;
private static final int NORMAL_DISTANCE = 8;
private static final double LONG_DISTANCE_UNIT_PRICE = BASIC_UNIT_PRICE * 0.5;
private static final double WAIT_TIME_UNIT_PRICE = 0.25;
// 需求一
private ToDoubleTripleIntFunction getBasicFee = (initValue, distance, any) -> initValue + distance * BASIC_UNIT_PRICE;
// 需求二
private ToDoubleTripleIntFunction getLongDistanceFee = (initValue, distance, any) ->
initValue + (distance - NORMAL_DISTANCE <= 0 ? 0D : (distance - NORMAL_DISTANCE) * LONG_DISTANCE_UNIT_PRICE);
// 需求三
private ToDoubleTripleIntFunction getWaitTimeFee = (initValue, any, waitTime) -> initValue + waitTime * WAIT_TIME_UNIT_PRICE;
public double calculate(int distance, int waitTime) {
return getBasicFee
.thenCompose(getLongDistanceFee)
.thenCompose(getWaitTimeFee)
.applyAsDouble(0D, distance, waitTime);
}
@FunctionalInterface
private interface ToDoubleTripleIntFunction {
double applyAsDouble(double f, int t, int u);
default ToDoubleTripleIntFunction thenCompose(ToDoubleTripleIntFunction next) {
return (double first, int second, int third) -> next.applyAsDouble(applyAsDouble(first, second, third), second, third);
}
}
纯函数实现第二版
第一版的写法有点硬， 因为所有的方法都是ToDoubleTripleIntFunction类型的，并且还有很多不需要的参数。
这一版优化了，所有的方法都是java基本方法，只是在使用的地方去组合成function的样子， 并且删除了其他方法不需要的参数列表， 用闭包的方式去传递 所需要的参数
// 需求一
private double getBasicFee(double initValue, int distance) {
return initValue + distance * BASIC_UNIT_PRICE;
}
// 需求二
private double getLongDistanceFee(double initValue, int distance) {
return initValue + (distance - NORMAL_DISTANCE <= 0 ? 0D : (distance - NORMAL_DISTANCE) * LONG_DISTANCE_UNIT_PRICE);
}
// 需求三
private double getWaitTimeFee(double initValue, int waitTime) {
return initValue + waitTime * WAIT_TIME_UNIT_PRICE;
}
public double calculate(int distance, int waitTime) {
// 这里组装函数流
ToDoubleBiIntFunction getBasicFee = this::getBasicFee;
return getBasicFee
// 这里用到了匿名方法
.thenCompose(this::getLongDistanceFee)
// 这里用到了闭包
.thenCompose((initValue, any) -> getWaitTimeFee(initValue, waitTime))
.applyAsDouble(0D, distance);
}
@FunctionalInterface
private interface ToDoubleBiIntFunction {
double applyAsDouble(double f, int t);
default ToDoubleBiIntFunction thenCompose(ToDoubleBiIntFunction next) {
return (double first, int second) -> next.applyAsDouble(applyAsDouble(first, second), second);
}
}
总结
函数式的第二版是在项目中实际使用的过程中，自己领悟和发现的。
第一版的函数式写法，大家表示很陌生，并且不愿意动，也不愿意写。
经过第二版的写法优化，和闭包的使用，大家觉得易读和简单，并且在新的流程中已经使用这种写法了。
