Java程序中是否存在两种主要方法？

Java程序中可以存在两种主要方法吗

只是因为他们的论点不同，比如：

public static void main(String[] args)

第二种可能是

public static void main(StringSecond[] args)

---

如果可能，将使用哪种方法作为入口点？如何识别这一点？

只要方法参数（编号（或）类型）不同，就可以。它被称为

重载方法通过传入方法的参数的数量和类型来区分

---

只有带有单个

String[]

（或）

String…

作为参数的main方法才会被视为程序的入口点。

仅

公共静态void main（String[]args）

计数。这是唯一被认为是真main（）的签名（我的意思是作为程序入口点）。

这将是可编译的代码，只要

StringSecond

是一个类。但是，如果“main method”是指进入程序的第二个入口点，那么问题的答案仍然是否定的。只有第一个选项（

publicstaticvoidmain（String[]args）

）可以作为进入程序的入口点

但是，请注意，如果将第二个

main（String[]）

方法放在不同的类中（但在同一个项目中），则可以在项目中有多个可能的入口点，然后可以从中进行选择。但这不能与覆盖或重载的原则相冲突

---

还要注意的是，这方面的一个混乱来源，特别是对于入门级程序员来说，

publicstaticvoidmain（String[]args）

和

publicstaticvoidmain（String…args）

都被用作入口点，并被视为具有相同的方法签名；只能有一个“main”方法，其中“main”表示可以“运行”的入口点

---

您可以像示例中那样编写重载版本，但它们不能“运行”。

单个程序中可以有多个main方法。其他是重载方法。 此重载方法在单个主方法下工作良好

public class MainMultiple{

   public static void main(String args[]){
       main(122);
       main('f');
       main("hello java");
   }

   public static void main(int i){
       System.out.println("Overloaded main()"+i);
   }

   public static void main(char i){
       System.out.println("Overloaded main()"+i);
   }

   public static void main(String str){
       System.out.println("Overloaded main()"+str);
   }
}

---

一个程序中可以有多个主方法。但是JVM总是调用String[]参数main（）方法。其他方法将充当重载方法。我们必须显式地调用这些重载方法。

在同一范围内有两个主（String[]args）方法的可能性会给JVM带来混乱。它无法将它们用作重载方法。因此，参数方面的签名必须不同。

在Java中，每个类只能有一个公共静态void main（String[]args）。这意味着，如果您的程序有多个类，那么每个类都可以有

公共静态void main（String[]args）

。有关详细信息，请参阅。

我已签入java版本1.6.0\u 32多个主方法正在工作，但应该有一个主方法，如签名类型的public static void main（String[]args）。Ex在这里，我已经测试过了

public class mainoverload
{
public static void main(String a)
{
    System.out.println("\nIts "+a);
}
public static void main(String args[])
{
    System.out.println("\nIts public static void main\n");
    mainoverload.main("Ankit");
    mainoverload.main(15,23);
    mainoverload.main(15);
}
public static void main(int a)
{
    System.out.println("\nIts "+a);
}
public static void main(int a,int b)
{
    System.out.println("\nIts "+a+" "+b);
}
}    

---

在这里您可以看到，在一个名为

Test.java

的文件中有2个

publicstaticvoidmain（字符串args[]）

（特别是没有将文件名用作这两个类名中的任何一个），这两个类都带有默认的访问说明符

class Sum {

    int add(int a, int b) {
        return (a+b);   
    }

    public static void main (String args[]) {
        System.out.println(" using Sum class");
        Sum a = new Sum();
        System.out.println("Sum is :" + a.add(5, 10));
    }

    public static void main (int i) {
        System.out.println(" Using Sum class main function with integer argument");
        Sum a = new Sum();
        System.out.println("Sum is :" + a.add(20, 10));
    }
}

class DefClass {

    public static void main (String args[]) {
        System.out.println(" using DefClass");
        Sum a = new Sum();
        System.out.println("Sum is :" + a.add(5, 10));
        Sum.main(null);
        Sum.main(1);
    }
}

当我们编译code Test.java时，它将生成2个

.class

文件（即

Sum.class

和

DefClass.class

），如果我们运行Test.java，我们将无法运行它，因为它找不到任何名为Test的主类。相反，如果我们使用

javasum

或

javadefclass

这两种方法，它们将使用不同的

main（）

提供不同的输出。要使用Sum类的main方法，我们可以使用类名

Sum.main（null）

或

Sum.main（1）//在DefClass main（）中传递整数值

在类作用域中，每个类只能有一个
publicstaticvoidmain（stringargs[]）
，因为类的静态方法属于一个类而不是它的对象，并且使用它的类名调用。即使我们创建多个对象并使用它们调用相同的静态方法，这些调用所引用的静态方法的实例也将是相同的

我们还可以通过在main中传递不同的参数集来重载main方法。上面的代码中提供了类似的示例，但默认情况下，控制流将从类文件的
公共静态void main（字符串args[]）
开始，我们使用
java classname
调用了该类文件。要使用其他参数集调用main方法，我们必须从其他类显式调用它。
main方法的签名必须是

public static void main(String[] args) 


参数的名称可以是任何有效的名称
静态关键字和公共关键字的位置可以互换
字符串数组也可以使用varargs语法

一个类可以定义多个名为main的方法。
这些方法的签名与主方法的签名不匹配。这些具有不同签名的其他方法不被视为“main”方法。
是的，在同一个程序中可能有两个main（）。例如，如果我有一个类Demo1，如下所示。编译此文件将生成Demo1.class文件。一旦您运行它，它将运行main（），默认情况下该函数包含字符串参数数组。它甚至不会嗅探带有int参数的main（）

class Demo1 {   
static int a, b;    
public static void main(int args) {
     System.out.println("Using Demo1 class Main with int arg");
     a =30;
     b =40;
     System.out.println("Product is: "+a*b);
 }
public static void main(String[] args) {
      System.out.println("Using Demo1 class Main with string arg");
      a =10;
      b =20;
      System.out.println("Product is: "+a*b);

 }
 }      

Output:
Using Demo1 class Main with string arg
Product is: 200

但是如果我添加另一个名为Anonym的类并将文件另存为Anonym.java。在这个函数中，我调用Demo1类main（）[int参数或string参数一]。编译后，将生成此匿名.class文件

class Demo1 {   
    static int a, b;    
public static void main(int args) {
    System.out.println("Using Demo1 class Main with int arg");
    a =30;
    b =40;
    System.out.println("Product is: "+a*b);
}
public static void main(String[] args) {
    System.out.println("Using Demo1 class Main with string arg");
     a =10;
     b =20;
     System.out.println("Product is: "+a*b);        
} 
}       

class Anonym{
public static void main(String arg[])
{

    Demo1.main(1);
    Demo1.main(null);
}
}


Output:
Using Demo1 class Main with int arg
Product is: 1200
Using Demo1 class Main with string arg
Product is: 200

下面文件“motor.java”中的代码将成功编译并运行，执行结果如下

2<SPACE>

对!！Java中的任何类都可以有多个主方法。它被称为重载（重载方法是具有相同名称但具有不同签名的方法），但应该只有一个
2<SPACE>

public class Locomotive {
    Locomotive() { main("hi");}

    public static void main(String[] args) {
        System.out.print("2 ");
    }

    public static void main(String args) {
        System.out.print("3 " + args);
    }
}

public static void main(String args){
    System.out.println("Print A");
}
public static void main(String [] args){
    System.out.println("Print B");
}
public static void main(int garbage){
    System.out.println("Print C");
}
public static void main(int i){
    System.out.println("Print D")
}