This tutorial will guide you on how to use do-while loop structures and user input in Java programs to achieve repeated execution or graceful exit of the program. Through an interactive calculator example, we will demonstrate how to effectively handle user instructions, manage input resources, and optimize code logic to ensure that the program has a good user experience and meets robustness requirements.

Core concept: do-while loop implements interactive control

When developing interactive programs, we often need the program to perform a specific operation at least once and then decide whether to continue based on the user's selection. The do-while loop structure is ideally designed for this type of scenario. Its characteristic is that the code in the loop body is executed first, and then the loop condition is evaluated. The loop continues as long as the condition is true; it terminates when the condition is false.

For the calculator program in this tutorial, the user will need to perform at least one calculation. After the calculation is complete, the program will ask the user whether to continue (enter 1) or exit (enter 0). The do-while loop can perfectly capture this "execute first, judge later" logic. We put all the calculation logic into the do block and use the instructions entered by the user as the basis for judging the while condition.

User input processing and resource management

In Java, the java.util.Scanner class is a common tool for obtaining user input (such as keyboard input). It provides multiple methods to read different types of data, such as nextInt() for reading integers and next() for reading strings.

When dealing with user input, resource management is especially important. Scanner objects consume system resources when they are created (for example, associated with an input stream). Failure to properly close these resources can lead to resource leaks, especially in large or long-running applications. The try-with-resources statement introduced in Java 7 is the recommended way to manage such closeable resources (classes that implement the AutoCloseable interface). It ensures that the resource will be automatically closed after the try block is executed (whether it ends normally or an exception occurs), thus avoiding the tediousness and omissions of manually calling the close() method.

Here is an example of an interactive calculator that uses a do-while loop and try-with-resources to manage a Scanner:

 import java.util.InputMismatchException;
import java.util.Scanner;

public class InteractiveCalculator {

    public static void main(String[] args) {
        int command; // Used to store user instructions: 0-exit, 1-continue//Use try-with-resources to ensure that Scanner resources are automatically closed try (Scanner scanner = new Scanner(System.in)) {
            do {
                try {
                    System.out.println("Please enter the first number: ");
                    int num1 = scanner.nextInt();

                    System.out.println("Please enter the second number: ");
                    int num2 = scanner.nextInt();

                    System.out.println("Please select operation ( , -, *, /): ");
                    String operation = scanner.next();

                    System.out.print("Calculation result: ");
                    //Use switch statement to process different operators switch (operation) {
                        case " ":
                            System.out.println(num1 num2);
                            break;
                        case "-":
                            System.out.println(num1 - num2);
                            break;
                        case "*":
                            System.out.println(num1 * num2);
                            break;
                        case "/":
                            if (num2 != 0) { // Avoid divide-by-zero errors System.out.println((double) num1 / num2); // Cast to double for floating point result} else {
                                System.out.println("Error: divisor cannot be zero!");
                            }
                            break;
                        default:
                            System.out.println("Error! Invalid operator.");
                    }
                } catch (InputMismatchException e) {
                    System.out.println("Input error: Please enter a valid number.");
                    scanner.next(); // Clear incorrect input to prevent infinite loop} catch (Exception e) {
                    System.out.println("An unknown error occurred: " e.getMessage());
                }

                System.out.println("\nPlease enter '1' to continue calculation, enter '0' to exit the program:");
                // Ensure user input is an integer and handle possible non-integer input while (!scanner.hasNextInt()) {
                    System.out.println("Input error: Please enter '0' or '1'.");
                    scanner.next(); // Clear incorrect input}
                command = scanner.nextInt();

            } while (command == 1); // As long as the user enters 1, continue looping System.out.println("The program has exited.");

        } // try-with-resources will automatically close the scanner here
    }
}

Code optimization and precautions

1. Advantages of the switch statement: When dealing with multiple equality judgments (such as different mathematical operators), the switch statement is usually clearer and more readable than a series of if-else if constructs. It can effectively organize code logic and improve maintainability.

2. The program naturally exits: When all the code in the main method is executed, or the main method returns normally, the Java Virtual Machine (JVM) will automatically terminate the program. Therefore, in most cases, we do not need to explicitly call System.exit() to end the program. System.exit() is typically used to forcefully terminate the entire JVM from anywhere during program execution, such as when a serious error occurs or all threads need to be stopped immediately. For normal flow exits controlled by user input, it is more elegant to let the main method end naturally.

3. Input validation and exception handling: In real applications, user input is unpredictable. To make the program more robust, we must validate user input and handle exceptions that may occur:

   • InputMismatchException : This exception is thrown when the type entered by the user does not match the type expected by the Scanner (for example, an integer was expected but a string was entered). Capturing this exception through a try-catch block and prompting the user to re-enter can effectively improve the user experience.
   • ArithmeticException : For example, in a division operation, this exception is thrown if the divisor is zero. Before performing division operation, conditional judgment (if (num2 != 0)) should be performed to avoid such errors.
   • Input validation in the loop : When obtaining the command instruction, adding a while (!scanner.hasNextInt()) loop can ensure that the user has indeed entered an integer and avoid the program crashing due to invalid input.

4. Flexibility of loop conditions: The conditions of the while loop can be flexibly adjusted according to specific needs. For example, in addition to directly judging command == 1, you can also define a Boolean variable continueProgram = true; and then set it to false when the user chooses to exit to terminate the loop. This approach may be more readable in some complex scenarios.

Summarize

Through this tutorial, we learned how to use Java's do-while loop structure and Scanner class to implement an interactive program that allows the user to decide to continue or exit the program. We emphasized the importance of try-with-resources in resource management, as well as optimizing code logic and improving program robustness through switch statements and exception handling. Mastering these core concepts will enable you to build more user-friendly and stable Java applications.

The above is the detailed content of Control program looping and exit through user input in Java. For more information, please follow other related articles on the PHP Chinese website!