类是一个对象的蓝图。一旦定义一个类可以创建从类蓝图使用关键字new创建对象。下面是一个简单的语法在Scala中定义一个类：

1. class Yiibai(xc: Int, yc: Int) { 
2.    var x: Int = xc 
3.    var y: Int = yc 
4.  
5.    def move(dx: Int, dy: Int) { 
6.       x = x + dx 
7.       y = y + dy 
8.       println ("Yiibai x location : " + x); 
9.       println ("Yiibai y location : " + y); 
10.    } 
11. } 

这个类定义了两个变量x和y和方法：move，没有返回值。类变量被调用，类的字段和方法被称为类方法。

类名可以作为一个类的构造函数，可以采取一些参数。上面的代码定义了两个构造函数的参数：xc和yc;它们都在类的主体内可见。

正如前面提到的，可以使用关键字new创建对象，然后可以按照下面的例子所示访问类的字段和方法：

1. import java.io._ 
2.  
3. class Yiibai(val xc: Int, val yc: Int) { 
4.    var x: Int = xc 
5.    var y: Int = yc 
6.    def move(dx: Int, dy: Int) { 
7.       x = x + dx 
8.       y = y + dy 
9.       println ("Yiibai x location : " + x); 
10.       println ("Yiibai y location : " + y); 
11.    } 
12. } 
13.  
14. object Test { 
15.    def main(args: Array[String]) { 
16.       val pt = new Yiibai(10, 20); 
17.  
18.       // Move to a new location 
19.       pt.move(10, 10); 
20.    } 
21. } 

当上述代码被编译和执行时，它产生了以下结果：

1. C:/>scalac Test.scala 
2. C:/>scala Test 
3. Yiibai x location : 20 
4. Yiibai y location : 30 
5.  
6. C:/> 

扩展一个类：

可以扩展scala类以类似的方式，如在Java中的一样，但有两个限制：方法重载需要override关键字，只有主构造可以传递参数给基构造。现在扩展上面的类，并增加一个类的方法：

1. class Yiibai(val xc: Int, val yc: Int) { 
2.    var x: Int = xc 
3.    var y: Int = yc 
4.    def move(dx: Int, dy: Int) { 
5.       x = x + dx 
6.       y = y + dy 
7.       println ("Yiibai x location : " + x); 
8.       println ("Yiibai y location : " + y); 
9.    } 
10. } 
11.  
12. class Location(override val xc: Int, override val yc: Int, 
13.    val zc :Int) extends Yiibai(xc, yc){ 
14.    var z: Int = zc 
15.  
16.    def move(dx: Int, dy: Int, dz: Int) { 
17.       x = x + dx 
18.       y = y + dy 
19.       z = z + dz 
20.       println ("Yiibai x location : " + x); 
21.       println ("Yiibai y location : " + y); 
22.       println ("Yiibai z location : " + z); 
23.    } 
24. } 

extends子句有两种作用：它使类Location继承类Yiibai所有非私有成员，它使Location类作为Yiibai类的子类。 因此，这里的Yiibai类称为超类，而Location类被称为子类。扩展一个类，继承父类的所有功能，被称为继承，但scala允许继承，只能从一个唯一的类。让我们看看完整的例子，显示继承的用法：

1. import java.io._ 
2.  
3. class Yiibai(val xc: Int, val yc: Int) { 
4.    var x: Int = xc 
5.    var y: Int = yc 
6.    def move(dx: Int, dy: Int) { 
7.       x = x + dx 
8.       y = y + dy 
9.       println ("Yiibai x location : " + x); 
10.       println ("Yiibai y location : " + y); 
11.    } 
12. } 
13.  
14. class Location(override val xc: Int, override val yc: Int, 
15.    val zc :Int) extends Yiibai(xc, yc){ 
16.    var z: Int = zc 
17.  
18.    def move(dx: Int, dy: Int, dz: Int) { 
19.       x = x + dx 
20.       y = y + dy 
21.       z = z + dz 
22.       println ("Yiibai x location : " + x); 
23.       println ("Yiibai y location : " + y); 
24.       println ("Yiibai z location : " + z); 
25.    } 
26. } 
27.  
28. object Test { 
29.    def main(args: Array[String]) { 
30.       val loc = new Location(10, 20, 15); 
31.  
32.       // Move to a new location 
33.       loc.move(10, 10, 5); 
34.    } 
35. } 

需要注意的是方法move，不会覆盖 move 方法相应的定义，因为它们是不同的定义（例如，前两个参数，而后者则需要三个参数）。
让我们编译和运行上面的程序，这将产生以下结果：

1. C:/>scalac Test.scala 
2. C:/>scala Test 
3. Yiibai x location : 20 
4. Yiibai y location : 30 
5. Yiibai z location : 20 
6.  
7. C:/> 

单例对象：

Scala比Java更面向对象，因为在Scala中不能有静态成员。相反，Scala有单例的对象。单例就是只能有一个实例，即，类的对象。可以使用关键字object代替class关键字，而不是创建单例。因为不能实例化一个单独的对象，不能将参数传递给主构造。前面已经看到全部采用单一对象，调用Scala的main方法的例子。以下是单例显示的相同的例子：

当上述代码被编译和执行时，它产生了以下结果：

1. C:/>scalac Test.scala 
2. C:/>scala Test 
3. Yiibai x location : 10 
4. Yiibai y location : 20 
5.  
6. C:/>