Building a Command-Line Menu with Control Flow

The Heartbeat of an Application: The Main Loop

Most interactive applications, from complex video games to simple console tools, are built around a central loop. This loop performs three key tasks, over and over:

1. Check for user input.
2. Update the program's state based on that input.
3. Display the results.

This cycle continues until the user decides to exit. The perfect tool for creating this "heartbeat" in Java is the while loop. We can use a boolean variable as a flag to control the loop. The loop will continue as long as the flag is true.

import java.util.Scanner;

public class WarehouseSystem {
    public static void main(String[] args) {
        // We'll add our variables here later

        boolean isRunning = true; // This flag controls the main loop

        while (isRunning) {
            // 1. Display the menu
            // 2. Get user input
            // 3. Process the choice
        }

        System.out.println("Exiting Warehouse System. Goodbye!");
    }
}

The video below demonstrates how a similar boolean flag and while loop are used to structure a simple banking application. Pay attention to how the loop keeps the program alive until the user chooses to exit.

Reading User Input with Scanner

To get the user's menu choice, we'll use Java's Scanner class. It's a versatile tool for reading input from various sources, including the console.

Scanner scanner = new Scanner(System.in);
System.out.println("Enter your choice: ");
int choice = scanner.nextInt(); // Reads an integer from the user

However, mixing calls to scanner.nextInt() (or nextDouble(), etc.) with scanner.nextLine() (which reads a full line of text, like a product name) can lead to a very common and confusing bug. This happens because nextInt() reads only the number and leaves the "Enter" keypress (a newline character) in the input buffer. The next time nextLine() is called, it reads that leftover newline and returns an empty string, effectively "skipping" the prompt.

Understanding this is crucial for writing robust input-handling code.

Following this best practice, our input-reading code looks more like this:

Scanner scanner = new Scanner(System.in);
System.out.println("Enter your choice: ");
String input = scanner.nextLine(); // Always read the full line
int choice = Integer.parseInt(input); // Then parse it to an integer

This approach is more predictable and avoids the newline bug entirely. We will revisit this robust parsing technique when we discuss exception handling in a future module.

Handling Choices with switch and if-else

Once you have the user's choice as an integer, you need to execute the correct action. You could use a series of if-else if-else statements, but for a fixed set of menu options, a switch statement is often cleaner and more readable. It checks a variable against a list of possible case values and executes the code associated with the first match.

The following tutorial builds a menu-driven application for a movie theater. Its structure is very similar to our warehouse system. The logic for displaying a menu, using a while loop, and handling user choices with switch is directly applicable.

Let's integrate this into our warehouse system code. Inside the while loop:

// Inside the while(isRunning) loop...

System.out.println("\n--- Smart Warehouse Menu ---");
System.out.println("1. Add Item");
System.out.println("2. Remove Item");
System.out.println("3. View Inventory");
System.out.println("4. Exit");
System.out.print("Enter your choice: ");

String input = scanner.nextLine();
int choice = Integer.parseInt(input);

switch (choice) {
    case 1:
        System.out.println("Executing 'Add Item'...");
        // Logic for adding an item will go here
        break;
    case 2:
        System.out.println("Executing 'Remove Item'...");
        // Logic for removing an item will go here
        break;
    case 3:
        System.out.println("Executing 'View Inventory'...");
        // Logic for viewing inventory will go here
        break;
    case 4:
        isRunning = false; // Set the flag to false to exit the loop
        break;
    default:
        System.out.println("Invalid choice. Please try again.");
        break;
}

While switch is great for the main menu, if-else statements are essential for handling conditions within a menu option. For example, when adding an item, you might use an if statement to check if the quantity entered is greater than zero.

A Tour of Java's Loops

We've already seen the while loop in action. Java provides two other types of loops, each suited for different scenarios.

1. while loop: The condition is checked before each iteration. If the condition is false initially, the loop body never runs. This is ideal for our main menu, which should not run at all if the program is supposed to exit immediately.

2. do-while loop: The condition is checked after each iteration. This guarantees that the loop body will execute at least once. This is perfect for input validation, where you need to prompt the user for input at least one time and then repeat the prompt if their input was invalid.

3. for loop: This loop is designed for situations where you want to iterate a specific number of times or iterate over all elements in a collection (like an array). It combines initialization, condition checking, and an update step into a single line. We will use this extensively when we start managing lists of products.

   // A simple for loop to count from 1 to 5
   for (int i = 1; i <= 5; i++) {
       System.out.println("Count is: " + i);
   }
   

For now, the while loop is the most important for our application's structure.

Conclusion

In this lesson, you've assembled the essential control flow structures needed to build an interactive console application. You now have a working menu that can accept and respond to user commands, forming the foundation of the Smart Warehouse system.

Here are the key takeaways for your interns:

• Main Application Loop: A while loop controlled by a boolean flag is a standard pattern for keeping a console application running until the user chooses to exit.
• Robust Input Handling: The Scanner class is used to get user input. A common pitfall is the newline character left by methods like nextInt(). The best practice is to always read the full line with nextLine() and then parse the string into the desired type.
• Conditional Logic: The switch statement is ideal for routing menu choices, while if-else statements are used for handling specific logical conditions within each choice.
• Loop Types: Java provides while, do-while, and for loops, each suited for different repetitive tasks.

The main method now orchestrates the entire application flow. However, as we add more logic for adding, removing, and viewing items, it will quickly become large and difficult to manage. In our next lesson, we will address this by learning how to define and use methods. This will allow us to break our code into smaller, reusable, and more organized blocks, which is a cornerstone of professional software development.