为何采用实例化调用非静态方法运行程序，而非直接用static void main？

Great question! This pattern is super common in Java applications, and it’s not just arbitrary—it’s a way to write cleaner, more maintainable, and testable code. Let’s break down the key advantages of separating your program’s entry point (main()) from its actual business logic (the start() method in your code):

First, here’s your code snippet for reference:

public static void main(String[] args) { 
    Main go = new Main(); 
    go.start(); 
} 
public Main() { } 
public void start() { 
    //SOME CODE HERE 
}

• Stays true to Java’s Object-Oriented roots
  The main() method is static, meaning it belongs to the class itself, not any instance of it. By moving your logic to a non-static start() method, you get to leverage all of OOP’s strengths: you can use instance variables to manage state, encapsulate data and behavior within objects, and avoid the pitfalls of overusing static variables (which can lead to messy global state). If you crammed everything into main(), you’d be stuck working with static members, which breaks the object-oriented paradigm Java was built around.

• Makes testing way easier
  Unit testing a static main() method is a headache. It’s tied to the program’s entry point, relies on command-line arguments, and once it runs, the JVM exits. But with a non-static start() method? You can simply instantiate the Main class in your test code, call start() directly, and validate its behavior without spinning up the entire application. If your start() method depends on other components, you can even mock those dependencies to isolate the logic you’re testing—something you can’t do easily with a static main().

• Improves code organization and reusability
  Shoving all your logic into main() quickly leads to a giant, unreadable block of code. Moving it to start() lets you split your logic into smaller, focused methods (all instance-level) that are easier to follow. Plus, you can reuse this logic elsewhere: if you need to run the same business flow again in another part of your app, you just create a new Main instance and call start(). Static main() methods can’t be inherited or reused in a clean, instance-based way.

• Enables cleaner exception handling
  In main(), handling exceptions often ends up being a catch-all block that’s messy and hard to maintain. By putting logic in start(), you can handle exceptions at the right level—either catching specific errors within start() or throwing them back to main() for top-level handling. This separates concerns: main() is responsible for bootstrapping the app and handling fatal errors, while start() focuses on executing the business logic with appropriate error handling.

• Avoids static state chaos
  If you use main() for all logic, you’ll likely end up using static variables to track state. Static variables are shared across all instances of the class, which can lead to unexpected behavior if multiple parts of your app try to modify them. Using instance variables in Main ensures each instance has its own isolated state, preventing bugs caused by shared static data.

To sum it up: this pattern keeps your entry point simple, your business logic flexible, and your codebase easier to work with long-term.

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