Java 中如何优化大量的 if...else...

柔光的暖阳◎ 2023-09-25 17:34 116阅读 0赞

## 策略模式（Strategy Pattern） ##

> 将每个条件分支的实现作为一个独立的策略类，然后使用一个上下文对象来选择要执行的策略。这种方法可以将大量的if else语句转换为对象之间的交互，从而提高代码的可维护性和可扩展性。

**示例：**

首先，我们定义一个接口来实现所有策略的行为：

public interface PaymentStrategy {
        void pay(double amount);
    }

接下来，我们定义具体的策略类来实现不同的支付方式：

public class CreditCardPaymentStrategy implements PaymentStrategy {
        private String name;
        private String cardNumber;
        private String cvv;
        private String dateOfExpiry;
     
        public CreditCardPaymentStrategy(String name, String cardNumber, String cvv, String dateOfExpiry) {
            this.name = name;
            this.cardNumber = cardNumber;
            this.cvv = cvv;
            this.dateOfExpiry = dateOfExpiry;
        }
     
        public void pay(double amount) {
            System.out.println(amount + " paid with credit card");
        }
    }
     
    public class PayPalPaymentStrategy implements PaymentStrategy {
        private String emailId;
        private String password;
     
        public PayPalPaymentStrategy(String emailId, String password) {
            this.emailId = emailId;
            this.password = password;
        }
     
        public void pay(double amount) {
            System.out.println(amount + " paid using PayPal");
        }
    }
     
    public class CashPaymentStrategy implements PaymentStrategy {
        public void pay(double amount) {
            System.out.println(amount + " paid in cash");
        }
    }

现在，我们可以在客户端代码中创建不同的策略对象，并将它们传递给一个统一的支付类中，这个支付类会根据传入的策略对象来调用相应的支付方法：

public class ShoppingCart {
        private List<Item> items;
     
        public ShoppingCart() {
            this.items = new ArrayList<>();
        }
     
        public void addItem(Item item) {
            this.items.add(item);
        }
     
        public void removeItem(Item item) {
            this.items.remove(item);
        }
     
        public double calculateTotal() {
            double sum = 0;
            for (Item item : items) {
                sum += item.getPrice();
            }
            return sum;
        }
     
        public void pay(PaymentStrategy paymentStrategy) {
            double amount = calculateTotal();
            paymentStrategy.pay(amount);
        }
    }

现在我们可以使用上述代码来创建一个购物车，向其中添加一些商品，然后使用不同的策略来支付：

public class Main {
        public static void main(String[] args) {
            ShoppingCart cart = new ShoppingCart();
     
            Item item1 = new Item("1234", 10);
            Item item2 = new Item("5678", 40);
     
            cart.addItem(item1);
            cart.addItem(item2);
     
            // pay by credit card
            cart.pay(new CreditCardPaymentStrategy("John Doe", "1234567890123456", "786", "12/22"));
     
            // pay by PayPal
            cart.pay(new PayPalPaymentStrategy("myemail@example.com", "mypassword"));
     
            // pay in cash
            cart.pay(new CashPaymentStrategy());
     
            //--------------------------或者提前将不同的策略对象放入map当中,如下
     
            Map<String, PaymentStrategy> paymentStrategies = new HashMap<>();
     
            paymentStrategies.put("creditcard", new CreditCardPaymentStrategy("John Doe", "1234567890123456", "786", "12/22"));
            paymentStrategies.put("paypal", new PayPalPaymentStrategy("myemail@example.com", "mypassword"));
            paymentStrategies.put("cash", new CashPaymentStrategy());
     
            String paymentMethod = "creditcard"; // 用户选择的支付方式
            PaymentStrategy paymentStrategy = paymentStrategies.get(paymentMethod);
     
            cart.pay(paymentStrategy);
     
        }
    }

## 工厂模式（Factory Pattern） ##

> 将每个条件分支的实现作为一个独立的产品类，然后使用一个工厂类来创建具体的产品对象。这种方法可以将大量的if else语句转换为对象的创建过程，从而提高代码的可读性和可维护性。

示例：

// 定义一个接口
    public interface StringProcessor {
        public void processString(String str);
    }
     
    // 实现接口的具体类
    public class LowercaseStringProcessor implements StringProcessor {
        public void processString(String str) {
            System.out.println(str.toLowerCase());
        }
    }
     
    public class UppercaseStringProcessor implements StringProcessor {
        public void processString(String str) {
            System.out.println(str.toUpperCase());
        }
    }
     
    public class ReverseStringProcessor implements StringProcessor {
        public void processString(String str) {
            StringBuilder sb = new StringBuilder(str);
            System.out.println(sb.reverse().toString());
        }
    }
     
    // 工厂类
    public class StringProcessorFactory {
        public static StringProcessor createStringProcessor(String type) {
            if (type.equals("lowercase")) {
                return new LowercaseStringProcessor();
            } else if (type.equals("uppercase")) {
                return new UppercaseStringProcessor();
            } else if (type.equals("reverse")) {
                return new ReverseStringProcessor();
            }
            throw new IllegalArgumentException("Invalid type: " + type);
        }
    }
     
    // 测试代码
    public class Main {
        public static void main(String[] args) {
            StringProcessor sp1 = StringProcessorFactory.createStringProcessor("lowercase");
            sp1.processString("Hello World");
            
            StringProcessor sp2 = StringProcessorFactory.createStringProcessor("uppercase");
            sp2.processString("Hello World");
            
            StringProcessor sp3 = StringProcessorFactory.createStringProcessor("reverse");
            sp3.processString("Hello World");
        }
    }

看起来还是有if...else,但这样的代码更加简洁易懂,后期也便于维护....

## 映射表（Map） ##

使用一个映射表来将条件分支的实现映射到对应的函数或方法上。这种方法可以减少代码中的if else语句，并且可以动态地更新映射表，从而提高代码的灵活性和可维护性。

示例：

import java.util.HashMap;
    import java.util.Map;
    import java.util.function.Function;
     
    public class MappingTableExample {
        private Map<String, Function<Integer, Integer>> functionMap;
     
        public MappingTableExample() {
            functionMap = new HashMap<>();
            functionMap.put("add", x -> x + 1);
            functionMap.put("sub", x -> x - 1);
            functionMap.put("mul", x -> x * 2);
            functionMap.put("div", x -> x / 2);
        }
     
        public int calculate(String operation, int input) {
            if (functionMap.containsKey(operation)) {
                return functionMap.get(operation).apply(input);
            } else {
                throw new IllegalArgumentException("Invalid operation: " + operation);
            }
        }
     
        public static void main(String[] args) {
            MappingTableExample example = new MappingTableExample();
            System.out.println(example.calculate("add", 10));
            System.out.println(example.calculate("sub", 10));
            System.out.println(example.calculate("mul", 10));
            System.out.println(example.calculate("div", 10));
            System.out.println(example.calculate("mod", 10)); // 抛出异常
        }
    }

## 数据驱动设计（Data-Driven Design） ##

将条件分支的实现和输入数据一起存储在一个数据结构中，然后使用一个通用的函数或方法来处理这个数据结构。这种方法可以将大量的if else语句转换为数据结构的处理过程，从而提高代码的可扩展性和可维护性。

示例：

import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Function;
     
    public class DataDrivenDesignExample {
        private List<Function<Integer, Integer>> functionList;
     
        public DataDrivenDesignExample() {
            functionList = new ArrayList<>();
            functionList.add(x -> x + 1);
            functionList.add(x -> x - 1);
            functionList.add(x -> x * 2);
            functionList.add(x -> x / 2);
        }
     
        public int calculate(int operationIndex, int input) {
            if (operationIndex < 0 || operationIndex >= functionList.size()) {
                throw new IllegalArgumentException("Invalid operation index: " + operationIndex);
            }
            return functionList.get(operationIndex).apply(input);
        }
     
        public static void main(String[] args) {
            DataDrivenDesignExample example = new DataDrivenDesignExample();
            System.out.println(example.calculate(0, 10));
            System.out.println(example.calculate(1, 10));
            System.out.println(example.calculate(2, 10));
            System.out.println(example.calculate(3, 10));
            System.out.println(example.calculate(4, 10)); // 抛出异常
        }
    }