programación - libro de programacion en java netbeans pdf

¿Pueden existir dos métodos principales en un programa Java?

Question

¿Pueden existir dos métodos principales en un programa Java? Solo por la diferencia en sus argumentos como:

public static void main(String[] args)

y segundo puede ser

public static void main(StringSecond[] args)

Si es posible, ¿qué Método se usará como punto de entrada? ¿Cómo identificar esto? por favor ayuda.

Answer 1

¡Sí! Cualquier clase en Java puede tener múltiples métodos principales. Se llama sobrecarga (los métodos sobrecargados son métodos con el mismo nombre pero con firmas diferentes) pero solo debe haber un método principal con parámetros como este: - (String [] args) o (String args [])

Por ejemplo: -clase pública 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")
}

}

El resultado del programa anterior será "Imprimir B" ya que solo ese método principal contiene la firma de método correcta identificada por el compilador Javac y solo compila y deja el resto.

Answer 2

Aquí puede ver que hay 2 public static void main (String args[]) en un solo archivo con el nombre Test.java (específicamente no usó el nombre del archivo como cualquiera de los nombres de 2 clases) y las 2 clases están con el especificador de acceso predeterminado.

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

Cuando compilamos el código Test.java generará 2 archivos .class (viz Sum.class y DefClass.class ) y si ejecutamos Test.java no podemos ejecutarlo ya que no encontrará ninguna clase principal con el nombre Test. En cambio, si hacemos java Sum o java DefClass ambos daremos diferentes salidas usando diferentes main() . Para usar el método principal de la clase Sum, podemos usar el nombre de clase Sum.main(null) o Sum.main(1)//Passing integer value in the DefClass main() .

En un ámbito de clase, podemos tener solo un public static void main (String args[]) por clase, ya que un método estático de una clase pertenece a una clase y no a sus objetos y se llama utilizando su nombre de clase. Incluso si creamos varios objetos y llamamos a los mismos métodos estáticos usándolos, la instancia del método estático al que se referirán estas llamadas será la misma.

También podemos sobrecargar el método principal pasando diferentes conjuntos de argumentos en el principal. El ejemplo similar se proporciona en el código anterior pero, de forma predeterminada, el flujo de control comenzará con el public static void main (String args[]) del archivo de clase que hemos invocado utilizando java classname . Para invocar el método principal con otro conjunto de argumentos, debemos llamarlo explícitamente desde otras clases.

Answer 3

El siguiente código en el archivo " Locomotive.java " se compilará y se ejecutará correctamente, con los resultados de ejecución que muestran

2<SPACE>

Como se mencionó en la publicación anterior, las reglas de sobrecarga aún funcionan para el método principal. Sin embargo, el punto de entrada es el famoso 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 4

En Java, puede tener solo un public static void main(String[] args) por clase . Lo que significa que, si su programa tiene múltiples clases, cada clase puede tener public static void main(String[] args) . Ver JLS para más detalles.

Answer 5

Ese sería un código compilable, siempre que StringSecond fuera una clase. Sin embargo, si por "método principal" te refieres a un segundo punto de entrada en el programa, entonces la respuesta a tu pregunta sigue siendo no. Solo la primera opción ( public static void main(String[] args) ) puede ser el punto de entrada a su programa.

Tenga en cuenta, sin embargo, que si tuviera que colocar un segundo método main(String[]) en una clase diferente (pero en el mismo proyecto), podría tener múltiples puntos de entrada posibles en el proyecto, de los cuales podría elegir. Pero esto no puede entrar en conflicto con los principios de anulación o sobrecarga.

También tenga en cuenta que una fuente de confusión en esta área, especialmente para los programadores introductorios, es que public static void main(String[] args) y public static void main(String ... args) se usan como puntos de entrada y se tratan como teniendo la misma firma de método

Answer 6

La firma del método principal debe ser

public static void main(String[] args) 

• El nombre del parámetro puede ser cualquier nombre válido
• Las posiciones de las palabras clave estáticas y públicas se pueden intercambiar
• La matriz String puede usar también la sintaxis varargs

Una clase puede definir múltiples métodos con el nombre main. La firma de estos métodos no coincide con la firma del método principal. Estos otros métodos con diferentes firmas no se consideran el método "principal".

Answer 7

La respuesta es Sí, pero debes considerar los siguientes 3 puntos.

1. No hay dos parámetros del método principal deben ser los mismos

   P.ej.

   • 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. El método principal real de Java es el que tiene (String[] args) , por lo que la ejecución real comienza desde public static void main (String [] args), por lo que el método principal con (String[] args) es obligatorio en una clase a menos que no es una clase infantil.

3. Para que se ejecuten otros métodos principales, debe llamarlos desde el método principal (String[] args) .

Aquí hay un video detallado sobre lo mismo: https://www.youtube.com/watch?v=Qlhslsluhg4&feature=youtu.be

Answer 8

La respuesta es no; solo puede haber un método "principal", donde "principal" significa un punto de entrada que puede "ejecutar".

Puede codificar versiones sobrecargadas como en su ejemplo, pero no pueden "ejecutarse".

Answer 9

Puede haber más de un método principal en un solo programa. Otros son método sobrecargado. Este método sobrecargado funciona bien bajo un solo método principal

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 10

Puede haber más de un método principal en un solo programa. Pero JVM siempre llama al método String [] argument main (). El otro método actuará como un método Sobrecargado. Estos métodos sobrecargados tenemos que llamar explícitamente.

Answer 11

Sí, es posible tener dos main () en el mismo programa. Por ejemplo, si tengo una clase Demo1 como la siguiente. La compilación de este archivo generará el archivo Demo1.class. Y una vez que ejecute esto, ejecutará main () teniendo una matriz de argumentos de cadena por defecto. Ni siquiera va a olfatear el argumento main () con int.

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

Pero si agrego otra clase llamada Anonym y guardo el archivo como Anonym.java. Dentro de esto llamo a la clase Demo1 main () [ya sea argumento int o argumento de cadena uno]. Después de compilar este archivo Anonym.class se genera.

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

Siempre que los parámetros del método (número (o) tipo) sean diferentes, sí pueden. Se llama overloading .

Los métodos sobrecargados se diferencian por el número y el tipo de argumentos pasados ​​al método

public static void main(String[] args)

solo el método principal con String[] simple String[] (o) String... como param se considerará como punto de entrada para el programa.

Answer 13

Solo contabiliza el public static void main(String[] args) . Esta es la única firma considerada como la verdadera main () (quiero decir, como punto de entrada al programa).

Answer 14

Tengo cheque en la versión 1.6.0_32 de Java. El método principal múltiple está funcionando, pero debería haber un método principal como public static void main (String [] args) de tipo signature. Aquí está Ex, que probé.

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

Answer 15

la posibilidad de dos métodos principales (String [] args) dentro del mismo ámbito crea confusión para la JVM. No los usa como métodos sobrecargados. Entonces las firmas en términos de parámetros) deben ser diferentes.