possiamo avere un main() in un'interfaccia e diverse implementazioni per main() nelle classi che implementano questa interfaccia?

Question

So che main() può essere sovraccaricato in una classe con il compilatore sempre prendendo quello con String[] args come argomenti come il metodo principale da cui inizia l'esecuzione. Ma è possibile dichiarare la stessa

main(String args[]) in an interface and implement it in different classes differently? 

Ad esempio,

package test; 
interface test 
{ 
    public void main(String args[]); 
    public void display(); 
} 



package test; 
class Testclass1 implements test 
{ 
    public void display() 
    { 
     System.out.println("hello"); 
    } 
    public static void main(String[] args) 
    { 
     test t; 
     t.display(); 
    } 
} 


package temp; 
import test.*; 
abstract class Testclass2 implements test 
{ 
    public static void main(String args[]) 
    { 
     System.out.println("TESTING"); 
    } 
} 

Answer 1

No, non è possibile, perché main deve essere statico per poter essere utilizzato come punto di ingresso e le interfacce non consentono l'uso di statico.

Answer 2

questo è un errore del compilatore. non puoi ignorare un'interfaccia non statica un metodo statico

Answer 3

Penso che manchi qualcosa. I metodi statici (come il metodo principale in Testclass1 e Testclass2) non possono sovrascrivere i metodi di sottoclasse.

Answer 4

Ci sono due risposte per la tua domanda.

1. Prima di tutto, non si può avere static metodi in Interface
2. Sì, è possibile sovraccaricare main() metodo, ma quando si avvia la classe, solo il metodo public static void main(String args[]){} verrà trattato come un punto di ingresso.

Per esempio

public class Test { 
    public static void main(String[] args) { 
     System.out.println("entry point)"); 
    } 

    public static void main(String arg1) { 
     System.out.println("overload2"); 
    } 

    public static void main(String arg1, String arg2) { 
     System.out.println("overload3"); 
    } 
} 

Quando si avvia la classe di cui sopra, l'out sarà "entry point"

Answer 5

non sono sicuro, ma si può avere più metodi principali più classi (non la stessa classe). Iniziamo il programma con il nome della classe il cui metodo principale vogliamo eseguire. Quindi dopo JVM cercherà il metodo principale solo in quella classe. Quindi non ci dovrebbero essere problemi.

Non sono sicuro, quindi fatemi sapere se ho torto.

Answer 6

è possibile creare voi proprio meccanismo di avvio, ma non so perché si vorrebbe.

public class RunTests { 
    public static void main(String... args) throws ClassNotFoundException { 
     List<Class> classes = new ArrayList<Class>(); 
     try { 
      for (String arg : args) { 
       classes.add(Class.forName(arg)); 
      } 
     } catch (ClassNotFoundException e) { 
      if (classes.isEmpty()) 
       throw e; 
     } 
     String[] remainingArgs = Arrays.asList(args).subList(classes.size(), args.length).toArray(new String[0]); 
     for(Class clazz: classes) { 
      try { 
       Test test = (Test) clazz.newInstance(); 
       test.main(remainingArgs); 
       test.display(); 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

interface Test { 
    public void main(String... args); 
    public void display(); 
} 

BTW: non è necessario avere un metodo main(), ad esempio,

class NoMain { 
    static { 
     System.out.println("Hello World"); 
     System.exit(0); 
    } 
} 

compila e funziona senza errori.

Answer 7

hai dichiarato un argomento principale (String [] args) come statico in Testclass1, ma nell'interfaccia "test" non è statico e l'interfaccia non consente l'argomento principale (String [] args) come statico. Anche se si esegue l'override principale (String [] args) in Testcalss1 come non-statico non è permesso, perché main (String args) è già definito in Testclass1.so non è possibile dichiarare main (String [] args) nell'interfaccia. E si è fatto un errore di uno in più sta inizializzando il test dell'interfaccia come t.Non puoi farlo.

Answer 8

Con Java-8 è possibile definire il metodo principale all'interno dell'interfaccia, il codice sottostante funzionerà in Java-8.

public interface TestInterfaces { 
    public static void main(String[] a){  
     System.out.println("I am a static main method inside Inteface !!"); 
    } 
} 

Answer 9

main() è static.so, non possiamo sovrascriveremo methods.Interfaces statiche permette metodi astratti metodi & saranno attuate in subclasses.So, metodi astratti mai essere static.finally conclusi che main() è non è possibile eseguire nelle interfacce.

Answer 10

Risposta: Sì, siamo in grado di fornire un'implementazione differente di main() dichiarata in un'interfaccia e classi che implementano tale interfaccia con il metodo di sovrascrittura e possono sovraccaricare il metodo principale statico se definito in un'interfaccia.

Qualche informazione in più per quanto riguarda i cambiamenti di interfaccia in Java 8.

Prima di Java 8, non è stato possibile definire metodi all'interno dell'interfaccia.

Ma ci sono modifiche apportate a Java 8 rispetto all'interfaccia in cui è possibile DEFINIRE il metodo predefinito e statico all'interno di un'interfaccia. Quindi sotto il codice funzionerà bene senza alcun problema.

public interface TestInterfaces { 
    public static void main(String[] a){  
     System.out.println("I am a static main method inside Inteface !!"); 
    } 
} 

Per informazioni su questa funzionalità, fare riferimento sotto il collegamento: http://www.journaldev.com/2752/java-8-interface-changes-static-method-default-method