Pitfalls of Constructors and Inheritance in Java: Avoid Infinite Loops

In Java object-oriented programming, improper constructor design, especially when the inheritance system contains user interaction or complex logic, can easily lead to unexpected recursive calls, causing the program to fall into an infinite loop. This article will deeply analyze this "loop without loop" phenomenon and reveal that its root cause is that when the subclass constructor implicitly or explicitly calls the parent class constructor, the logic contained in the parent class constructor is repeatedly executed. We will provide clear solutions to guide developers on how to refactor their code and separate complex business logic and user input from constructors to ensure correctness and maintainability of program behavior.

Understanding the problem: Why does the code "infinite loop"?

Many developers may encounter a confusing problem when they first come into contact with Java inheritance: although there are no explicit for or while loops in the code, the program repeatedly executes certain blocks of code, especially during the object creation phase. This phenomenon usually occurs when a subclass constructor calls the parent class constructor (super()). If the parent class constructor contains user input or logic for creating new objects, it may lead to unexpected recursive calls.

Consider the following simplified code structure:

 class Person {
    public Person(String agentId, String password, String address) {
        // ...other initialization code...
        Scanner input = new Scanner(System.in);
        System.out.println("[1]AGENT");
        System.out.println("[2]CUSTOMER");
        int choice = input.nextInt(); // This will wait for user input if (choice == 1) {
            // If you choose 1, the Agent object may be created here Agent agent = new Agent("Niel", "diko alam", "umay");
        } else if (choice == 2) {
            System.out.println("POTANGINA");
        }
        // input.close(); // Important resource management, but not the core issue here}
}

class Agent extends Person {
    public Agent(String agentId, String password, String address) {
        super(agentId, password, address); // Explicitly or implicitly call the constructor of the parent class Person // ...Agent-specific initialization code...
    }
}

public class Finals {
    public static void main(String[] args) {
        // Try to create a Person object, and then create an Agent object Person person = new Person("20860132", "h208f32", "San luis");
        Agent agent = new Agent("20860132", "h208f32", "San luis"); // This is where the problem starts}
}

In the above code, when the main method executes new Agent(...), the following steps occur:

1. The constructor of the Agent class is called.
2. The first line of the Agent constructor calls (implicitly or explicitly) super(agentId, password, address), the constructor of the Person class.
3. The Person constructor starts executing, it prints the menus [1]AGENT and [2]CUSTOMER, and waits for user input.
4. If the user enters 1, the Person constructor will internally try to create a new Agent object: Agent agent = new Agent(...).
5. The creation of this new Agent object will repeat steps 1-4, thus forming a chain of infinite recursive calls, causing the program to appear to be in an "infinite loop".

This is the so-called "constructor recursion trap", which is not caused by traditional loop statements, but is the result of a combination of improper constructor design and inheritance mechanisms.

Solution: Move business logic and user interaction out of the constructor

The core principle for solving this problem is that constructors should focus on initializing the state of the object rather than performing complex business logic or user interaction. Logic for user input and object type selection should be placed outside the constructor, such as in the main method or a dedicated factory method.

Here is an example of the refactored code:

1. Modify the Person class constructor

Removed user input and object creation selection logic from the Person constructor. The Person constructor is now only responsible for initializing the properties of the Person object.

 import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

class Person {
    protected String agentId;
    protected String password;
    protected String address;

    // The constructor is only responsible for initializing the properties public Person(String agentId, String password, String address) {
        this.agentId = agentId;
        this.password = password;
        this.address = address;
        // Remove user input and object creation logic}
    // ... other methods (if needed)
}

2. Modify Agent class constructor

The constructor of the Agent class can now focus on the initialization of the Agent object and call super() to initialize the properties of the Person part.

 class Agent extends Person {

    public Agent(String agentId, String password, String address) {
        super(agentId, password, address); // Call the parent class constructor to initialize the Person property // Agent-specific login and operation logic can be placed here, or it is more recommended to place it in the method called after the Agent object is created // For demonstration, we keep the login logic in the constructor, but in actual applications, further separation of Scanner input2 = new Scanner(System.in);
        System.out.println("[LOGIN]");
        System.out.print("ENTER AGENT ID:");
        // It is recommended to use nextLine() to read the entire line and then parse it into int to avoid Scanner buffer problems String idStr = input2.nextLine(); 
        int id = Integer.parseInt(idStr);

        System.out.print("ENTER PASSWORD:");
        String passStr = input2.nextLine();
        int pass = Integer.parseInt(passStr);

        if (id == 20860132 && pass == 20020729) {
            System.out.println("AGENT LOGIN SUCCESSFUL.");
            //The operation menu after successful login can be placed in a separate method, such as operateAgentMenu()
            // Scanner input = new Scanner(System.in); // Scanner should not be created frequently within the constructor
            // ...menu logic...
        } else {
            System.out.println("INCORRECT PLEASE TRY AGAIN.");
        }
        // input2.close(); // Important resource management, but you need to pay attention to the Scanner creation and closing strategy throughout the application life cycle}

    // ... addCar, schedule, records and other methods...
    public void addCar(List<string> cars) {
        try (FileWriter fw = new FileWriter("cars.txt", true);
             PrintWriter pw = new PrintWriter(fw)) { // Use try-with-resources to automatically close resources pw.println(cars);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //Other methods are similarly modified to try-with-resources
}</string>

3. Modify the Customer class constructor

Like Agent, Customer constructor should focus only on initialization.

 class Customer extends Person {
    private String customerId;

    public Customer(String agentId, String password, String address, String customerId) {
        super(agentId, password, address);
        this.customerId = customerId;
    }

    // ...other methods...
}

4. Modify the main method: focus on user interaction and object creation

Now, the main method will be responsible for handling the user's selection of whether to create an Agent or a Customer, and calling the appropriate constructor based on the selection.

 public class Finals {
    public static void main(String[] args) {
        Scanner mainInput = new Scanner(System.in); // Create a Scanner once in the main method

        System.out.println("Welcome to the System!");
        System.out.println("[1] AGENT");
        System.out.println("[2] CUSTOMER");
        System.out.print("Please choose your role: ");

        int choice = -1;
        try {
            choice = mainInput.nextInt();
            mainInput.nextLine(); // Consume the newline character to avoid affecting subsequent nextLine() calls} catch (java.util.InputMismatchException e) {
            System.out.println("Invalid input. Please enter a number.");
            mainInput.nextLine(); // Clear invalid input // You can choose to re-prompt the user for input or exit return; 
        }

        Person user = null; // Define a Person reference to store the created object if (choice == 1) {
            //Create Agent object Agent agent = new Agent("20860132", "h208f32", "San luis");
            user = agent; // Assign the agent object to the user reference // After successful login, you can call the menu method of the Agent object // agent.showAgentMenu(mainInput); // Assume that the Agent has a method to display the menu} else if (choice == 2) {
            // Create a Customer object Customer customer = new Customer("defaultAgentId", "defaultPass", "defaultAddress", "CUST001");
            user = customer; // Assign the customer object to the user reference System.out.println("CUSTOMER role selected.");
            // After successful login, you can call the menu method of the Customer object // customer.showCustomerMenu(mainInput); // Assume that the Customer has a method to display the menu} else {
            System.out.println("Invalid choice. Exiting.");
        }

        // You can perform subsequent operations here based on the type of user if (user != null) {
            System.out.println("User created: " user.getClass().getSimpleName());
            // For example, if user is Agent, its unique method can be called // if (user instanceof Agent) {
            // ((Agent) user).someAgentSpecificMethod();
            // }
        }

        mainInput.close(); // Close the Scanner at the end of the program
    }
}

Notes and further optimization

1. Scanner resource management: In the original code, Scanner objects were created in multiple places but were not closed. This may lead to resource leakage. Best practice is to create a Scanner object at the entry point of the program (such as the main method), pass it to the method that requires it, and finally close it when the program ends. Alternatively, for a locally used Scanner, use a try-with-resources statement to ensure it is closed.
2. Mixing problem of nextInt() and nextLine(): When the Scanner's nextInt() or next() method is followed by the nextLine() method, nextLine() may accidentally read the newline character left by nextInt(). The solution is to call an empty nextLine() immediately after nextInt() to consume the newline character.
3. Input validation: The user's input may not be the expected number, or may be outside the valid range. In practical applications, input validation and error handling mechanisms should be added (such as try-catch blocks to capture InputMismatchException or NumberFormatException).
4. Separation of responsibilities: Further, login logic, menu display logic, etc. can be separated from the constructor and used as class methods. This makes the constructor more concise and improves the testability and maintainability of the code. For example, the Agent class can have a login() method and a showOperationsMenu() method.
5. Factory pattern: For scenarios where different types of objects (Agent or Customer) are created based on user selection, you can consider introducing the factory pattern, such as creating a PersonFactory class that contains a static method createPerson(int choice) that returns the corresponding Person subclass instance based on the selection. This better encapsulates the logic of object creation.

By following these principles and suggestions, developers can effectively avoid infinite loop problems caused by improperly designed constructors and build more robust and maintainable Java applications.

The above is the detailed content of Pitfalls of Constructors and Inheritance in Java: Avoid Infinite Loops. For more information, please follow other related articles on the PHP Chinese website!