java 如何去掉if else

在Java中去掉if else的几种方法包括：使用多态、策略模式、函数式编程、switch语句、映射表、责任链模式。 其中，使用策略模式是一种非常有效的方法，它可以将条件分支逻辑封装在不同的策略类中，通过上下文类动态选择策略，从而避免冗长的if-else结构。策略模式不仅能提高代码的可读性和可维护性，还能很方便地添加新的策略而不影响现有代码。

一、使用多态

多态是一种面向对象编程的特性，它允许子类实现父类的抽象方法。当我们有多个if-else分支，每个分支都调用不同的方法时，可以考虑使用多态。

1.1 示例

假设我们有一个计算不同形状面积的程序：

abstract class Shape {
    abstract double area();
}
class Circle extends Shape {
    double radius;
    Circle(double radius) {
        this.radius = radius;
    }
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}
class Rectangle extends Shape {
    double length, width;
    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    double area() {
        return length * width;
    }
}
public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle(5);
        System.out.println("Area: " + shape.area());
        shape = new Rectangle(4, 5);
        System.out.println("Area: " + shape.area());
    }
}

二、使用策略模式

策略模式是一种行为设计模式，它将一组行为封装成独立的类，使得这些行为可以相互替换。策略模式使得算法可以在不影响客户端的情况下发生变化。

2.1 示例

假设我们有一个计算不同折扣的程序：

interface DiscountStrategy {
    double applyDiscount(double price);
}
class NoDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price;
    }
}
class SeasonalDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.9;
    }
}
class ClearanceDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.5;
    }
}
class ShoppingCart {
    private DiscountStrategy discountStrategy;
    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }
    public double checkout(double price) {
        return discountStrategy.applyDiscount(price);
    }
}
public class Main {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.setDiscountStrategy(new SeasonalDiscount());
        System.out.println("Total: " + cart.checkout(100));
        cart.setDiscountStrategy(new ClearanceDiscount());
        System.out.println("Total: " + cart.checkout(100));
    }
}

三、使用函数式编程

Java 8 引入了函数式编程特性，例如 Function 接口和 lambda 表达式，可以用来简化代码逻辑，减少if-else结构。

3.1 示例

假设我们有一个根据用户类型计算折扣的程序：

import java.util.function.Function;
public class Main {
    public static void main(String[] args) {
        Function<Double, Double> noDiscount = price -> price;
        Function<Double, Double> seasonalDiscount = price -> price * 0.9;
        Function<Double, Double> clearanceDiscount = price -> price * 0.5;
        double price = 100;
        String userType = "seasonal";
        Function<Double, Double> discountStrategy;
        switch (userType) {
            case "seasonal":
                discountStrategy = seasonalDiscount;
                break;
            case "clearance":
                discountStrategy = clearanceDiscount;
                break;
            default:
                discountStrategy = noDiscount;
        }
        System.out.println("Total: " + discountStrategy.apply(price));
    }
}

四、使用映射表

映射表是一个将键映射到值的数据结构，如 HashMap。它可以用来替代复杂的if-else结构，通过查找表来决定需要执行的逻辑。

4.1 示例

假设我们有一个根据操作符执行不同计算的程序：

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
public class Main {
    public static void main(String[] args) {
        Map<String, BiFunction<Double, Double, Double>> operations = new HashMap<>();
        operations.put("+", (a, b) -> a + b);
        operations.put("-", (a, b) -> a - b);
        operations.put("*", (a, b) -> a * b);
        operations.put("/", (a, b) -> a / b);
        double a = 10;
        double b = 5;
        String operator = "+";
        BiFunction<Double, Double, Double> operation = operations.get(operator);
        if (operation != null) {
            System.out.println("Result: " + operation.apply(a, b));
        } else {
            System.out.println("Invalid operator");
        }
    }
}

五、使用责任链模式

责任链模式是一种行为设计模式，它将请求沿着处理者链传递，直到有一个处理者处理它。该模式可以动态地添加或删除处理者，减少条件判断。

5.1 示例

假设我们有一个处理不同类型请求的程序：

abstract class Handler {
    private Handler next;
    public Handler setNext(Handler next) {
        this.next = next;
        return next;
    }
    public void handle(Request request) {
        if (next != null) {
            next.handle(request);
        }
    }
}
class AuthHandler extends Handler {
    @Override
    public void handle(Request request) {
        if (request.isAuthenticated()) {
            super.handle(request);
        } else {
            System.out.println("Authentication failed");
        }
    }
}
class LoggingHandler extends Handler {
    @Override
    public void handle(Request request) {
        System.out.println("Logging request: " + request);
        super.handle(request);
    }
}
class BusinessHandler extends Handler {
    @Override
    public void handle(Request request) {
        System.out.println("Handling business logic");
    }
}
class Request {
    private boolean authenticated;
    public Request(boolean authenticated) {
        this.authenticated = authenticated;
    }
    public boolean isAuthenticated() {
        return authenticated;
    }
    @Override
    public String toString() {
        return "Request{" + "authenticated=" + authenticated + '}';
    }
}
public class Main {
    public static void main(String[] args) {
        Handler authHandler = new AuthHandler();
        Handler loggingHandler = new LoggingHandler();
        Handler businessHandler = new BusinessHandler();
        authHandler.setNext(loggingHandler).setNext(businessHandler);
        Request request = new Request(true);
        authHandler.handle(request);
    }
}

结论

通过本文，我们探讨了几种在Java中去掉if-else的方法，包括多态、策略模式、函数式编程、映射表和责任链模式。每种方法都有其适用场景和优缺点，选择哪种方法取决于具体的业务需求和代码结构。通过合理使用这些设计模式和编程技巧，可以提高代码的可读性、可维护性和扩展性。