Scala 的类大抵和 Java 是类似的，简单的例子如下：
class MyClass {
var myField : Int = 0;
def this(value : Int) = {
this();
this.myField = value;
}
def getMyField() : Int = {
return this.myField;
}
def addToMyField(value : Int) {
this.myField += value;
}
}
如果好奇，可以把编译后的代码反编译成Java代码看看：
import scala.reflect.ScalaSignature;
@ScalaSignature(bytes=" 06 0112A! 01 02 01 13 9Q*_"mCN 34("A 02 02 17q*W 16 35;z}
011C 01 01 07! 9!"D 01 25 05I 21!B:dC2f 27BA 06 05 31 e. 37*fM")Q 02 01C 01 35 051A( 338jiz" 22a 04 03! 01i 21A 01 05% 01 01
21" 01 24 03 35i 27PR5fY 22, 22 01 06 03 17UI!A 06 05 03 07%sG 17C 04 31 01 01 07I 21A
02 275Lh)[3mI~#S- 35 13 035u 01"aB 16
05qA! 01B+oSRDqAHf 02 02 03 07A#A 02yIEBa 01 01!B 23! 22 01C7z
&,G 16 32 21 135 01A 21 01 22 25 05= 31 03" 02 23" 01 04! 22! 02<bYV, 07" 02 24 01 039 23AC4fi6Kh)[3mIR A 03C 03* 01 21 05!& 01 07bI 22$v.T=GS 26dG
06 02 33W!)A 05 13a 01) 01")
public class MyClass
{
private int myField = 0;
public int myField() { return this.myField; }
public void myField_$eq(int x$1) { this.myField = x$1; }
public int getMyField()
{
return myField();
}
public void addToMyField(int value) {
myField_$eq(myField() + value);
}
public MyClass()
{
}
public MyClass(int value)
{
this();
myField_$eq(value);
}
}
除了ScalaSignature，其他部分再熟悉不过了。只是Scala在语法上稍作了改变，在学习了golang和swift之后，也应该习以为常了吧。
类部分虽然没有太多可说的地方，但是在对象上就有些许不同。Scala 中 object 用于构建 singleton 类型。
object Main {
def sayHi() {
println("Hi!");
}
}
在 Java 进行调用的话，就是
Main.sayHi();
之前在Java中写过Singleton代码的话，很容易猜出来具体的实现。反编译的代码：
import scala.reflect.ScalaSignature;
@ScalaSignature(bytes=" 06 01e9Q! 01 02 02 25 A!T1j]* 1!A 04=K6 04H/ 37 04 01A 21aaB 07 02 05 31) 01B 01E 01 23 !Q*Y5o' 9! 02 05 02f 355 ABC 01 16 03 25 318- 317b 23 yAB 01 04B]f 24VM 32 05 06# 35! AE 01 07y%t 27 16 36 25 03 25AQ 01F 04 05 02U Qa]1z 21&$ 22A 06 03 27]I! 01 07 07 03 Us 27 16 36")
public final class Main
{
public static void sayHi()
{
Main..MODULE$.sayHi();
}
}
实现上来讲，只是多了一个 Main$ 类来实现具体的代码。
有了静态成员，如何添加非静态成员？Scala给出的答案是 Companion Objects，也就是定义同名 class。
object Main {
def sayHi() {
println("Hi!");
}
}
class Main {
def sayHelloWorld() {
println("Hello World");
}
}
这样一来，Main既支持静态方式调用，也支持实例化。其实在 Java 中只是一个类，包含了静态成员和非静态成员而已。
public class Main
{
public static void sayHi()
{
Main..MODULE$.sayHi();
}
public void sayHelloWorld()
{
Predef..MODULE$.println("Hello World");
}
}
可以考虑一种情况，object 和 class 中都定义了相同名称的成员，结果会如何呢？
object Main {
def sayHi() {
println("Hi!");
}
}
class Main {
def sayHelloWorld() {
println("Hello World");
}
def sayHi() {
println("non-static hi!")
}
}
编译没有报错，结果是静态成员无法访问了。
error: non-static method sayHi() cannot be referenced from a static context
Main.sayHi();
^
1 error
静态方法被隐藏了，可以通过反编译来验证。
public class Main
{
public void sayHelloWorld()
{
Predef..MODULE$.println("Hello World");
}
public void sayHi() {
Predef..MODULE$.println("non-static hi!");
}
}
实际生成的代码中并不包含静态成员。有没有办法访问之前的静态成员呢？可以试试下面的代码：
Main$.MODULE$.sayHi();
当然，以上是Java中调用的情况，在 Scala 中是可以区分两个sayHi的。
object UseInScala {
def main(args: Array[String]) {
Main.sayHi();
var main = new Main();
main.sayHi();
}
}
输出：
> scala UseInScala Hi! non-static hi!
从这些方面来看，Scala 的代码是极容易引入到 Java 中的，下一步可能会花些功夫在 Scala 的学习和应用上。
［1］http://tutorials.jenkov.com/scala/singleton-and-companion-objects.html