class - run - scala java download

Método principal en Scala

Question

Escribí una clase Scala y definí el método main() en ella. Se compiló, pero cuando lo ejecuté, obtuve NoSuchMethodError:main . En todos los ejemplos de scala, he visto, el método principal está definido en un objeto. En Java definimos el método principal en una clase. ¿Es posible definir main() en una clase Scala o siempre necesitamos un objeto para esto?

Answer 1

Como Eugene dijo en un comentario, no hay métodos estáticos en Scala. Pero mira esto:

$ cat Echo.scala
object Echo {
  def main( args:Array[String] ):Unit = args foreach println
}

$ scalac Echo.scala

$ javap Echo/$.class
Compiled from "Echo.scala"
public final class Echo$ {
  public static final Echo$ MODULE$;
  public static {};
  public void main(java.lang.String[]);
}

$ javap Echo.class
Compiled from "Echo.scala"
public final class Echo {
  public static void main(java.lang.String[]);
}

Tenga en cuenta que el archivo de clase para la clase Echo (no Echo $, el objeto) sí tiene un método principal vacío público estático. Scala genera métodos estáticos para métodos definidos en objetos para compatibilidad con Java.

Sin embargo, considero crear un método principal en un programa Scala y un anacronismo. Utilice el rasgo de la aplicación en su lugar; es más limpio

object Echo extends App {
  args foreach println
}

Answer 2

Cuando quiero probar mi código en el editor de scala de ideas inteligentes, simplemente creo un objeto complementario justo debajo de mi clase y le pongo un método principal. Eso es todo. ver un ejemplo:

class Colon {
    class Cow {
        def ^ (moon:Moon): Unit ={
        println("Cow jumped over the moon")
        }
    }
    class Moon{
        def ^:(cow:Cow) = println("This cow jumped over moon too")
    }
}
object Colon{
    def main(args: Array[String]): Unit = {
    val c:Colon = new Colon
    val cow = new c.Cow
    val moon = new c.Moon
    cow ^ moon
    cow ^: moon
    moon.^:(cow)
    }
}

Answer 3

Para responder a su pregunta, eche un vistazo a lo siguiente: Hice una clase de Scala, la compilé y descompilé, y lo que obtuve es interesante.

class MyScalaClass{
   def main(args: Array[String]): Unit = {
         println("Hello from main of class")
   }
}

Compiled from "MyScalaClass.scala"

public class MyScalaClass {
      public void main(java.lang.String[]);
      public MyScalaClass();
}

Por lo tanto, significa que cuando la clase scala se convierte en clase java, el método principal de la clase scala que a su vez se convierte en el método principal en la clase java no es estático . Y, por lo tanto, no podríamos ejecutar el programa porque JVM no puede encontrar el punto de partida en el programa.

Pero si se realiza el mismo código utilizando la palabra clave ''objeto'', entonces:

Compiling the following:

object MyScalaClass{
 def main(args: Array[String]): Unit = {
  println("Hello from main of object")
 }
}

Decompiling the following:
javap MyScalaClass$.class

Compiled from "MyScalaClass.scala"
public final class MyScalaClass$ {
 public static final MyScalaClass$ MODULE$;
 public static {};
 public void main(java.lang.String[]);
}

Decompiling the following
javap MyScalaClass.class

Compiled from "MyScalaClass.scala"
public final class MyScalaClass {
  public static void main(java.lang.String[]);
}

Así que aquí tenemos main public void static en MyScalaClass.class, por lo tanto, el método principal puede ser ejecutado directamente por la JVM aquí.

Espero que tengas tu respuesta.