Mastering Methods: Parameters and Returns for Command Handling

The Problem: A Crowded main Method

Let's look at the structure you built in the previous lesson:

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

        while (isRunning) {
            // ... code to display menu ...

            int choice = // ... code to get user input ...

            switch (choice) {
                case 1:
                    System.out.println("Executing 'Add Item'...");
                    // Imagine 20-30 lines of code here for adding an item
                    break;
                case 2:
                    System.out.println("Executing 'Remove Item'...");
                    // And another 20-30 lines of code here
                    break;
                // ... and so on
            }
        }
    }
}

Imagine adding the logic for each menu option directly into the switch block. The main method would become hundreds of lines long, making it incredibly difficult to read, debug, and maintain. This is where methods come to the rescue.

Anatomy of a Method

A method is like a named recipe. You give it a name, tell it what ingredients it needs (parameters), and define the steps to produce a result (the method body). The result might be an action performed (like printing to the screen) or a new piece of data that is returned to the caller.

The following article provides a clear breakdown of these components. Focus on understanding the role of each part in the method declaration.

Action-Only Methods: void Return Type

The simplest type of method performs an action but doesn't need to send any data back. The return type for such a method is void. A perfect candidate in our warehouse application is the logic for displaying the menu.

Let's create a displayMenu method.

public static void displayMenu() {
    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: ");
}

Now, we can replace the menu printing code in our main method's loop with a simple call to displayMenu();.

The video below provides a concise explanation of void methods and how to call them.

Methods That Compute: Parameters and Return Values

Now for the more powerful case: methods that take in data, process it, and return a result. Let's refactor the part of our code that gets the user's input. We can create a method getUserChoice that handles prompting the user, reading the input, and returning the integer choice.

This method needs access to the Scanner to read input, so we will pass the scanner object as an argument.

public static int getUserChoice(Scanner scanner) {
    System.out.print("Enter your choice: ");
    String input = scanner.nextLine();
    int choice = Integer.parseInt(input); // We'll learn to handle bad input in the "Exceptions" module
    return choice;
}

When this method is called, it executes its code and, upon reaching the return statement, sends the value of choice back to where it was called.

Our main method can now be simplified even further:

// Inside the while loop...
displayMenu();
int choice = getUserChoice(scanner);
switch (choice) {
    // ... cases
}

The video below demonstrates this concept of a value-returning method with a practical example. Notice how the returned value is captured and used by the caller.

Putting It All Together: A Modular Design

By applying these principles, we can create separate methods for each of our menu actions. This is a crucial step in structuring our application. We are separating the "what" (the high-level flow in main) from the "how" (the detailed implementation in each method).

For now, these methods can just contain the placeholder print statements.

public static void handleAddItem() {
    System.out.println("Executing 'Add Item'...");
    // Future logic for adding an item will go here
}

public static void handleRemoveItem() {
    System.out.println("Executing 'Remove Item'...");
    // Future logic for removing an item will go here
}

public static void handleViewInventory() {
    System.out.println("Executing 'View Inventory'...");
    // Future logic for viewing inventory will go here
}

Our main method now becomes incredibly clean and readable. It serves as the central coordinator, delegating tasks to specialized methods.

public class WarehouseSystem {

    // ... (definitions for displayMenu, getUserChoice, handleAddItem, etc.)

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean isRunning = true;

        while (isRunning) {
            displayMenu();
            int choice = getUserChoice(scanner);

            switch (choice) {
                case 1:
                    handleAddItem();
                    break;
                case 2:
                    handleRemoveItem();
                    break;
                case 3:
                    handleViewInventory();
                    break;
                case 4:
                    isRunning = false;
                    break;
                default:
                    System.out.println("Invalid choice. Please try again.");
                    break;
            }
        }
        System.out.println("Exiting Warehouse System. Goodbye!");
        scanner.close();
    }
}

The following resource walks through a very similar process of building a command-line application by encapsulating logic into different methods and classes. It's a great example of the design philosophy we are adopting.

Conclusion

In this lesson, you've taken a massive step toward writing professional, organized code. By moving logic out of a monolithic main method and into smaller, focused methods, you've drastically improved the readability and maintainability of the warehouse application. This modular approach is not just a Java feature; it's a fundamental principle of software engineering.

Here are the key takeaways for your interns:

• Modularity: Methods allow you to break a large problem into smaller, manageable pieces.
• Encapsulation: Each method should have a single, well-defined responsibility. The "how" is hidden inside the method, and the caller only needs to know "what" it does via its signature.
• Parameters and Return Values: These are the mechanisms for passing data into and out of methods, allowing them to communicate and work together.
• Readability: A main method that delegates to well-named helper methods reads like a high-level summary of the program's logic, which is invaluable for anyone trying to understand the code.

The method signature (public int getChoice(Scanner s)) is the contract that a method offers to the rest of your program. Learning to read and understand these contracts is the first step to using pre-built Java libraries, which are known as Application Programming Interfaces (APIs).

In the next module, we will move beyond primitive types and simple methods. We'll begin exploring the core of Java's power—Object-Oriented Programming—by designing classes to model the real-world entities in our warehouse, such as Product, StorageSlot, and Order.