The Application trait can be used to quickly turn objects
into executable programs, but is not recommended.
Here is an example:
object Main extends Application {
Console.println("Hello World!")
}
Here, object Main inherits the main method
of Application. The body of the Main object
defines the main program. This technique does not work if the main
program depends on command-line arguments (which are not accessible
with the technique presented here).
It is possible to time the execution of objects that inherit from class
Application by setting the global scala.time
property. Here is an example for benchmarking object Main:
java -Dscala.time Main
In practice the Application trait has a number of serious
pitfalls:
Threaded code that references the object will block until static
initialization is complete. However, because the entire execution of an
object extending Application takes place during
static initialization, concurrent code will always deadlock if
it must synchronize with the enclosing object.
As described above, there is no way to obtain the
command-line arguments because all code in body of an object
extending Application is run as part of the static initialization
which occurs before Application's main method
even begins execution.
Static initializers are run only once during program execution, and
JVM authors usually assume their execution to be relatively short.
Therefore, certain JVM configurations may become confused, or simply fail to
optimize or JIT the code in the body of an object extending
Application. This can lead to a significant
performance degradation.
Instead, it is recommended to define a main method explicitly:
object Main {
def main(args: Array[String]) {
//..
}
}
Inherits
AnyRef
Any
Value Members
defequals(arg0: Any): Boolean
This method is used to compare the receiver object (this)
with the argument object (arg0) for equivalence
This method is used to compare the receiver object (this)
with the argument object (arg0) for equivalence.
It is reflexive: for any instance x of type Any,
x.equals(x) should return true.
It is symmetric: for any instances x and y of type
Any, x.equals(y) should return true if and only
if y.equals(x) returns true.
It is transitive: for any instances
x, y, and z of type AnyRef
if x.equals(y) returns true and
y.equals(z) returns
true, then x.equals(z) should return true.
If you override this method, you should verify that
your implementation remains an equivalence relation.
Additionally, when overriding this method it is often necessary to
override hashCode to ensure that objects that are
"equal" (o1.equals(o2) returns true)
hash to the same Int
(o1.hashCode.equals(o2.hashCode)).
arg0
the object to compare against this object for equality.
returns
true if the receiver object is equivalent to the argument; false otherwise.
definition classes: AnyRef ⇐ Any
valexecutionStart: Long
The time when execution of this program started
The time when execution of this program started.
defhashCode(): Int
Returns a hash code value for the object
Returns a hash code value for the object.
The default hashing algorithm is platform dependent.
Note that it is allowed for two objects to have identical hash
codes (o1.hashCode.equals(o2.hashCode)) yet not be
equal (o1.equals(o2) returns false). A
degenerate implementation could always return 0.
However, it is required that if two objects are equal
(o1.equals(o2) returns true) that they
have identical hash codes
(o1.hashCode.equals(o2.hashCode)). Therefore, when
overriding this method, be sure to verify that the behavior is
consistent with the equals method.
The
Applicationtrait can be used to quickly turn objects into executable programs, but is not recommended. Here is an example:object Main extends Application { Console.println("Hello World!") }Here, object
Maininherits themainmethod ofApplication. The body of theMainobject defines the main program. This technique does not work if the main program depends on command-line arguments (which are not accessible with the technique presented here).It is possible to time the execution of objects that inherit from class
Applicationby setting the globalscala.timeproperty. Here is an example for benchmarking objectMain:In practice the
Applicationtrait has a number of serious pitfalls:objectextendingApplicationtakes place during static initialization, concurrent code will always deadlock if it must synchronize with the enclosing object.objectextendingApplicationis run as part of the static initialization which occurs beforeApplication'smainmethod even begins execution.objectextendingApplication. This can lead to a significant performance degradation.Instead, it is recommended to define a
mainmethod explicitly:object Main { def main(args: Array[String]) { //.. } }