我们可以重载Java中的main方法吗？

我们可以重载main()Java中的方法吗？

您可以重载该main()方法，但仅public static void main(String[] args)在JVM启动您的类时使用。例如：

public class Test {
    public static void main(String[] args) {
        System.out.println("main(String[] args)");
    }

    public static void main(String arg1) {
        System.out.println("main(String arg1)");
    }

    public static void main(String arg1, String arg2) {
        System.out.println("main(String arg1, String arg2)");
    }
}

从命令行运行时，即使指定一个或两个命令行参数，该命令也始终会打印。main(String[] args)java Test ...

当然，您可以main()从代码中自己调用该方法-此时将应用正常的重载规则。

编辑：请注意，您可以使用varargs签名，因为从JVM的角度来看，这是等效的：

public static void main(String... args)

是的，您可以在Java中重载main方法。但是，程序在运行程序时不会执行重载的main方法，您必须从实际的main方法中调用重载的main方法。

这意味着main方法充当java解释器开始执行应用程序的入口点。在哪里需要从main调用加载的main。

是的，通过方法重载。通过方法重载，一个类中可以具有任意数量的主要方法。让我们看一个简单的例子：

class Simple{  
  public static void main(int a){  
  System.out.println(a);  
  }  

  public static void main(String args[]){  
  System.out.println("main() method invoked");  
  main(10);  
  }  
}  

它将给出以下输出：

main() method invoked
10

是的，您可以重载main（）

但是要明确一点-尽管您可以重载main，但是只有带有标准签名的版本才可以从命令行作为应用程序执行。例如

public static void main(String a,String... args){
// some code
}
2)public static void main(String[] args){//JVM will call this method to start 
// some code 
}

是的，您可以在Java中重载main方法。您必须从实际的main方法调用重载的main方法。

是的，主要方法可以重载。必须从“ public static void main（String args []）”内部调用重载的main方法，因为这是JVM启动类时的入口。重载的main方法也可以像普通方法一样具有任何限定符。

是的你可以。

mainJava中的方法不是外星方法。除了main()可以像其他方法一样可以重载的事实外，JVM始终会寻找方法签名来启动程序。

• 普通main方法充当JVM开始执行程序的入口点。

• 我们可以重载mainJava中的方法。但是，当我们运行您的程序时，程序不会
  执行重载的main方法，我们只需main要从实际的main方法中调用重载的方法。

  // A Java program with overloaded main()
  import java.io.*;     
  public class Test {         
    // Normal main()
    public static void main(String[] args) {
      System.out.println("Hi Geek (from main)");
      Test.main("Geek");
    }     
    // Overloaded main methods
    public static void main(String arg1) {
      System.out.println("Hi, " + arg1);
      Test.main("Dear Geek","My Geek");
    }
    public static void main(String arg1, String arg2) {
      System.out.println("Hi, " + arg1 + ", " + arg2);
    }
  }
  

  Java中main（）的有效变体

是的，我们可以重载main方法。main方法不能为静态main方法。

这是完全合法的：

public static void main(String[] args) {

}

public static void main(String argv) {
    System.out.println("hello");
}

是。“ main（）”方法可以重载。我试图输入一些代码来回答您的问题。

public class Test{
static public void main( String [] args )
        {
                System.out.println( "In the JVMs static main" );
                main( 5, 6, 7 );    //Calling overloaded static main method
                Test t = new Test( );
                String [] message  = { "Subhash", "Loves", "Programming" };
                t.main(5);
                t.main( 6, message );
        }

        public static void main( int ... args )
        {
                System.out.println( "In the static main called by JVM's main" );
                for( int val : args )
                {
                        System.out.println( val );
                }
        }

        public void main( int x )
        {
                System.out.println( "1: In the overloaded  non-static main with int with value " + x );
        }

        public void main( int x, String [] args )
        {
                System.out.println( "2: In the overloaded  non-static main with int with value " + x );
                for ( String val : args )
                {
                        System.out.println( val );
                }
        }
}

输出：

$ java Test
In the JVMs static main
In the static main called by JVM's main
5
6
7
1: In the overloaded  non-static main with int with value 5
2: In the overloaded  non-static main with int with value 6
Subhash
Loves
Programming
$

在上面的代码中，主要方法的静态方法和非静态版本都被重载用于演示。请注意，通过写JVM main，我的意思是说，这是JVM首先用来执行程序的主要方法。

是的，u可以重载main方法，但是解释器将始终搜索正确的main方法语法以开始执行。是的，您必须在object的帮助下调用重载的main方法。

class Sample{
public void main(int a,int b){
System.out.println("The value of a is "  +a);
}
public static void main(String args[]){
System.out.println("We r in main method");
Sample obj=new Sample();
obj.main(5,4);
main(3);
}
public static void main(int c){
System.out.println("The value of c  is"  +c);
}
}

The output of the program is:
We r in main method
The value of a is 5
The value of c is 3

是的，根据我的观点，我们可以重载main方法，但仅是方法重载。例如

class main_overload {
    public static void main(int a) {
        System.out.println(a);
    }
    public static void main(String args[]) {
        System.out.println("That's My Main Function");
        main(100);
    }
}

在此双反斜杠步骤中，我只是调用main方法...。

是的，可以重载main方法，其他函数也可以重载。需要注意的是，至少应有一个以“ String args [] ”为参数的主函数。并且在其中可以有任意数量的main函数。您的程序具有不同的参数和功能。让我们通过一个简单的示例来理解：

Class A{

public static void main(String[] args)
{
System.out.println("This is the main function ");
A object= new A();
object.main("Hi this is overloaded function");//Calling the main function
}

public static void main(String argu)     //duplicate main function
{
System.out.println("main(String argu)");
}
}

输出：这是主要功能
嗨，这是重载功能

是的，您可以重载main方法，但是在任何类中，只有一个带有签名的方法可以使public static void main(string args[])您的应用程序启动Execution，正如我们所知，在任何语言中，Execution都是从Main方法开始的。

package rh1;

public class someClass 
{

    public static void main(String... args)
    {
        System.out.println("Hello world");

        main("d");
        main(10);
    }
    public static void main(int s)
    {

        System.out.println("Beautiful world");
    }
    public static void main(String s)
    {
        System.out.println("Bye world");
    }
}