高阶函数在设计模式中应用广泛，包括：策略模式（使用高阶函数创建算法或行为）、模板方法模式（定义算法骨干）、观察者模式（定义观察者和被观察者接口）。在策略模式中，高阶函数允许更改算法而不影响现有代码；在模板方法模式中，高阶函数定义通用的算法骨干，由子类定制具体步骤；在观察者模式中，高阶函数定义观察者和被观察者接口，允许观察者订阅和取消订阅事件。
Java 函数式编程中高阶函数在设计模式中的应用
引言
函数式编程是一种编程范式，它专注于使用函数作为一等公民。高阶函数是函数式编程中一个重要的概念，它可以接收其他函数作为参数或返回另一个函数。在设计模式中，高阶函数可以简化代码，提高可读性和可维护性。
立即学习“Java免费学习笔记（深入）”；
高阶函数在设计模式中的应用
高阶函数可以在设计模式中完成各种任务，包括：
- 策略模式：策略模式使用高阶函数来创建各种算法或行为。这允许客户端在不改变现有代码的情况下更改算法。
- 模板方法模式：模板方法模式使用高阶函数来定义一个通用的算法骨干。子类可以通过实现具体步骤来定制算法。
- 观察者模式：观察者模式使用高阶函数来定义观察者和被观察者的接口。这允许观察者在不改变被观察者的前提下订阅和取消订阅事件。
实战案例
策略模式
// 策略接口
interface Strategy {
int doSomething(int a, int b);
}
// 具体策略
class AddStrategy implements Strategy {
@Override
public int doSomething(int a, int b) {
return a + b;
}
}
class MultiplyStrategy implements Strategy {
@Override
public int doSomething(int a, int b) {
return a * b;
}
}
// 策略模式上下文
class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public int doSomething(int a, int b) {
return strategy.doSomething(a, b);
}
}
// 主类
public class Main {
public static void main(String[] args) {
Context context = new Context(new AddStrategy());
System.out.println(context.doSomething(1, 2)); // 输出 3
context = new Context(new MultiplyStrategy());
System.out.println(context.doSomething(1, 2)); // 输出 2
}
}模板方法模式
// 抽象类
abstract class AbstractTemplate {
public void templateMethod() {
step1();
step2();
hook();
}
protected abstract void step1();
protected abstract void step2();
// 可选钩子方法
protected void hook() {}
}
// 具体子类
class ConcreteTemplate extends AbstractTemplate {
@Override
protected void step1() {
System.out.println("Step 1");
}
@Override
protected void step2() {
System.out.println("Step 2");
}
}
// 主类
public class Main {
public static void main(String[] args) {
ConcreteTemplate template = new ConcreteTemplate();
template.templateMethod();
// 输出：
// Step 1
// Step 2
}
}观察者模式
// 观察者接口
interface Observer {
void update(Object event);
}
// 被观察者接口
interface Observable {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers(Object event);
}
// 具体观察者
class ConcreteObserver implements Observer {
@Override
public void update(Object event) {
System.out.println("Received event: " + event);
}
}
// 具体被观察者
class ConcreteObservable implements Observable {
private List<Observer> observers = new ArrayList<>();
@Override
public void addObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(Object event) {
for (Observer observer : observers) {
observer.update(event);
}
}
}
// 主类
public class Main {
public static void main(String[] args) {
ConcreteObservable observable = new ConcreteObservable();
ConcreteObserver observer1 = new ConcreteObserver();
ConcreteObserver observer2 = new ConcreteObserver();
observable.addObserver(observer1);
observable.addObserver(observer2);
observable.notifyObservers("Hello!");
// 输出：
// Received event: Hello!
// Received event: Hello!
}
} 
