Java8-代码优化与设计模式

策略模式与lambda

策略模式

策略模式（Strategy Pattern）是一种行为设计模式，它使你能够在运行时更改算法。策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换。这种模式让算法独立于使用它的客户端。

策略模式包含三个主要组成部分：

1. 策略接口（Strategy Interface）：定义所有支持的算法的公共接口。
2. 具体策略（Concrete Strategies）：实现了策略接口的不同算法。
3. 上下文（Context）：使用策略接口，并在运行时委托给具体策略来完成实际的工作。

// 策略接口
public interface Strategy {
    void execute();
}

// 具体的实现
public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
    }
}
// 调用接口的准备
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}


// 客户端的调用 或者说 上下文调用
public class Client {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy(); 
      	// 输出：Executing strategy A

        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy(); 
      	// 输出：Executing strategy B
    }
}

lambda表达式的改进

上面例子中的Strategy就是一个函数接口，满足使用lambda表达式的前提。这意味着我们不需要声明新的类来实现不同的策略，通过直接传递Lambda表达式就能达到同样的目的(省去了写实现类的步骤)，并且还更简洁易懂：

// 客户端的调用 或者说 上下文调用
public class Client {
    public static void main(String[] args) {
        Context context = new Context(()->System.out.println("Executing strategy A"));
        context.executeStrategy(); 
      	// 输出：Executing strategy A

        context.setStrategy(()->System.out.println("Executing strategy A"));
        context.executeStrategy(); 
      	// 输出：Executing strategy B
    }
}

注意事项

尽管使用Lambda表达式简化了代码，但如果你的策略实现较为复杂，或者需要复用相同的策略实例，还是建议定义具体的策略类。Lambda表达式最适合用于简单的、一次性使用的策略实现。

模板方法与lambda

模板方法

模板方法模式ß（Template Method Pattern）是一种行为设计模式，它定义了一个算法的骨架，并将一些步骤延迟到子类去实现。模板方法模式允许子类重新定义算法中的某些步骤，而不改变算法的整体结构。更通俗一点讲就是，一个类，部分方法实现，部分方法不实现。

如果你需要采用某个算法的框架，同时又希望有一定的灵活度，能对它的某些部分进行改进，那么采用模板方法设计模式是比较通用的方案。

public abstract class Game {

    // 具体方法
    protected void initializeGame() {
        System.out.println("Initializing game...");
    }
  
    protected void endGame() {
        System.out.println("Game over!");
    }

    // 抽象方法
    protected abstract void playRound();
}


// 具体实现类
public class ChessGame extends Game {
    @Override
    protected void playRound() {
        System.out.println("Playing chess ing...");
        // 棋盘上的逻辑...
    }
}

public class CardGame extends Game {
    @Override
    protected void playRound() {
        System.out.println("Playing card ing...");
        // 扑克牌上的逻辑...
    }
}

// 应用
public class Client {
    public static void main(String[] args) {
        ChessGame chessGame = new ChessGame();
        chessGame.playGame(); // 输出：Initializing game..., Playing chess round..., Game over!

        CardGame cardGame = new CardGame();
        cardGame.playGame(); // 输出：Initializing game..., Playing card round..., Game over!
    }
}

可以看到，在上述的例子中抽象方法只有一个（为函数式接口），所以它也可以使用lambda表达式进行代码优化。

优化改进

但需要注意的是，跟策略模式有些不同，这里的抽象方法存在于类中，所以我们需要将其转换为一个函数式接口，并使用Lambda表达式来简化实现。

如果他有多个抽象方法，我们就无法对其lambda化。不过，如果你可以将其转换为一个抽象方法，仍可以使用。

public class Client {
    public static void main(String[] args) {
        ChessGame chessGame = ()-> System.out.println("Playing chess ing...");
        chessGame.playGame(); // 输出：Initializing game..., Playing chess round..., Game over!

        CardGame cardGame = new CardGame();
        cardGame.playGame(); // 输出：Initializing game..., Playing card round..., Game over!
    }
}

注意事项跟策略模式相同，lambda表达式只适用于简单逻辑的优化，对于复杂逻辑，还是老实继承类。