打破代码复杂度迷宫：抛弃if/else的N种策略

2023-11-14 12:19:56

甩掉if-else，提升代码质量：探索多种优化方案

简介

在软件开发领域，效率至上，时间就是金钱。为了追求开发速度，我们常常忽略代码的可读性与扩展性，而if-else条件判断则成为了一种简单粗暴的代码复用利器。然而，当代码中充斥着大量的if-else时，程序的可读性与可维护性就会大幅下降。为了打破代码复杂度的迷宫，本文将探讨多种优化方案，帮助您抛弃if/else，提升代码质量。

抽取策略：让代码更简洁

抽取策略是指将重复或相似的代码片段提取出来，形成一个独立的方法或函数，然后在需要的时候调用它。这样做的好处是提高了代码的复用性和可读性，减少了代码的重复率，降低了代码的复杂度，同时还能提升代码的维护性。

代码示例：

// 原始代码
if (condition1) {
    // do something
} else if (condition2) {
    // do something else
} else if (condition3) {
    // do something else again
}

// 优化后的代码
private void handleCondition(boolean condition) {
    if (condition) {
        // do something
    }
}

// 调用抽取出的方法
handleCondition(condition1);
handleCondition(condition2);
handleCondition(condition3);

对象策略：让代码更直观

对象策略是指将不同的行为封装到不同的对象中，然后根据需要选择不同的对象来执行不同的操作。这样做的好处是提高了代码的可读性和可维护性，使代码更加直观和易于理解，同时也提高了代码的扩展性，便于添加新的行为。

代码示例：

// 原始代码
if (type == "A") {
    // do something for type A
} else if (type == "B") {
    // do something for type B
} else if (type == "C") {
    // do something for type C
}

// 优化后的代码
public interface Shape {
    void draw();
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        // draw a rectangle
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        // draw a circle
    }
}

public class Triangle implements Shape {
    @Override
    public void draw() {
        // draw a triangle
    }
}

Shape shape = null;
switch (type) {
    case "A":
        shape = new Rectangle();
        break;
    case "B":
        shape = new Circle();
        break;
    case "C":
        shape = new Triangle();
        break;
}

shape.draw();

策略模式：让代码更灵活

策略模式是指将算法或行为封装到独立的类中，然后通过一个接口来调用这些类。这样做的好处是提高了代码的可读性和可维护性，使代码更加灵活和易于扩展，便于添加新的算法或行为。

代码示例：

// 原始代码
if (algorithm == "A") {
    // use algorithm A
} else if (algorithm == "B") {
    // use algorithm B
} else if (algorithm == "C") {
    // use algorithm C
}

// 优化后的代码
public interface Algorithm {
    void execute();
}

public class AlgorithmA implements Algorithm {
    @Override
    public void execute() {
        // implement algorithm A
    }
}

public class AlgorithmB implements Algorithm {
    @Override
    public void execute() {
        // implement algorithm B
    }
}

public class AlgorithmC implements Algorithm {
    @Override
    public void execute() {
        // implement algorithm C
    }
}

Algorithm algorithm = null;
switch (algorithmType) {
    case "A":
        algorithm = new AlgorithmA();
        break;
    case "B":
        algorithm = new AlgorithmB();
        break;
    case "C":
        algorithm = new AlgorithmC();
        break;
}

algorithm.execute();

状态模式：让代码更易维护

状态模式是指将一个对象的状态封装到独立的类中，然后通过一个接口来调用这些类。这样做的好处是提高了代码的可读性和可维护性，使代码更加易于理解和维护，便于添加新的状态。

代码示例：

// 原始代码
if (state == "A") {
    // do something for state A
} else if (state == "B") {
    // do something for state B
} else if (state == "C") {
    // do something for state C
}

// 优化后的代码
public interface State {
    void handle();
}

public class StateA implements State {
    @Override
    public void handle() {
        // handle state A
    }
}

public class StateB implements State {
    @Override
    public void handle() {
        // handle state B
    }
}

public class StateC implements State {
    @Override
    public void handle() {
        // handle state C
    }
}

State state = null;
switch (stateType) {
    case "A":
        state = new StateA();
        break;
    case "B":
        state = new StateB();
        break;
    case "C":
        state = new StateC();
        break;
}

state.handle();

责任链模式：让代码更具弹性

责任链模式是指将多个对象链接成一条链，当一个对象无法处理请求时，它就会将请求传递给下一个对象，依此类推，直到有对象能够处理该请求。这样做的好处是提高了代码的可读性和可维护性，使代码更加灵活和可扩展，便于添加新的处理程序。

代码示例：

// 原始代码
if (handlerA.canHandle(request)) {
    handlerA.handle(request);
} else if (handlerB.canHandle(request)) {
    handlerB.handle(request);
} else if (handlerC.canHandle(request)) {
    handlerC.handle(request);
}

// 优化后的代码
public interface Handler {
    boolean canHandle(Request request);

    void handle(Request request);
}

public class HandlerA implements Handler {
    @Override
    public boolean canHandle(Request request) {
        return request instanceof RequestA;
    }

    @Override
    public void handle(Request request) {
        // handle request A
    }
}

public class HandlerB implements Handler {
    @Override
    public boolean canHandle(Request request) {
        return request instanceof RequestB;
    }

    @Override
    public void handle(Request request) {
        // handle request B
    }
}

public class HandlerC implements Handler {
    @Override
    public boolean canHandle(Request request) {
        return request instanceof RequestC;
    }

    @Override
    public void handle(Request request) {
        // handle request C
    }
}

Handler handler = new HandlerA();
handler.setNextHandler(new HandlerB());
handler.setNextHandler(new HandlerC());

handler.handleRequest(request);