为什么 java 反射将对象方法显示为实例的方法，而不是静态的？

Question

默认java控制台应用程序运行带有main方法的传递类，该方法应使用static修饰符声明。

所以，我尝试创建这样的类作为对象，而不是直接使用静态修饰符。但令人惊讶的是，我得到了没有静态修饰符的main方法。

$ scala
Welcome to Scala version 2.10.3-20130923-000000-e2fec6b28d (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_60).
Type in expressions to have them evaluated.
Type :help for more information.
scala> import java.lang.reflect.Modifier
import java.lang.reflect.Modifier
scala> object Main {
     | def main(args : Array[String]) = println("hello")
     | }
defined module Main
scala> val method = Main.getClass.getMethod("main", classOf[Array[String]])
method: java.lang.reflect.Method = public void Main$.main(java.lang.String[])
scala> Modifier.isStatic( method.getModifiers )
res0: Boolean = false

所以Main对象包含的main方法实际上不是静态的

我想使用java命令来运行scala类，而不是特定的scala命令。

如何从scala对象中获得静态主方法?

---

更新:

建议搜索具有相同名称的类，除非它没有'$'符号作为后缀。因此，我继续进行REPL会话，试图找到这个类

scala> val loader = Main.getClass.getClassLoader
loader: ClassLoader = scala.tools.nsc.interpreter.IMain$TranslatingClassLoader@fdf3a48
scala> val mc = Class.forName("Main", true, loader)
java.lang.ClassNotFoundException: Main
    at scala.tools.nsc.interpreter.AbstractFileClassLoader.findClass(AbstractFileClassLoader.scala:69)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:425)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:358)
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Class.java:270)
    at .<init>(<console>:11)
    at .<clinit>(<console>)
    at .<init>(<console>:7)
    at .<clinit>(<console>)
    at $print(<console>)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:734)
    at scala.tools.nsc.interpreter.IMain$Request.loadAndRun(IMain.scala:983)
    at scala.tools.nsc.interpreter.IMain.loadAndRunReq$1(IMain.scala:573)
    at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:604)
    at scala.tools.nsc.interpreter.IMain.interpret(IMain.scala:568)
    at scala.tools.nsc.interpreter.ILoop.reallyInterpret$1(ILoop.scala:756)
    at scala.tools.nsc.interpreter.ILoop.interpretStartingWith(ILoop.scala:801)
    at scala.tools.nsc.interpreter.ILoop.reallyInterpret$1(ILoop.scala:774)
    at scala.tools.nsc.interpreter.ILoop.interpretStartingWith(ILoop.scala:801)
    at scala.tools.nsc.interpreter.ILoop.command(ILoop.scala:713)
    at scala.tools.nsc.interpreter.ILoop.processLine$1(ILoop.scala:577)
    at scala.tools.nsc.interpreter.ILoop.innerLoop$1(ILoop.scala:584)
    at scala.tools.nsc.interpreter.ILoop.loop(ILoop.scala:587)
    at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply$mcZ$sp(ILoop.scala:878)
    at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:833)
    at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply(ILoop.scala:833)
    at scala.tools.nsc.util.ScalaClassLoader$.savingContextLoader(ScalaClassLoader.scala:135)
    at scala.tools.nsc.interpreter.ILoop.process(ILoop.scala:833)
    at scala.tools.nsc.MainGenericRunner.runTarget$1(MainGenericRunner.scala:83)
    at scala.tools.nsc.MainGenericRunner.process(MainGenericRunner.scala:96)
    at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:105)
    at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)

我可能认为我需要从scala编译器utils中调用特殊函数来获得定义类的包装

---

解决:

我做了更多的实验，证实scala的行为不同于scala REPL。第一种方法为每个对象生成额外的类，该类将对象的方法作为静态的。如果您创建了一个类及其伴侣对象，那么伴侣的方法将被添加到相关的类中，而无需创建额外的代理。这适用于任何方法，甚至是那些签名与主方法签名不同的方法

Answer 1

Scala编译器创建了一个静态main方法:

$ cat Main.scala 
object Main {
  def main(args: Array[String]) = println("hello")
}
$ scalac Main.scala
$ ls *class
Main.class  Main$.class
$ javap -cp . Main
Compiled from "Main.scala"
public final class Main {
  public static void main(java.lang.String[]);
}
$ javap -cp . Main$
Compiled from "Main.scala"
public final class Main$ {
  public static final Main$ MODULE$;
  public static {};
  public void main(java.lang.String[]);
}
$ java -cp /usr/local/scala/lib/scala-library.jar:. Main
hello

Answer 2

如果你反编译这个:

package test
import java.lang.reflect.Modifier
object Main {
  def main(args: Array[String]): Unit = {
    val method = Main.getClass.getMethod("main", classOf[Array[String]])
    println(Modifier.isStatic(method.getModifiers)) // false
    println(Main.getClass.getName()); // test.Main$
    val act = Class.forName("test.Main");
    val method2 = act.getMethod("main", classOf[Array[String]])
    println(Modifier.isStatic(method2.getModifiers)) // true !!!
  }
}

你会看到两个类:

1)

public final class Main$
{
  ...
  public void main(String[] args)
  {
    ...
  }
  ...
}

2)

public final class Main
{
  public static void main(String[] paramArrayOfString)
  {
    ...
  }
}

Answer 3

我将删除这个答案，一旦真正的一个显示，但这不是说scala没有静态方法，问题是错误的?使用Java反射进行检查:

/tmp » echo 'object Main {  def main(args : Array[String]) = println("hello") }' > Main.scala
/tmp » scalac Main.scala
/tmp » javap Main      
Compiled from "Main.scala"
public final class Main {
  public static void main(java.lang.String[]);
}