零碎if else沉沉浮浮，代码王国再无宁静

2023-07-09 09:25:48

击败IF Else怪兽：8种替代方案，优化你的代码

简介

IF Else语句就像程序中的拦路虎，阻碍了前进的步伐，让代码的可读性和维护性大打折扣。以下介绍8种有效方法，让你告别IF Else的困扰，让代码运行更流畅，维护更轻松。

1. 条件语句：简洁易读，一网打尽

条件语句是一种更简洁、易读的IF Else替代方案。IF...ELSE IF...ELSE语句可用于处理多种情况，无需多个IF Else语句：

if (condition1) {
  // Do something
} else if (condition2) {
  // Do something else
} else {
  // Do something else again
}

2. Switch Case语句：精简明确，针对特定情况

Switch Case语句专门用于处理多个特定情况，比IF Else语句更精简、明确：

switch (expression) {
  case value1:
    // Do something
    break;
  case value2:
    // Do something else
    break;
  default:
    // Do something else again
    break;
}

3. 策略模式：算法解耦，代码更灵活

策略模式将算法或行为封装成独立的类，实现算法和行为的解耦：

interface Strategy {
  void doSomething();
}

class ConcreteStrategyA implements Strategy {
  @Override
  public void doSomething() {
    // Do something
  }
}

class ConcreteStrategyB implements Strategy {
  @Override
  public void doSomething() {
    // Do something else
  }
}

class Client {
  private Strategy strategy;

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

  public void doSomething() {
    strategy.doSomething();
  }
}

public class Main {
  public static void main(String[] args) {
    Client clientA = new Client(new ConcreteStrategyA());
    clientA.doSomething();

    Client clientB = new Client(new ConcreteStrategyB());
    clientB.doSomething();
  }
}

4. 状态模式：对象状态，灵活多变

状态模式将对象状态封装成独立的类，实现对象状态的灵活变化：

interface State {
  void doSomething();
}

class ConcreteStateA implements State {
  @Override
  public void doSomething() {
    // Do something
  }
}

class ConcreteStateB implements State {
  @Override
  public void doSomething() {
    // Do something else
  }
}

class Context {
  private State state;

  public Context(State state) {
    this.state = state;
  }

  public void doSomething() {
    state.doSomething();
  }
}

public class Main {
  public static void main(String[] args) {
    Context context = new Context(new ConcreteStateA());
    context.doSomething();

    context = new Context(new ConcreteStateB());
    context.doSomething();
  }
}

5. 命令模式：请求封装，解耦调用

命令模式将请求封装成独立的对象，实现请求和调用之间的解耦：

interface Command {
  void execute();
}

class ConcreteCommandA implements Command {
  @Override
  public void execute() {
    // Do something
  }
}

class ConcreteCommandB implements Command {
  @Override
  public void execute() {
    // Do something else
  }
}

class Invoker {
  private Command command;

  public Invoker(Command command) {
    this.command = command;
  }

  public void invoke() {
    command.execute();
  }
}

public class Main {
  public static void main(String[] args) {
    Invoker invoker = new Invoker(new ConcreteCommandA());
    invoker.invoke();

    invoker = new Invoker(new ConcreteCommandB());
    invoker.invoke();
  }
}

6. 工厂方法模式：创建解耦，灵活多变

工厂方法模式将对象的创建过程封装成独立的类，实现对象的创建和具体实现之间的解耦：

interface Factory {
  Product createProduct();
}

class ConcreteFactoryA implements Factory {
  @Override
  public Product createProduct() {
    return new ConcreteProductA();
  }
}

class ConcreteFactoryB implements Factory {
  @Override
  public Product createProduct() {
    return new ConcreteProductB();
  }
}

abstract class Product {
  public abstract void doSomething();
}

class ConcreteProductA extends Product {
  @Override
  public void doSomething() {
    // Do something
  }
}

class ConcreteProductB extends Product {
  @Override
  public void doSomething() {
    // Do something else
  }
}

public class Main {
  public static void main(String[] args) {
    Factory factory = new ConcreteFactoryA();
    Product product = factory.createProduct();
    product.doSomething();

    factory = new ConcreteFactoryB();
    product = factory.createProduct();
    product.doSomething();
  }
}

7. 简单工厂模式：创建简化，一目了然

简单工厂模式通过一个简单的工厂类来创建不同的对象，实现对象的创建过程简化：

class Factory {
  public static Product createProduct(String type) {
    switch (type) {
      case "A":
        return new ConcreteProductA();
      case "B":
        return new ConcreteProductB();
      default:
        return null;
    }
  }
}

abstract class Product {
  public abstract void doSomething();
}

class ConcreteProductA extends Product {
  @Override
  public void doSomething() {
    // Do something
  }
}

class ConcreteProductB extends Product {
  @Override
  public void doSomething() {
    // Do something else
  }
}

public class Main {
  public static void main(String[] args) {
    Product product = Factory.createProduct("A");
    product.doSomething();

    product = Factory.createProduct("B");
    product.doSomething();
  }
}

8. 原型模式：克隆创建，高效便捷

原型模式通过克隆一个现有对象来创建新对象，实现对象创建过程的高效便捷：

class Product implements Cloneable {
  @Override
  public Product clone() throws CloneNotSupportedException {
    return (Product) super.clone();
  }

  public void doSomething() {
    // Do something
  }
}

public class Main {
  public static void main(String[] args) {
    Product product1 = new Product();
    Product product2 = product1.clone();

    product2.doSomething();
  }
}