类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的模板。
1.Scala类的定义和使用
可以使用new关键字创建对象，实例Test1.scala如下：
class Point(xc:Int,yc:Int){
var x:Int = xc;
var y:Int = yc;
def move(dx:Int, dy:Int){
x = x + dx;
y = y + dy;
println("x = " + x);
println("y = " + y);
}
}
object Test1{
def main(args:Array[String]){
var point = new Point(10,20);
println("point("+point.x+","+point.y+")");
println("move(5,5):");
point.move(5,5);
}
}
编译并执行上述代码，输出结果如下：
E:\Test>scalac Test1.scala
E:\Test>scala Test1
point(10,20)
move(5,5):
x = 15
y = 25
根据上述实例，我们需要注意以下几点：
- Scala的类不声明为public，一个Scala源文件可以有多个类；
- Scala的类中可以有成员变量x，y，也可以有成员方法move；
- Scala的类定义可以有参数xc，yc，称为类参数，类参数在整个类中都可以访问;
- Scala需要使用一个类时，使用new关键字生成类对象即可；
- Scala类对象可以调用自己的成员变量和成员方法。
2.Scala类的继承
Scala继承一个基类跟Java很相似，但是需要注意以下几点：
- 重写超类的非抽象方法(override修饰的方法)必须使用override修饰符；
- 重写超类的抽象方法(没有override修饰的方法)不需要使用override修饰符；
- 只有主构造函数才可以往基类的构造函数里写参数；
下面是一个Scala继承的例子：
class Point(val xc:Int, val yc:Int){
var x:Int = xc;
var y:Int = yc;
def move(dx:Int, dy:Int){
x = x + dx;
y = y + dy;
println("x = " + x);
println("y = " + y);
}
}
class Location(override val xc:Int, override val yc:Int, val zc:Int)
extends Point(xc,yc) {
var z:Int = zc;
def move(dx:Int, dy:Int, dz:Int) {
x = x + dx;
y = y + dy;
z = z + dz;
println("x = " + x);
println("y = " + y);
println("z = " + z);
}
}
object Test2{
def main(args:Array[String]) {
var position = new Location(10,20,30);
println("position("+position.x+","+position.y+","+position.z+")");
println("move(1,2,3):");
position.move(1,2,3);
}
}
编译并执行上述代码，输出结果如下：
E:\Test>scalac Test2.scala
E:\Test>scala Test2
position(10,20,30)
move(1,2,3):
x = 11
y = 22
z = 33
关于Scala中的继承，有以下几点需要注意：
- Scala使用extends关键字实现继承；
- 被继承的类叫做基类或父类，继承的类子类；
- 继承的类会获得父类所有的属性和方法；
- 继承的类需要使用override修饰符重写父类的类变量；
- Scala跟Java一样，不允许多继承，只能继承一个父类。
3.Scala重写父类的非抽象方法
Scala类的方法默认都是抽象的，前面没有override修饰，Scala重写一个抽象方法时，不需要使用override修饰，如前面的Test2中的move方法；Scala类的非抽象方法以override修饰，Scala重写一个非抽象方法时，也必须使用override修饰，如下面的实例：
class Person {
var name = "";
override def toString = getClass.getName + "[ name = " + name + " ]";
}
class Employee extends Person {
var salary = 0.0;
override def toString = super.toString + "[ salary = " + salary + " ]";
}
object Test3 extends App {
val fred = new Employee;
fred.name = "Fred";
fred.salary = 50000;
println(fred);
}
编译并执行上述代码，输出结果如下：
E:\Test>scalac Test3.scala
E:\Test>scala Test3
Employee[ name = Fred ][ salary = 50000.0 ]
4.Scala单例对象
在Scala中没有static修饰符，但是Scala可以使用object关键字实现单例模式。Scala在使用单例模式时，除了定义的类之外，还要定义一个同名的object对象，它和类的区别是，object对象不能带参数。当单利对象与某个类共享同一个名称时，它被称为这个类的伴生对象（companion object）；这个类被称为该单例对象的伴生类（companion class）。注意：必须在同一个源文件里定义类和它的伴生对象；类和它的伴生对象可以互相访问私有成员。
下面是一个单例对象的实例：
object Test4 {
val str:String = "this is a singleton object";
def main(args:Array[String]){
println(str);
}
}
编译并执行上述代码，输出结果如下：
E:\Test>scalac Test4.scala
E:\Test>scala Test4
this is a singleton object
下面是一个伴生对象的实例：
class Marker private(val color:String){
println("create " + this);
override def toString():String="Color is : "+color;
}
object Marker{
private val markers:Map[String,Marker]=Map(
"red"->new Marker("red"),
"green"->new Marker("green"),
"blue"->new Marker("blue")
);
def apply(color:String)={
if(markers.contains(color))
markers(color);
else
null;
}
def getMarker(color:String)={
if(markers.contains(color))
markers(color);
else
null;
}
def main(args:Array[String]) {
println(Marker("red"));
println(Marker getMarker "blue");
}
}
