Possono esistere due metodi principali in un programma Java?

Question

Esistono due metodi principali in un programma Java? Solo dalla differenza nelle loro argomentazioni come:

e secondo può essere

public static void main(StringSecond[] args) 

Se è possibile, quale metodo verrà utilizzato come punto di ingresso? Come identificare questo? per favore aiuto.

Answer 1

Fintanto che i parametri del metodo (numero (o) tipo) sono diversi, sì, possono. Si chiama overloading.

metodi overload si differenziano per il numero e la tipologia degli argomenti passato nel metodo

unico metodo principale con singolo String[] (o) String... come param sarà considerata come punto di ingresso per il programma.

Answer 2

Conteggi solo public static void main(String[] args). Questa è l'unica firma considerata come vera main() (come il punto di ingresso del programma, intendo).

Answer 3

Questo sarebbe codice compilabile, purché StringSecond fosse una classe. Tuttavia, se per "metodo principale" intendi un secondo punto di accesso al programma, la risposta alla tua domanda è ancora no. Solo la prima opzione (public static void main(String[] args)) può essere il punto di ingresso nel programma.

Nota, tuttavia, se si dovesse collocare un secondo metodo main(String[]) in una classe diversa (ma nello stesso progetto), si potrebbero avere più punti di ingresso possibili nel progetto da cui scegliere. Ma questo non può essere in conflitto con i principi di sovrascrittura o sovraccarico.

noti inoltre che una fonte di confusione in quest'area, specialmente per i programmatori introduttiva, è che public static void main(String[] args) e public static void main(String ... args) sono entrambi usati come punti di entrata e vengono trattati come aventi la stessa firma.

Answer 4

La risposta è no; può esistere solo un metodo "principale" - dove "principale" indica un punto di ingresso che è possibile "eseguire".

È possibile codificare le versioni sovraccaricate come nell'esempio, ma non possono essere "eseguite".

Answer 5

Ci possono essere più di un metodo principale in un singolo programma. Altri sono metodo di overload. Questo metodo di overload funziona bene sotto un unico metodo 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 6

Non ci può essere più di un metodo principale in un unico programma. Ma JVM chiamerà sempre String argomento argomento main(). Gli altri metodi fungeranno da metodo Overloaded. Questi metodi sovraccarichi dobbiamo chiamare esplicitamente.

Answer 7

la possibilità di due metodi principali (String [] args) all'interno dello stesso ambito creano confusione per JVM. Non riesce a usarli come metodi sovraccaricati. Quindi le firme in termini di parametri) devono essere diverse.

Answer 8

In Java, si può avere solo uno public static void main(String[] args)per classe. Il che significa, se il tuo programma ha più classi, ogni classe può averepublic static void main(String[] args). Vedi JLS per i dettagli.

Answer 9

ho il check in java versione 1.6.0_32 il metodo principale multiplo funziona ma dovrebbe esserci un metodo principale come public static void main (String [] args) di tipo signature. Ex è qui che ho provato.

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 10

Qui si può vedere che ci sono 2 public static void main (String args[]) in un unico file con il nome Test.java (in particolare non ha utilizzato il nome del file come uno dei nomi di 2 classi) e le 2 classi sono con il default identificatore di accesso.

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

Quando si compila il codice Test.java che genererà 2 .class file (viz Sum.class e DefClass.class) e se corriamo Test.java non possiamo eseguirlo come non troverà alcuna classe principale con il nome Test. Invece se facciamo java Sum o java DefClass entrambi forniranno uscite differenti usando diversi main(). Per utilizzare il metodo principale della classe Sum, è possibile utilizzare il nome della classe Sum.main(null) o Sum.main(1)//Passing integer value in the DefClass main().

In ambito classe, è possibile avere un solo public static void main (String args[]) per classe poiché un metodo statico di una classe appartiene a una classe e non ai suoi oggetti e viene chiamato utilizzando il nome della classe. Anche se creiamo oggetti multipli e chiamiamo gli stessi metodi statici che li usano, allora l'istanza del metodo statico a cui queste chiamate faranno riferimento sarà la stessa.

Possiamo anche fare l'overloading del metodo main passando diversi set di argomenti nel main. L'esempio simile è fornito nel codice precedente ma, per impostazione predefinita, il flusso di controllo inizierà con public static void main (String args[]) del file di classe che abbiamo richiamato utilizzando java classname. Per invocare il metodo principale con un altro insieme di argomenti, dobbiamo chiamarlo esplicitamente da altre classi.

Answer 11

La firma del metodo main deve essere

public static void main(String[] args) 

• il nome del parametro può essere qualsiasi nome valido
• Le posizioni di parole chiave statiche e pubbliche possono essere scambiati
• L'array String può usare anche la sintassi varargs

Una classe può definire più metodi con il nome principale. La firma di questi metodi non corrisponde alla firma del metodo principale. Questi altri metodi con diverse firme non sono considerati il ​​metodo "principale".

Answer 12

Sì, è possibile avere due main() nello stesso programma. Ad esempio, se ho una classe Demo1 come sotto. La compilazione di questo file genererà il file Demo1.class. E una volta eseguito questo, verrà eseguito il main() con array di argomenti String per impostazione predefinita. Non annuserà nemmeno l'argomento 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 

Ma se aggiungo un'altra classe denominata Anonym e salvo il file come Anonym.java.All'interno di questo chiamo la classe Demo1 main() [argomento int o argomento stringa uno]. Dopo aver compilato questo file Anonym.class viene generato.

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 13

Il seguente codice nel file "Locomotive.java" verrà compilare ed eseguire con successo, con i risultati di esecuzione che mostra

2<SPACE> 

Come accennato nel post sopra, le regole sovraccarico funzionano ancora per il metodo principale. Tuttavia, il punto ingresso è il famoso PSVM (void main (String [] args public static))

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