Why main method is static in java [duplicate]

Answer 1

main is static so your code can execute without having to instantiate a class first. Maybe you don't even want to create a class, or maybe creating the class is slow and you want to print out a "Loading..." text first, or you have multiple constructors, etc... there are many reasons not to force the user to create a class before command execution can begin.

You can still create objects before main() is executed if you create them statically.

Answer 2

It's just a convention. The Java language designers could have easily decided that you must designate a class to be instantiated, making its constructor the main method. But calling a static method is just as effective and doesn't require a class to be instantiated first.

Also, if the class has a superclass, you could alter the behavior of program startup by changing a superclass (since superclass constructors must be called before subclasses), perhaps unintentionally. Static methods don't have this problem.

The main method is static because it keeps things simpler, but if they wanted to make it more complicated, they could have.

Answer 3

Yes, other languages which run on the JVM create objects or modules (which are also objects) and run them. For example, the Fortress language 'Hello world' looks like

Component HelloWorld
Export Executable
run(args) = print "Hello, world!"
end

or, without the args:

Component HelloWorld
Export Executable
run() = print "Hello, world!"
end

Java is a bit more pragmatic than a pure OO language, having static methods and fields and primitive types. Its static main method is closer to C's main function. You would have to ask Gosling as to why he chose that convention.

The code to launch the JVM is fairly simple - this example creates a JVM, creates an object and calls its run method with the command line arguments - making the startup function (new main.HelloWorld()).run(args) rather than main.HelloWorld.main(args):

#include <stdio.h>
#include <jni.h>

JNIEnv* create_vm() {
    JavaVM* jvm;
    JNIEnv* env;
    JavaVMInitArgs args;
    JavaVMOption options[1];

    args.version = JNI_VERSION_1_2;
    args.nOptions = 1;

    options[0].optionString = "-Djava.class.path=C:\\java_main\\classes";
    args.options = options;
    args.ignoreUnrecognized = JNI_TRUE;

    JNI_CreateJavaVM(&jvm, (void **)&env, &args);

    return env;
}

int invoke_class(JNIEnv* env, int argc, char **argv) {
    jclass helloWorldClass;

    helloWorldClass = env->FindClass("main/HelloWorld");

    if (helloWorldClass == 0)
        return 1;

    jmethodID constructorMethod = env->GetMethodID(helloWorldClass, "<init>", "()V");

    jobject object = env->NewObject(helloWorldClass, constructorMethod);

    if (object == 0)
        return 1;

    jobjectArray applicationArgs = env->NewObjectArray(argc, env->FindClass("java/lang/String"), NULL);

    for (int index = 0; index < argc; ++index) {
        jstring arg = env->NewStringUTF(argv[index]);
        env->SetObjectArrayElement(applicationArgs, index, arg);
    }

    jmethodID runMethod = env->GetMethodID(helloWorldClass, "run", "([Ljava/lang/String;)V");

    env->CallVoidMethod(object, runMethod, applicationArgs);

    return 0;
}

int main(int argc, char **argv) {
    JNIEnv* env = create_vm();

    return invoke_class( env, argc, argv );
}