这只是一种惯例，但可能比另一种更方便。使用静态主程序，调用Java程序所需要知道的只是类的名称和位置。如果它不是静态的，您还必须知道如何实例化该类，或者要求该类具有空构造函数。

c++、c#和Java中的主要方法是静态的。

这是因为它们可以被运行时引擎调用，而无需实例化任何对象，然后main主体中的代码将完成其余的工作。

在main方法被调用之前，没有对象被实例化。使用static关键字意味着可以在不创建任何对象的情况下调用方法。

否则，它将需要一个对象的实例来执行。但是它必须从头开始调用，而不是首先构造对象，因为它通常是main()函数(bootstrap)的任务，解析参数并构造对象，通常是通过使用这些参数/程序参数。

如果不是，如果有多个构造函数，应该使用哪个构造函数?

在Java语言规范中有更多关于Java程序初始化和执行的信息。

各种类型的applet、midlet、servlet和bean被构造，然后在它们上调用生命周期方法。调用main是对主类所做的全部工作，因此不需要在被多次调用的对象中保存状态。将main固定在另一个类上是很正常的(尽管这不是一个好主意)，这将妨碍使用类创建main对象。

这只是一种惯例。JVM当然可以处理非静态的主方法，如果这是惯例的话。毕竟，您可以在类上定义静态初始化器，并在到达main()方法之前实例化无数对象。

该方法是静态的，否则就会产生歧义:应该调用哪个构造函数?特别是如果你的类是这样的:

public class JavaClass{
  protected JavaClass(int x){}
  public void main(String[] args){
  }
}

JVM是否应该调用新的JavaClass(int)?x应该通过什么?

如果不是，JVM是否应该实例化JavaClass而不运行任何构造函数方法?我认为不应该这样，因为那样会使你的整个类出现特殊情况——有时你有一个没有初始化的实例，你必须在每个可能被调用的方法中检查它。

在调用入口点之前，JVM必须实例化一个类，这有太多的边缘情况和模糊性，因此没有意义。这就是为什么main是静态的。

我不知道为什么main总是被标记为public。

如果主方法不是静态的，则需要从程序外部创建主类的对象。你想怎么做呢?

这只是惯例。事实上，甚至main()的名称和传入的参数都是纯粹的约定。

当您运行Java .exe(或Windows上的javaw.exe)时，真正发生的是几个Java本机接口(JNI)调用。这些调用加载的DLL是真正的JVM(没错，java.exe不是JVM)。JNI是我们用来连接虚拟机世界和C、c++等语言世界的工具。反过来也是对的——不使用JNI是不可能让JVM运行的(至少据我所知)。

基本上，java.exe是一个超级简单的C应用程序，它解析命令行，在JVM中创建一个新的String数组来保存这些参数，解析出您指定的包含main()的类名，使用JNI调用查找main()方法本身，然后调用main()方法，将新创建的字符串数组作为参数传入。这非常非常类似于您从Java中使用反射时所做的事情——它只是使用了令人混淆的命名本机函数调用。

编写自己版本的java.exe(源代码随JDK一起分发)并让它做一些完全不同的事情是完全合法的。事实上，这正是我们对所有基于java的应用程序所做的。

我们的每个Java应用程序都有自己的启动器。我们这样做主要是为了得到我们自己的图标和进程名，但在其他情况下，当我们想做一些常规的main()调用之外的事情来让事情继续进行时，它也很方便(例如，在一种情况下，我们正在进行COM互操作性，我们实际上将COM句柄传递给main()而不是字符串数组)。

So, long and short: the reason it is static is b/c that's convenient. The reason it's called 'main' is that it had to be something, and main() is what they did in the old days of C (and in those days, the name of the function was important). I suppose that java.exe could have allowed you to just specify a fully qualified main method name, instead of just the class (java com.mycompany.Foo.someSpecialMain) - but that just makes it harder on IDEs to auto-detect the 'launchable' classes in a project.

因为静态成员不是任何特定类的一部分，而且主方法不需要创建它的Object，但仍然可以引用所有其他类。

Static表示该方法是类方法。并且调用时不需要任何类的对象。

由于程序从main()和开始执行，java是纯面向对象的程序，其中对象在main()中声明，这意味着main()在对象创建之前被调用，因此如果main()是非静态的，那么就需要一个对象，因为静态意味着不需要对象..........

静态方法不需要任何对象。它直接运行，所以main直接运行。

public关键字是一个访问修饰符，它允许程序员进行控制 类成员的可见性。当类成员前面有public时，则 成员可以由声明它的类之外的代码访问。

public的反义词是private，它防止成员被定义在类外部的代码使用。

在这种情况下，main()必须声明为public，因为必须调用它 当程序启动时，由其类之外的代码执行。

关键字static允许 Main()被调用，而不必实例化类的特定实例。这是必要的，因为Java解释器在创建任何对象之前调用main()。

关键字void只是告诉编译器main()不返回值。

这是一个经常被问到的问题，为什么main()在Java中是静态的。

答:我们知道在Java中，JVM从main()开始执行。当JVM执行main()时，包含main()的类不会被实例化，因此我们不能在没有引用它的对象的情况下调用非静态方法。因此，为了调用它，我们将其设置为静态的，因此类装入器将所有静态方法装入JVM上下文内存空间中，JVM可以从那里直接调用它们。

The static key word in the main method is used because there isn't any instantiation that take place in the main method. But object is constructed rather than invocation as a result we use the static key word in the main method. In jvm context memory is created when class loads into it.And all static members are present in that memory. if we make the main static now it will be in memory and can be accessible to jvm (class.main(..)) so we can call the main method with out need of even need for heap been created.

我认为关键字“静态”使主方法成为类方法，类方法只有它的一个副本，可以被所有人共享，而且，它不需要一个对象来引用。因此，当编译驱动程序类时，可以调用主方法。(我只是在java的字母级别，如果我错了，对不起)

Main()是静态的，因为;在应用程序生命周期的这一点上，应用程序堆栈本质上是过程化的，因为还没有实例化对象。

这是一个干净的石板。您的应用程序此时正在运行，即使没有声明任何对象(请记住，有过程性和OO编码模式)。作为开发人员，通过创建对象的实例并依赖于在其中编译的代码，将应用程序转换为面向对象的解决方案。

面向对象的优点有几百万个显而易见的理由。然而，大多数VB开发人员在代码中经常使用“goto”这样的关键字的日子已经一去不复返了。“goto”是VB中的一个过程命令，它被OO对应的方法调用所取代。

您还可以将静态入口点(main)视为纯粹的自由。如果Java足够不同，可以实例化一个对象，并在运行时只向你呈现该实例，那么你就别无选择，只能编写一个过程化应用程序。对于Java来说，这听起来可能难以想象，但可能有许多场景都需要过程化方法。

这可能是一个非常晦涩的回答。记住，“类”只是一个相互关联的代码的集合。“实例”是这个类的一个孤立的、活生生的、自主的代。

任何应用程序的真正入口点都是静态方法。如果Java语言支持实例方法作为“入口点”，那么运行时将需要在内部将其作为静态方法实现，该方法构造对象的实例，然后调用实例方法。

有了这些，我将研究选择以下三个选项中的一个的基本原理:

我们今天看到的静态void main()。 在新构造的对象上调用的实例方法void main()。 使用类型的构造函数作为入口点(例如，如果入口类被称为Program，那么执行将有效地由新的Program()组成)。

分解:

静态无效主()

调用外围类的静态构造函数。 调用静态方法main()。

void main ()

调用外围类的静态构造函数。 通过有效调用new ClassName()构造外围类的实例。 调用实例方法main()。

新ClassName ()

调用外围类的静态构造函数。 构造类的实例(然后不做任何操作，只是返回)。

理由是:

这个我倒着讲。

请记住，Java的设计目标之一是强调(尽可能要求)良好的面向对象编程实践。在这种情况下，对象的构造函数初始化对象，但不应该对对象的行为负责。因此，给出new ClassName()入口点的规范会使新Java开发人员感到困惑，因为它强制每个应用程序上的“理想”构造函数设计出现异常。

通过将main()设置为实例方法，可以解决上述问题。但是，它要求规范列出入口类的构造函数的签名以及main()方法的签名，从而增加了复杂性。

总而言之，指定静态void main()将创建复杂度最低的规范，同时遵循将行为置于方法中的原则。考虑到实现main()方法本身构造类的实例并调用实例方法是多么简单，将main()指定为实例方法并没有真正的优势。

这只是一个惯例，我们可以在这里看到:

方法必须声明为public和static，它不能返回任何值 值，并且它必须接受String数组作为参数。默认情况下, 第一个非选项参数是要调用的类的名称。 应该使用完全限定的类名。如果-jar选项为 指定后，第一个非选项参数是JAR存档的名称 类包含应用程序的类和资源文件 由Main-Class manifest头指示的启动类。

http://docs.oracle.com/javase/1.4.2/docs/tooldocs/windows/java.html#description

public静态void关键字意味着Java虚拟机(JVM)解释器可以调用程序的主方法来启动程序(public)，而无需创建类的实例(static)，并且程序结束时不会将数据返回给Java VM解释器(void)。

来源: 要领，第1部分，第2课:构建应用程序

为什么公共静态无效主(字符串[]args) ?

这就是Java语言和Java虚拟机是如何设计和编写的。

Oracle Java语言规范

请参阅第12章执行- 12.1.4节调用Test.main:

最后，在完成Test类的初始化之后(在此期间可能发生了其他相应的加载、链接和初始化)，调用Test的main方法。 方法main必须声明为public、static和void。它必须接受一个字符串数组的参数。此方法可以声明为任意一种 public static void main(String[] args) 或 public static void mainargs)

Oracle Java虚拟机规范

请参阅第2章Java编程语言概念-第2.17节执行:

Java虚拟机通过调用某个指定类的main方法并向其传递一个参数(字符串数组)来开始执行。这将导致指定的类被加载(§2.17.2)，链接(§2.17.3)到它使用的其他类型，并初始化(§2.17.4)。方法main必须声明为public、static和void。

Oracle OpenJDK源代码

下载并提取jar源代码，看看JVM是如何编写的，查看../launcher/java. C，其中包含java [-options] class [args…]命令背后的原生C代码:

/*
 * Get the application's main class.
 * ... ...
 */
if (jarfile != 0) {
    mainClassName = GetMainClassName(env, jarfile);

... ...

    mainClass = LoadClass(env, classname);
    if(mainClass == NULL) { /* exception occured */

... ...

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                   "([Ljava/lang/String;)V");

... ...

{    /* Make sure the main method is public */
    jint mods;
    jmethodID mid;
    jobject obj = (*env)->ToReflectedMethod(env, mainClass,
                                            mainID, JNI_TRUE);

... ...

/* Build argument array */
mainArgs = NewPlatformStringArray(env, argv, argc);
if (mainArgs == NULL) {
    ReportExceptionDescription(env);
    goto leave;
}

/* Invoke main method. */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

... ...

来自java.sun.com(网站上有更多信息):

主要方法是静态的，以使Java VM解释器能够在不首先创建控件类实例的情况下启动类。控件类的实例在程序启动后在main方法中创建。

我的理解一直很简单，就像任何静态方法一样，可以在不创建相关类的实例的情况下调用主方法，允许它在程序中的任何其他方法之前运行。如果它不是静态的，你就必须在调用它之前实例化一个对象——这就产生了一个“先有鸡还是先有蛋”的问题，因为main方法通常是你在程序开始时用来实例化对象的。

原型public static void main(String[])是在JLS中定义的约定:

方法main必须声明为public、static和void。它必须指定一个形式形参(§8.4.1)，其声明类型为String数组。

在JVM规范5.2中。虚拟机启动我们可以读到:

The Java virtual machine starts up by creating an initial class, which is specified in an implementation-dependent manner, using the bootstrap class loader (§5.3.1). The Java virtual machine then links the initial class, initializes it, and invokes the public class method void main(String[]). The invocation of this method drives all further execution. Execution of the Java virtual machine instructions constituting the main method may cause linking (and consequently creation) of additional classes and interfaces, as well as invocation of additional methods.

有趣的是，在JVM规范中并没有提到主方法必须是静态的。 但是规范还说Java虚拟机执行以下两个步骤:

链接初始类(5.4。链接) 初始化它。初始化)

类或接口的初始化包括执行类或接口的初始化方法。

在2.9。特殊方法:

定义一个类或接口初始化方法:

一个类或接口最多有一个类或接口初始化方法，并通过调用该方法进行初始化(§5.5)。类或接口的初始化方法具有特殊名称<clinit>，不带参数，且为空。

类或接口初始化方法不同于定义如下的实例初始化方法:

在Java虚拟机级别，每个用Java编程语言(JLS§8.8)编写的构造函数都作为实例初始化方法出现，具有特殊名称<init>。

因此JVM初始化一个类或接口初始化方法，而不是实例初始化方法，后者实际上是一个构造函数。 因此，他们不需要在JVM规范中提到主方法必须是静态的，因为在调用主方法之前不创建实例这一事实暗示了这一点。

让我们简单地假设，静态不需要作为应用程序入口点。

一个应用程序类看起来是这样的:

class MyApplication {
    public MyApplication(){
        // Some init code here
    }
    public void main(String[] args){
        // real application code here
    }
}

构造函数代码和主方法之间的区别是必要的，因为在OO中，构造函数只应确保实例被正确初始化。初始化后，实例可以用于预期的“服务”。将完整的应用程序代码放到构造函数中会破坏这一点。

因此，这种方法将在应用程序上强制执行三个不同的契约:

必须有一个默认构造函数。否则，JVM将不知道调用哪个构造函数以及应该提供哪些参数。 必须有一个主要的方法。好吧，这并不奇怪。 类不能是抽象的。否则，JVM无法实例化它。

另一方面，静态方法只需要一个契约:

必须有一个主要的方法。

这里抽象构造函数和多重构造函数都不重要。

由于Java被设计为一种简单的语言，所以应用程序入口点被设计为使用一个简单的契约，而不是使用三个独立而脆弱的契约，这并不奇怪。

请注意:这个参数不是关于JVM或JRE内部的简单性。这个参数是关于用户的简单性。

在这里，完整的签名只能算作一份合同。

最近，类似的问题也出现在了程序员网站上。SE

为什么在Java和c#中使用静态主方法，而不是构造函数? 从主要或次要来源中寻找一个明确的答案，为什么(特别是)Java和c#决定将静态方法作为它们的入口点-而不是通过应用程序类的实例表示应用程序实例，入口点是一个适当的构造函数?

公认的答案是，

In Java, the reason of public static void main(String[] args) is that Gosling wanted the code written by someone experienced in C (not in Java) to be executed by someone used to running PostScript on NeWS   For C#, the reasoning is transitively similar so to speak. Language designers kept the program entry point syntax familiar for programmers coming from Java. As C# architect Anders Hejlsberg puts it, ...our approach with C# has simply been to offer an alternative... to Java programmers... ...

public static void main(String args[])是什么意思?

public is an access specifier meaning anyone can access/invoke it such as JVM(Java Virtual Machine. static allows main() to be called before an object of the class has been created. This is neccesary because main() is called by the JVM before any objects are made. Since it is static it can be directly invoked via the class. class demo { private int length; private static int breadth; void output(){ length=5; System.out.println(length); } static void staticOutput(){ breadth=10; System.out.println(breadth); } public static void main(String args[]){ demo d1=new demo(); d1.output(); // Note here output() function is not static so here // we need to create object staticOutput(); // Note here staticOutput() function is static so here // we needn't to create object Similar is the case with main /* Although: demo.staticOutput(); Works fine d1.staticOutput(); Works fine */ } } Similarly, we use static sometime for user defined methods so that we need not to make objects. void indicates that the main() method being declared does not return a value. String[] args specifies the only parameter in the main() method. args - a parameter which contains an array of objects of class type String.

在Java中声明为静态的任何方法都属于类本身。 同样，特定类的静态方法只能通过引用类Class_name.method_name();

因此，在访问静态方法之前不需要实例化类。

因此main()方法被声明为静态的，这样就可以在不创建该类对象的情况下访问它。

因为我们用存在main方法的类名来保存程序(或者从程序开始执行的地方开始，适用于没有main()方法()的类(高级级别))。所以通过上面提到的方法:

Class_name.method_name();

可以访问主方法。

简而言之，当程序被编译时，它会在类中搜索main()方法，其String参数如下:main(String args[])。由于在开始时它没有实例化该类的作用域，因此main()方法被声明为静态的。

让我用更简单的方式来解释这些事情:

public static void main(String args[])

除了applet，所有Java应用程序都从main()开始执行。

关键字public是一个访问修饰符，允许从类外部调用成员。

使用Static是因为它允许调用main()而不必实例化该类的特定实例。

Void表示main()不返回任何值。

我不知道JVM是否在对象实例化之前调用main方法…但是main()方法是静态的还有一个更有力的原因…当JVM调用类的主方法(比如Person)时。它通过"Person.main()"调用它。您可以看到，JVM通过类名调用它。这就是为什么main()方法应该是静态和公共的，以便JVM可以访问它。

希望有帮助。如果是的话，请在评论中告诉我。

基本上，我们将这些数据成员和成员函数设置为STATIC，它们不执行任何与对象相关的任务。对于main方法，我们将其设置为STATIC，因为它与object无关，因为无论我们是否创建对象，main方法总是运行。

这背后的原因很简单，因为对象不需要调用静态方法，如果它是非静态方法，java虚拟机先创建对象，然后调用main()方法，这将导致额外的内存分配问题。

The main method of the program has the reserved word static which means it is allowed to be used in the static context. A context relates to the use of computer memory during the running of the program. When the virtual machine loads a program, it creates the static context for it, allocating computer memory to store the program and its data, etc.. A dynamic context is certain kind of allocation of memory which is made later, during the running of the program. The program would not be able to start if the main method was not allowed to run in the static context.

static -当JVM调用主方法时，被调用的类不存在对象，因此它必须有静态方法来允许从类调用。

使用Java命令运行Java虚拟机(JVM)时，

java ClassName argument1 argument2 ...

当您执行您的应用程序时，您指定它的类名作为java命令的参数，如上所述

JVM尝试调用您指定的类的主方法

-在这一点上，类的对象还没有被创建。 将main声明为静态允许JVM在不创建的情况下调用main 类的实例。

让我们回到命令

ClassName是JVM的命令行参数，它告诉JVM要执行哪个类。在ClassName之后，您还可以指定一个字符串列表(由空格分隔)作为JVM将传递给应用程序的命令行参数。-这些参数可以用来指定运行应用程序的选项(例如文件名)-这就是为什么在main中有一个名为String[] args的参数

参考资料:Java™如何编程(早期对象)，第十版

主方法总是需要是静态的，因为在运行时JVM不会创建任何对象来调用主方法，正如我们所知，在java中静态方法是唯一可以使用类名调用的方法，所以主方法总是需要是静态的。

更多信息请访问这个视频:https://www.youtube.com/watch?v=Z7rPNwg-bfk&feature=youtu.be