如何用Java Switch创建布尔条件？解决编译错误及实现需求

Hey there! Let's fix your code and build the reusable boolean condition structure you need, step by step.

First, Let's Squash That Compile Error #

The error unclosed character literal case '||': happens because a char type can only hold a single character, but '||' is two characters. On top of that, your code has a couple of variable mix-ups:

• You declared char select; but never assigned it, instead using an undeclared operator variable.
• Switching on a char can't work for multi-character operators like ||.

Refactoring to a Reusable Object-Oriented Structure #

Instead of just printing results, let's create a dedicated class to hold your boolean condition logic and results—this way other code can easily call and reuse it. Here's a complete, working example:

1. The BooleanCondition Class (Encapsulates Your Logic)

This class stores the operator, input values, and pre-calculates the boolean result. It provides getter methods so other code can access the result or a human-readable description.

class BooleanCondition {
    private final String operator;
    private final double firstValue;
    private final double secondValue;
    private final boolean result;

    // Constructor: Initialize and calculate result when creating an instance
    public BooleanCondition(String operator, double firstValue, double secondValue) {
        this.operator = operator;
        this.firstValue = firstValue;
        this.secondValue = secondValue;
        this.result = computeConditionResult();
    }

    // Private method to handle the boolean logic
    private boolean computeConditionResult() {
        return switch (operator) {
            case "-" -> firstValue < secondValue;
            case "+" -> firstValue > secondValue;
            case "||" -> firstValue == secondValue;
            default -> throw new IllegalArgumentException("Invalid operator: Use -, +, or ||");
        };
    }

    // Getters for other code to access the result and details
    public boolean getResult() {
        return result;
    }

    public String getConditionDescription() {
        return switch (operator) {
            case "-" -> firstValue + " is less than " + secondValue;
            case "+" -> firstValue + " is greater than " + secondValue;
            case "||" -> firstValue + " and " + secondValue + " are equal";
            default -> "Invalid operator provided";
        };
    }
}

2. The Main Class (Handles Input & Uses the Condition Object)

This part reads user input, creates a BooleanCondition instance, and shows how other code can use the object:

import java.util.Scanner;

public class ConditionGenerator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Get user input
        System.out.print("Enter operator (- for less than, + for greater than, || for equal): ");
        String operator = scanner.next();

        System.out.print("Enter two numbers (size and days): ");
        double size = scanner.nextDouble();
        double days = scanner.nextDouble();

        try {
            // Create the reusable condition object
            BooleanCondition userCondition = new BooleanCondition(operator, size, days);

            // Print the condition details and result
            System.out.println("\nCondition: " + userCondition.getConditionDescription());
            System.out.println("Boolean Result: " + userCondition.getResult());

            // Example: Pass the object to another method for further use
            processCondition(userCondition);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }

        scanner.close();
    }

    // Example method that uses the BooleanCondition object
    private static void processCondition(BooleanCondition condition) {
        if (condition.getResult()) {
            System.out.println("\nAction: The condition is true—running related logic!");
        } else {
            System.out.println("\nAction: The condition is false—taking alternative steps!");
        }
    }
}

Key Improvements & Fixes #

• Fixed the compile error: Switched from char to String for the operator, so we can handle || correctly.
• Reusable structure: The BooleanCondition object holds all relevant data and logic, so you can pass it to any other part of your code easily.
• Clean error handling: Uses exceptions to catch invalid operators and provides clear feedback.
• Readable code: Separates input handling, condition logic, and usage into distinct parts, making it easier to maintain.

内容的提问来源于stack exchange，提问作者Bilgin