¿podemos tener main() en una interfaz y diferentes implementaciones para main() en las clases que implementan esta interfaz?

Question

Sé que main() puede estar sobrecargado en una clase con el compilador tomando siempre el que tiene String[] args como argumentos como el método principal desde donde se inicia la ejecución. Sin embargo, es posible declarar la misma

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

Por ejemplo,

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, no puede, porque main tiene que ser estático para poder usarse como punto de entrada, y las interfaces no permiten el uso de estática.

Answer 2

esto es un error de compilación. no puede anular una interfaz no estática un método estático

Answer 3

Creo que le falta algo. Los métodos estáticos (como el método principal en Testclass1 y Testclass2) no pueden anular los métodos de las subclases.

Answer 4

Hay dos respuestas para su pregunta.

1. En primer lugar, no se puede tener static métodos de una Interface
2. Sí se puede sobrecargar main() método, pero al iniciar la clase, sólo el método public static void main(String args[]){} será tratado como un punto de entrada.

Por ejemplo

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

Al iniciar la clase anterior, la salida será "entry point"

Answer 5

No estoy seguro, pero usted puede tener múltiples métodos principales en múltiples clases (no la misma clase). Comenzamos el programa con el nombre de la clase cuyo método principal queremos ejecutar. Entonces, después de eso, JVM buscará el método principal solo en esa clase. Entonces no debería haber ningún problema.

No estoy seguro, por favor avíseme si me equivoco.

Answer 6

Puede crear su propio mecanismo de inicio, pero no estoy seguro de por qué lo desea.

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: No es necesario tener un método main(), p. Ej.

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

compila y se ejecuta sin error.

Answer 7

declaraste main (String [] args) como static en Testclass1, pero en la interfaz "test" no es estática y la interfaz no permite main (String [] args) como estática. Aunque anulas main (String [] args) en Testcalss1 como no estático, no está permitido, porque main (String args) ya está definido en Testclass1.so que no se puede declarar main (String [] args) en la interfaz. Y se hace un error más se está inicializando la prueba de interfaz como t.No puedes hacer eso.

Answer 8

Con Java-8 puede tener el método principal definido dentro de la interfaz, a continuación el código funcionará en 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() es static.so, no podemos sobreescribir methods.Interfaces estáticas permite métodos abstractos métodos & que se llevarán a cabo en subclasses.So, métodos abstractos no sean static.finally llegué a la conclusión de que main() es no es posible ejecutar en las interfaces.

Answer 10

Respuesta: Sí, podemos proporcionar diferentes implementaciones de main() declaradas en una interfaz y las clases que implementan esa interfaz anulando el método y pueden sobrecargar el método principal estático si está definido en una interfaz.

Algunos más información sobre cambios en la interfaz en Java 8.

Antes de Java 8, no fue posible definir los métodos dentro de la interfaz.

Pero hay cambios en Java 8 con respecto a la interfaz donde se puede DEFINIR el método predeterminado y estático dentro de una interfaz. Por lo tanto, el código siguiente funcionará bien sin ningún problema.

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

Para obtener información con respecto a esta funciones, consulte el enlace a continuación: http://www.journaldev.com/2752/java-8-interface-changes-static-method-default-method