继承
只能有一个父类
与其他支持面向对象的语言一样，Scala 也支持继承，并且子类只能有一个父类，不能继承于多个父类，如果希望实现类似继承多个父类的功能，应该考虑引入 trait。虽然只支持一个父类，但是父类还可以有父类，也就是爷爷类，对于类继承的层数是没有具体要求的，这几点在下面这个例子中都有体现：
scala> class A {
| }
defined class A
scala> class B {
| }
defined class B
scala> class AA extends A {
| }
defined class AA
scala> class AB extends A with B {
| }
<console>:9: error: class B needs to be a trait to be mixed in
class AB extends A with B {
^
scala> class AAA extends AA {
| }
defined class AAA
scala> class AAAA extends AAA {
| }
defined class AAAA
都继承了什么
子类继承父类时都会继承些什么呢，这里结合可见性（可见性的详细内容会在下文介绍）进行分析，先定义这样一组父子类：
scala> class Parent ( x: Int, y: String, z: Double ) {
| val xx = x
| protected val yy = y
| private val zz = z
|
| def getXX = xx
| protected def getYY = yy
| private def getZZ = zz
|
| def testYY = yy
| def testZZ = zz
| def testGetYY = getYY
| def testGetZZ = getZZ
| }
defined class Parent
在 Scala 类继承中，允许在子类内部直接访问父类的 public 及 protected 成员及方法，但不允许子类直接访问父类的 private 成员及方法，如下例：
scala> class Child1 ( x: Int, y: String, z: Double ) extends Parent(x, y, z ) {
| println( xx )
| println( yy )
| println( getXX )
| println( getYY )
| }
defined class Child1
scala> class Child2 ( x: Int, y: String, z: Double ) extends Parent(x, y, z ) {
| println( zz )
| println( getZZ )
| }
<console>:9: error: value zz in class Parent cannot be accessed in Child2
println( zz )
^
<console>:10: error: method getZZ in class Parent cannot be accessed in Child2
println( getZZ )
^
在类外部，只有 public 的方法和成员能被直接访问，protected 及 private 均不予许：
scala> class Child3 ( x: Int, y: String, z: Double ) extends Parent(x, y, z ) {
| }
defined class Child3
scala> val child = new Child3( 1, "hello", 3.1415926 )
child: Child3 = Child3@39529185
scala> child.xx
res6: Int = 1
scala> child.yy
<console>:11: error: value yy in class Parent cannot be accessed in Child3
Access to protected value yy not permitted because
enclosing object $iw is not a subclass of
class Parent where target is defined
child.yy
^
scala> child.zz
<console>:11: error: value zz in class Parent cannot be accessed in Child3
child.zz
^
scala>
scala> child.getXX
res9: Int = 1
scala> child.getYY
<console>:11: error: method getYY in class Parent cannot be accessed in Child3
Access to protected method getYY not permitted because
enclosing object $iw is not a subclass of
class Parent where target is defined
child.getYY
^
scala> child.getZZ
<console>:11: error: method getZZ in class Parent cannot be accessed in Child3
child.getZZ
^
但我们可以通过父类提供的方法来间接访问 protected 和 private 的成员和方法：
scala> child.testYY
res20: String = hello
scala> child.testZZ
res21: Double = 3.1415926
scala> child.testGetYY
res22: String = hello
scala> child.testGetZZ
res23: Double = 3.1415926
单例对象
在 Scala 中，使用关键字 object 来定义单例对象：
scala> object T {}
defined module T
单例对象将在其首次被调用时初始化，且没有参数。单例对象一旦定义完毕，它的名字就代表了该单例对象的唯一实例。
当单例对象与某个类的名字相同且两者定义在同一文件中，就形成了特殊的单例对象-伴生对象，对应的类称为伴生类，若单例没有相同名字的类的话成为孤立对象（好惨）。我们经常使用在伴生对象中对应 apply 方法来创建新的伴生类实例并且将半身列的可见性设置为 private，以便能方便的创建伴生类实例，更重要的是可以在伴生类对象中管理所有伴生类实例，例子如下：
class Q ( qParam: String ) {
private val q = qParam
}
object Q {
private val qList = ListBuffer[ Q ]()
def apply( qParam: String ) {
val qInstance = new Q( qParam )
qList.append( qInstance )
qInstance
}
def qListSize = qList.size
}
object Test {
def main (args: Array[String]) {
val qIns1 = Q( "q1" )
val qIns2 = Q( "q2" )
println( Q.qListSize )
}
}
输出：
2
另外伴生对象与伴生类可以互相访问 private 成员和方法，object 也可以继承父类或混入特质。
