java - Java程序中可以存在两个主要方法吗？

Question

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

只是因为他们的论点有所不同，例如：

public static void main(String[] args)

第二个可以是

public static void main(StringSecond[] args)

如果可能，将使用哪个 Method 作为入口点？如何识别这个？

Answer 1

在这里，您可以看到public static void main (String args[])单个文件中有 2 个名称Test.java（特别是没有使用文件名作为 2 个类名称中的任何一个），并且 2 个类具有默认访问说明符。

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);
    }
}

当我们编译代码 Test.java 时，它将生成 2 个.class文件（即Sum.class和DefClass.class），如果我们运行 Test.java，我们将无法运行它，因为它找不到任何名为 Test 的主类。相反，如果我们这样做java Sum或java DefClass两者都会使用不同的main(). 要使用 Sum 类的 main 方法，我们可以使用类名Sum.main(null)或Sum.main(1)//Passing integer value in the DefClass main().

在类作用域中，每个类只能有一个public static void main (String args[])，因为类的静态方法属于一个类而不属于它的对象，并且使用它的类名来调用。即使我们创建多个对象并使用它们调用相同的静态方法，这些调用将引用的静态方法的实例也是相同的。

我们还可以通过在 main 中传递不同的参数集来重载 main 方法。上面的代码中提供了类似的示例，但默认情况下，控制流将从public static void main (String args[])我们使用调用的类文件开始java classname。要使用其他参数集调用 main 方法，我们必须从其他类显式调用它。

Answer 2

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

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

public static void main(String[] args)

只有以单个String[]（或）String...为参数的 main 方法才会被视为程序的入口点。

Answer 3

一个程序中可以有多个 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);
   }
}

Answer 4

只public static void main(String[] args)计算。这是唯一被认为是真正的 main() 的签名（我的意思是作为程序入口点）。

Answer 5

只要StringSecond是一个类，那将是可编译的代码。但是，如果您所说的“主要方法”是指程序的第二个入口点，那么您的问题的答案仍然是否定的。只有第一个选项 ( public static void main(String[] args)) 可以作为程序的入口点。

但是请注意，如果您要将第二个main(String[])方法放在不同的类中（但在同一个项目中），您可以在项目中拥有多个可能的入口点，然后您可以从中进行选择。但这不能与覆盖或重载的原则相冲突。

另请注意，该领域的一个混淆来源，尤其是对于入门级程序员而言，是public static void main(String[] args)和public static void main(String ... args)都用作入口点并被视为具有相同的方法签名。

Answer 6

在 Java 中，每个类只能有一个 。这意味着，如果您的程序有多个类，则每个类都可以有. 有关详细信息，请参阅JLS。public static void main(String[] args) public static void main(String[] args)

Answer 7

main 方法的签名必须是

public static void main(String[] args) 

• 参数名称可以是任何有效名称
• static和public关键字的位置可以互换
• String 数组也可以使用 varargs 语法

一个类可以定义多个名为 main 的方法。这些方法的签名与 main 方法的签名不匹配。这些具有不同签名的其他方法不被视为“主要”方法。

Answer 8

答案是肯定的，但您应该考虑以下 3 点。

1. 没有两个主要方法参数应该相同

   例如。

   • public static void main(int i)
   • public static void main(int i, int j)
   • public static void main(double j)
   • public static void main(String[] args)

2. Java 的实际 main 方法是带有 的(String[] args)，所以实际执行是从 public static void main(String[] args) 开始的，所以带有的 main 方法(String[] args)必须在一个类中，除非它不是子类。

3. 为了执行其他主要方法，您需要从(String[] args)主要方法内部调用它们。

这是一个关于相同的详细视频： https ://www.youtube.com/watch?v=Qlhslsluhg4&feature=youtu.be

Answer 9

答案是不; 只有一种“main”方法——其中“main”表示您可以“运行”的入口点。

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

Answer 10

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

Answer 11

是的，在同一个程序中有两个 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 参数或字符串参数之一]。编译此 Anonym.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

Answer 12

是的！Java 中的任何类都可以有多个主要方法。它被称为重载（重载的方法是具有相同名称但具有不同签名的方法）但应该只有一个带有如下参数的主要方法：- (String[] args) 或 (String args[])

例如：-public 类 E {

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")
}

}

上述程序的输出将是“Print B”，因为只有该 main 方法包含由 Javac 编译器识别的正确方法签名，并且它只编译并保留其余的。

Answer 13

案例：1 > 我们有两个主要方法，但使用“Main”和“main2”，所以 jvm 只有一个=调用“main”方法。

2> 方法相同但参数不同，仍然 jvm 调用“main(String[] args)”方法。

3> 完全相同的方法，但它会产生编译时错误，因为您不能在一个类中拥有两个相同名称的方法！！！

希望它能给你一个清晰的画面。

Answer 14

同一范围内的两个 main(String[] args) 方法的可能性会给 JVM 造成混乱。它无法将它们用作重载方法。因此，参数方面的签名）必须不同。

Answer 15

文件“ Locomotive.java ”中的以下代码将成功编译并运行，执行结果显示

2<SPACE>

如上所述，重载规则仍然适用于 main 方法。然而，入口点是著名的psvm (public static void main(String[] args))

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);
    }
}

Answer 16

我已经检查了 java 版本 1.6.0_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);
}
}