纠正Java中的主要方法，并理解其含义

Question

I've got a quick question that probably borders on dumb (to you Java experts out there), but I've been having some trouble understanding the basic "main method" syntax and why it seems to vary.

First a little background: I've been taking some basic Java courses, and I've been able to pick it up fairly quickly because I've done some programming in other languages (VBA, Python, etc).

But anyway, for the "main method", this course uses:

public void run() {
    // do whatever we were discussing
}

However, the compilers I've been using (www.compileonline.com, and now most recently JGrasp) apparently only recognize this:

public static void main(String args[]) {
    // code goes here.
}

Now I have a basic understanding of this (what "public", "void" and even "static" mean) but I'm not sure I understand why the course lessons use run() and the compilers say otherwise. I find it interesting that the compilers require the "main" method to be static (like a constant or class variable) and to use a string called args; I've never used this string, but for whatever reason it seems to be needed.

Similarly, the courses I've been learning from use a simple "println" but the compilers need "System.out.println"... just thought I should mention that because I'm thinking it's part of the same situation.

Anyway, does anyone know off-hand what's going on here? It's no big deal, because it's easy to just copy/paste the compilers' required text into the courses' code to get similar results, but it would be great to actually know why this is the case (as I'm sure this sort of copy/paste strategy will lead to "bugs" in the future). The only thing that I can come up with off-hand is maybe there was an update to Java that drastically changed certain functions and is not backwards-compatible? Anyway, thanks in advance for your input. : )

Answer 1

Here's a basic Java class.

public class Basic implements Runnable {

    @Override
    public void run() {
        // TODO Code goes here
    }

    public static void main(String[] args) {
        Basic basic = new Basic();
        basic.run();
    }

} 

This is how a main method and a run method work together. You put your code in the run method, and you execute the code from the main method.

The main method is static because Java has to have a single entry point into your classes and methods. The args String array allows you to pass strings to your program from the command line where you execute your program.

As an example, a file copy program would have two args parameters, the input file path and the output file path. This allows the file copy program to copy any file.

Answer 2

The real main method in Java for stand-alone applications is

public static void main(String[] args) { ... }

Everything else is part of a framework that has its own main method that sets up some things for you and then calls your code.

How it calls your code depends on the framework. If it's a web framework, it might call your doGet and doPost methods (servlet), or the methods annotated with @GET and @POST in a class annotated with @Path (JAX-RS). If it's an applet or a JavaFX application, your code would be called in a different way and so on.

Answer 3

The run method implements the Runnable interface for executing threads.

http://docs.oracle.com/javase/tutorial/essential/concurrency/runthread.html

Answer 4

I would suspect that the courses you're taking are deliberately avoiding the normal, more verbose syntax to make the content more accessible to students without prior experience in programming.

For a beginner, things like public static void main(String[] args) and System.out.println() can be quite a mouthful for the seemingly simple ideas they represent. As a result, some instructors choose to avoid "real" Java until their students are ready to grasp concepts like arrays and static fields/methods.

This pedagogical approach also helps to keep students from running into errors they don't yet understand, such as calling non-static methods in a static context. As others have mentioned, it also makes it easy to ensure students write code that is compatible with a given testing framework.

As for whether it's a good or bad approach, I can't really say. I'm sure some students appreciate the softer introduction, while others may feel that the "hand-holding" is an unnecessary hindrance.

Of course, if you intend to write real-world Java programs, you'll need to familiarize yourself with the way Java really works at some point, which involves the verbose forms you've pointed out.