2011-01-20 17 views
11

Mi chiedevo quale effetto avrebbe avuto la creazione di ulteriori metodi principali sul codice.Metodi multipli main() in java

Ad esempio,

public class TestClass { 
    public static void main (String[] args){ 
     TestClass foo = new TestClass(); 
    } 
} 

dopo l'avvio iniziale up, verrà creato foo e sarebbe altro metodo principale pubblico interno. Ciò causerà errori?

risposta

32

Non causerà errori. Solo perché tu inizializzi un oggetto, non significa che il metodo principale viene eseguito. Java sarà solo inizialmente chiamare il metodo principale della classe passato a esso, come

>java TestClass

Tuttavia, fare qualcosa di simile:

public class TestClass 
{ 
public static void main (String[] args) 
{ 
    TestClass foo = new TestClass(); 
    foo.main(args); 
} 
} 

O

public class TestClass 
{ 
public TestClass() 
{ 
    //This gets executed when you create an instance of TestClass 
    main(null); 
} 

public static void main (String[] args) 
{ 
    TestClass foo = new TestClass(); 
} 
} 

Quello causerebbe un StackOverflowError, perché sei exp lecitamente chiamando il metodo principale di TestClass, che poi chiama il metodo principale ancora, e ancora, e ancora, e ....

In caso di dubbio, basta provarlo fuori :-)

+0

Parole sagge: D Grazie! – guy8214

5

Questo va perfettamente bene. Avere più metodi main non causa alcun problema. Quando si avvia per la prima volta un programma Java, l'esecuzione inizia nella della funzione denominata main in una classe specificata dall'utente o dal file .jar. Una volta avviato il programma, tutte le altre funzioni chiamate main vengono essenzialmente ignorate o trattate come altre funzioni.

+0

Penso che l'OP si chieda se i metodi principali vengano ricreati ogni volta che un oggetto di tale classe viene istanziato anziché avere più metodi principali dichiarati nello stesso ambito. – berry120

+0

Penso che potrebbe essere interpretato in entrambi i modi, e avere entrambe le spiegazioni è utile. Solo la mia opinione, ovviamente. – duffymo

+0

Abbastanza corretto, sono d'accordo che avere entrambe le spiegazioni è comunque utile. È proprio come l'ho letto per la prima volta :-) – berry120

3

No, è possibile avere un numero qualsiasi di metodi principali in un progetto. Dal momento che si specifica quale si desidera utilizzare quando si avvia il programma, questo non causa alcun conflitto.

+0

_se ho più main_ ** come specificare quale usare per primo? ** –

6

Non avrà un ulteriore main -metodo, come main è static. Quindi è una volta per classe.

Se si dispone di più metodi main nel progetto, verrà specificato quale avviare all'avvio dell'applicazione.

10

Il metodo principale è statico, il che significa che appartiene alla classe anziché all'oggetto. Quindi l'oggetto non avrà affatto un altro metodo principale al suo interno.

È possibile chiamare il metodo principale su istanze dell'oggetto, ma se lo si fa è letteralmente solo un altro modo di chiamare TestClass.main() (ed è disapprovato da molti, me compreso, chiamare un metodo statico su un'istanza di un oggetto comunque.)

Se ci si riferisce a più metodi principali nello stesso programma, anche questo non è un problema. La classe principale viene semplicemente specificata e il suo metodo principale viene eseguito per avviare il programma (nel caso di un file jar questo è l'attributo della classe principale nel file manifest.)

4

Dopo la ricerca di una Java Classe con più metodi main() o in parole semplici, metodi main() sovraccaricati, ho trovato un mio esempio.Si prega di dare un'occhiata

public class MultipleMain{ 

    public static void main(String args[]){ 
     main(1); 
     main('c'); 
     main("MyString"); 
    } 

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

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

}

Ho provato questo codice Java JDK 1.7 e funziona come un fascino!

È necessario "public static void main (String args [])" per iniziare e quindi è possibile chiamare i metodi main sovraccaricati all'interno di questo main e dovrebbe funzionare con certezza.

Qualsiasi commento e suggerimento sono molto apprezzati. Sono solo uno sviluppatore Java principiante disposto a sviluppare le mie competenze Java.

Grazie, PK

+0

Ho anche provato qualcosa di simile. Anche se abbiamo un metodo principale multiplo ma il metodo principale con argomento (String args []) viene eseguito per primo_. ** Esiste un modo per eseguire prima un altro metodo principale? ** –

+1

@RishabhAgarwal Il runtime Java cerca il metodo * main con (String args []) * quando la classe con il metodo main viene caricata. Non sono a conoscenza di alcun meccanismo per sovrascriverlo. – realPK

0

quando si esegue la classe Java che sarà sempre cercare la firma static void main pubblici (String args []) nella classe. Quindi supponiamo che se invochi l'argomento della riga di comando , cercherà il metodo Signature nella classe e non invocherà altro finché non lo invierà esplicitamente in base al suo nome di classe.

class MainMethod1{ 
public static void main(String[] ags){ 
    System.out.println("Hi main 1"); 
    testig2 y = new testig2(); 
//in this case MainMethod1 is invoked/....... 
// String[] a = new String[10]; 
// testig2.main(a); 
    } 

} 
class MainMethod2{ 
    public static void main(String[] ags){ 
    System.out.println("Hi main 2"); 
    } 
} 

Ma quando si prova lo stesso da eclissi si chiederà quale classe per la compilazione. Significa MainMethod1 o Mainmethod2. Pertanto, se la classe ha la firma esatta, può essere utilizzata come punto di accesso individuale per avviare l'applicazione. Venendo alla tua domanda, Se rimuovi la firma come hai fatto sopra cambiando l'argomento se il metodo principale. Funzionerà come un metodo normale.

1

si può avere solo un metodo principale di una classe, ma si può chiamare un metodo principale per l'altro esplicitamente

class Expmain 
{ 
    public static void main(String[] ar) 
    { 
     System.out.println("main 1"); 
    } 
} 

class Expmain1 
{ 
    public static void main(String[] ar) 
    { 
     System.out.println("main 2"); 
     Expmain.main(ar); 
    } 
} 
0

E 'tutta una questione di motore di esecuzione della JVM. Ricorda, scrivi >java com.abc.MainClass sul prompt di cmd.

Spiega tutto. Se il metodo principale non viene trovato qui genera un tempo di esecuzione Errore: Metodo principale non trovato nella classe MainClass. Ora, se il metodo principale viene trovato qui, funge da primo punto quando i contatori del programma devono mappare e avviare l'esecuzione delle istruzioni. Le classi referte vengono caricate, quindi i metodi riferiti possono essere chiamati usando le istanze create all'interno. Quindi, main è specifico per una classe sebbene una classe possa avere solo un metodo principale. Nota: la firma del metodo principale non cambia mai. È possibile avere due metodi principali sovraccarico in stessa classe, come

public static void main(String[] args) {}

public static void main() {} //overloaded in same class.

Durante vincolante statico, il principale originale viene risolto e identificato da motore di esecuzione.

0

Un altro punto interessante da considerare è un caso in cui si hanno due classi differenti nel file java.

Ad esempio, si dispone di un file Java con due classi:

public class FirstClassMultiply { 

    public static void main (String args[]){ 
     System.out.println("Using FirstClassMultiply"); 
     FirstClassMultiply mult = new FirstClassMultiply(); 
     System.out.println("Multiple is :" + mult.multiply(2, 4)); 
    } 
    public static void main (int i){ 
     System.out.println("Using FirstClassMultiply with integer argument"); 
     FirstClassMultiply mult = new FirstClassMultiply(); 
     System.out.println("Multiply is :" + mult.multiply(2, 5)); 
    } 

    int multiply(int a, int b) { 
     return (a * b); 
    } 
} 

class SecondClass { 

    public static void main(String args[]) { 
     System.out.println("Using SecondClass"); 

     FirstClassMultiply mult = new FirstClassMultiply(); 
     System.out.println("Multiply is :" + mult.multiply(2, 3)); 

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

compilazione con javac FirstClassMultiply.java genererà due .class file, prima è FirstClassMultiply.class e secondo è SecondClass.class

E al fine di eseguire sarà necessario farlo per i file .class generati: java FirstClassMultiply e java SecondClass, non il file del nome file originale.

Si prega di notare un paio di punti aggiuntivi:

  1. Sarete in grado di eseguire SecondClass.class anche se di classe non era pubblica nel file originale!
  2. FirstClassMultiplyoverloading del metodo principale di è tutto bene, ma, il unico punto di ingresso al prog sarà il metodo principale con String args[] argomento.