当前位置： java函数的编写-matlab编写阶乘函数
本文是《Java 8 in Action》的阅读笔记，阅读大约需要5分钟。
有点冠冕堂皇的感觉，但这确实是我最近使用Lambda表达式的感受。 设计模式是对过去一些好的经验和套路的总结，但是好的语言特性可以让开发者不去思考这些设计模式。 常见的面向对象设计模式有策略模式、模板方法、观察者模式、责任链模式和工厂模式。 使用Lambda表达式（函数式编程思想）有助于避免面向对象开发中的那些固定代码。 下面我们选取了战略模式和责任链模式两个案例进行分析。
案例一：策略模式
当我们对一个问题有不同的解决方案，又不想让客户感知到这些解决方案的细节时，这种情况下就适合使用策略模式。 策略模式由三部分组成：
面向对象的思想
首先定义strategy接口，代表排序策略：
public interface ValidationStrategy {
boolean execute(String s);
}然后定义具体的实现类（即不同的排序算法）：
public class IsAllLowerCase implements ValidationStrategy {
@Override
public boolean execute(String s) {
return s.matches("[a-z]+");
}
}
public class IsNumberic implements ValidationStrategy {
@Override
public boolean execute(String s) {
return s.matches("\\d+");
}
}最后定义客户使用场景，代码如下图所示。 Validator 是为客户提供服务时使用的上下文环境。 每个 Valiator 对象都封装了一个特定的 Strategy 对象。 在实际工作中，我们可以通过更换具体的Strategy对象来升级客户服务，客户不需要升级。
public class Validator {
private final ValidationStrategy strategy;
public Validator(ValidationStrategy strategy) {
this.strategy = strategy;
}
/**
* 给客户的接口
*/
public boolean validate(String s) {
return strategy.execute(s);
}
}
public class ClientTestDrive {
public static void main(String[] args) {
Validator numbericValidator = new Validator(new IsNumberic());
boolean res1 = numbericValidator.validate("7780");
System.out.println(res1);
Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
boolean res2 = lowerCaseValidator.validate("aaaddd");
System.out.println(res2);
}}函数式编程思想
如果你用Lambda表达式来思考，你会发现ValidationStrategy是一个函数式接口（它也有和Predicate一样的函数描述），那么上面的实现类就不用定义了，直接替换成下面的代码java函数的编写，因为Lambda表达式内部对这些类进行了一定程度的封装。
public class ClientTestDrive {
public static void main(String[] args) {
Validator numbericValidator = new Validator((String s) -> s.matches("\\d+"));
boolean res1 = numbericValidator.validate("7789");
System.out.println(res1);
Validator lowerCaseValidator = new Validator((String s) -> s.matches("[a-z]+"));
boolean res2 = lowerCaseValidator.validate("aaaddd");
System.out.println(res2);
}
}案例 2：责任链模式
在某些场景下，需要对一个对象做一系列的工作，而这些工作是由不同的类来完成的。 这时候使用责任链模型就比较合适了。 责任链模式的主要组成部分包括三个：
面向对象的思想
首先，我们在这里定义一个抽象类ProcessingObject，其中的successor字段用于管理该对象的后续操作对象； handle接口作为对外提供服务的接口； handleWork作为实际处理对象的操作方法。
public abstract class ProcessingObject{
protected ProcessingObjectsuccessor;public void setSuccessor(ProcessingObjectsuccessor) {
this.successor = successor;
}
public T handler(T input) {
T r = handleWork(input);
if (successor != null) {
return successor.handler(r);
}
return r;
}
abstract protected T handleWork(T input);
}接下来，您可以定义两个具体的操作对象，如下代码所示。 PS：此处不宜使用《Java 8实战》一书中的replaceAll方法。 关于这一点，可以参考我们之前的文章——[#rd](#rd)。
public class HeaderTextProcessing extends ProcessingObject{
@Override
protected String handleWork(String input) {
return "From Raoul, Mario and Alan: " + input;
}
}
public class SpellCheckerProcessing extends ProcessingObject{
@Override
protected String handleWork(String input) {return input.replace("labda", "lambda");
}
}最后，可以在Client中将以上两个具体的操作类对象组合成一个操作序列，见如下代码：
public class Client {
public static void main(String[] args) {
ProcessingObjectp1 = new HeaderTextProcessing();
ProcessingObjectp2 = new SpellCheckerProcessing();
p1.setSuccessor(p2);
String result = p1.handler("Aren't labdas really sexy?!!");
System.out.println(result);
}
}函数式编程思想
如果用函数式编程思维，那么责任链模式就很简单了——y=f(x)和z=g(x)这两个方法都需要处理x，所以如果把这两个函数组合在一起，就会形成r=f(g(x))的情况，即Lambda表达式中的addThen可以用来串联多个处理进程。
public class ClientWithLambda {
public static void main(String[] args) {
UnaryOperatorheaderProcessing = (String text) -> "From Raoul, Mario and Alan: " + text;
UnaryOperatorspellCheckProcessing = (String text) -> text.replace("labda", "lambda");
Functionfunction = headerProcessing.andThen(spellCheckProcessing);
String result = function.apply("Aren't labdas really sexy?!!");System.out.println(result);
UnaryOperatorhhhhhProcessing = (String text) -> text.concat("hhhh");
Functionfunction1 = function.andThen(hhhhhProcessing);
String result1 = function1.apply("Aren't labdas really sexy?!!");
System.out.println(result1);
}
}以上就是使用Java原生的Lambda表达式实现的责任链模型。 我们也可以使用上一篇文章介绍的vavr库——[#rd](#rd)。 代码如下：
public class ClientWithVavr {
public static void main(String[] args) {
Function1headerProcessing = (String text) -> "From Raoul, Mario and Alan: " + text;
Function1specllCheckProcessing = (String text) -> text.replace("labda", "lambda");
Function1function = headerProcessing.compose(specllCheckProcessing);
String result = function.apply("Aren't labdas really sexy?!!");
System.out.println(result);
}
}总结
可见，函数式编程思维不同于面向对象编程思维，具有更强的表达能力。 因此，作为开发者java函数的编写，是时候认真学习一下函数式编程思想了。 作为一名 Java 开发者，我打算先从学习 Lambda 表达式开始，然后尝试学习 Scala 或 Kotlin 中的函数式编程特性。
参考
《Java编程实战》《设计模式之禅》
***本期围绕后端技术、JVM排查与优化、Java面试题、个人成长与自我管理等话题，为读者提供一线开发者的工作与成长经验。 希望你能在这里有所收获。
上一篇 
