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

时间：2012-11-15 14:43:40

标签： java methods arguments main

Java程序中是否存在两种主要方法？ 只有他们的论点不同，如：

public static void main(String[] args)

，第二个可以是

public static void main(StringSecond[] args)

如果可能，哪个方法将用作入口点？ 怎么识别这个？请帮忙。

17 个答案:

答案 0 :(得分：25)

在这里，您可以看到单个文件中有2个public static void main (String args[])，名称为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，我们无法运行它，因为它赢了＆＃ 39;找到名为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方法，我们必须从其他类中显式调用它。

答案 1 :(得分：24)

只要方法参数（数字（或）类型）不同，是的，它们就可以。它被称为overloading。

  

重载方法由传递给方法

的参数的数量和类型区分 
public static void main(String[] args)

只有使用单String[]（或）String...作为参数的主方法才会被视为该程序的入口点。

答案 2 :(得分：7)

单个程序中可以有多个主方法。其他是重载方法。 这个重载方法在单个主方法

下工作正常 
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);
   }
}

答案 3 :(得分：5)

只要StringSecond是一个类，那就是可编译的代码。但是，如果通过“主要方法”表示进入该计划的第二个入口点，那么您的问题的答案仍然是否定的。只有第一个选项（public static void main(String[] args)）可以作为您程序的入口点。

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

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

答案 4 :(得分：4)

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

答案 5 :(得分：2)

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

答案 6 :(得分：1)

enter image description here

情况：1>我们有两个主要方法，但使用“ Main”和“ main2”，因此jvm仅是=调用“ main”方法。

2>相同的方法，但是使用了diff params，仍然是jvm调用“ main（String [] args）”方法。

3>完全相同的方法，但是由于您在一个类中不能同时使用两个相同的名称方法，因此它会产生差错时间错误！

希望它会给你清晰的图片

答案 7 :(得分：1)

是的，您可以根据需要使用多种主要方法。您可以使用与main(String[])签名不同的主要方法，这称为重载，JVM将忽略这些主要方法。

public class TwoMain {
    public static void main(String args1[])
    {
        System.out.println("First main");
    }

    public static void main(String args2[])
    {
        System.out.println("Second main");
    }
}

答案 8 :(得分：1)

是的，可以在同一个程序中有两个main（）。例如，如果我有一个类Demo1如下。编译此文件将生成Demo1.class文件。一旦你运行它，它将默认运行具有String参数数组的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

答案 9 :(得分：1)

主要方法的签名必须是

public static void main(String[] args)
  • 参数的名称可以是任何有效名称
  • 静态和公共关键字的位置可以互换
  • String数组也可以使用varargs语法

一个类可以定义名为main的多个方法。 这些方法的签名与main方法的签名不匹配。具有不同签名的这些其他方法不被视为＆＃34; main＆＃34;方法

答案 10 :(得分：0)

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

答案 11 :(得分：0)

以下代码在文件＆＃34; Locomotive.java ＆＃34;将成功编译并运行，执行结果显示

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

答案 12 :(得分：0)

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

例如：-public class E {

var largestResult = largest(int1, int2, num3, num4, num5);
var smallestResult = smallest(int1, int2, num3, num4, num5);
var sumResult = sum(int1, int2, num3, num4, num5);

}

上述程序的输出将是“Print B”，因为只有主方法包含由Javac编译器识别的正确方法签名，并且它仅编译并离开其余部分。

答案 13 :(得分：0)

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

  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)的方法，因此实际执行是从公共静态void main（String [] args）开始的，因此，(String[] args)的main方法必须位于一个类，除非它不是一个子类。

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

以下是有关该视频的详细视频： https://www.youtube.com/watch?v=Qlhslsluhg4&feature=youtu.be

答案 14 :(得分：0)

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

答案 15 :(得分：0)

答案是否定的;只有一个“主要”方法 - “主要”意味着你可以“运行”的入口点。

您可以像示例中那样对重载版本进行编码，但它们无法“运行”。

答案 16 :(得分：-1)

我已经检查了java版本1.6.0_32多个main方法正在工作但是应该有一个主要方法，如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);
}
}
相关问题
最新问题