ScalaScala之Classes and Properties
Posted leesf
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了ScalaScala之Classes and Properties相关的知识，希望对你有一定的参考价值。
一、前言
前面学习了控制结构，下面学习Scala的Class和Properties。
二、Class&Properties
尽管Scala和Java很类似，但是对类的定义、类构造函数、字段可见性控制等则不相同，Java更为冗长，Scala精炼。本章将通过Scala的构造函数工作原理来理解Scala的类和字段，当申明类构造函数参数和使用var、val、private关键字来修饰类的字段时，Scala编译器将会为你生成代码，根据字段修饰符不同，Scala编译器会生成不同的存取函数，本章也会展示如何重写这些函数，另外，Scala将会根据你的值为变量赋予相应的类型。
2.1 创建主构造函数
1. 问题描述
你需要为一个类创建主构造函数，你很快就会发现其和Java大不相同。
2. 解决方案
Scala的主构造函数是如下的结合
· 构造函数参数
· 类主体中调用的方法
· 类主体中执行的语句和表达式
Scala类主体中声明的字段与Java类似，他们在类初始化时被赋值，下面的类演示构造函数的参数、类字段和类中的语句
由于类主体中的方法也是构造函数的一部分，当创建一个Person实例时，你会看到println的输出和printHome和printFullName函数调用的输出
3 讨论
如果你是从Java到Scala，你会发现在Scala中声明一个主构造函数时非常不同的，在Java中，在不在主构造函数中都是非常明显的，但是Scala模糊了这个区别，一旦你理解了这个方法，你将会更精确的定义类构造函数，由于构造函数中的firstName和lastName被声明为var类型，因此其是可变的，Scala会为其生成存取函数
HOME字段时private和val的，其在Java中等效于final和private的，其不能被其他对象直接访问，并且其值不能被改变，使用scalac进行编译后，再用javap进行反编译结果如下
可以看到包含了很多_$eq方法，这是var字段的语法糖，对用户透明，对于如下类
class Person { var name = "" override def toString = s"name = $name" }
由于name是var类型的，因此Scala会为其生成存取函数，即将会生成name_$eq函数，有了该函数，你可以修改name字段
p.name = "Ron Artest"
实际上，你调用的是如下方法
p.name_$eq("Ron Artest")
可以看到Scala的代码更为精炼，在声明字段时需要注意Scala是否会生成该存取函数
2.2 控制构造函数字段的可见性
1. 问题描述
你想控制Scala中的类中作为构造函数参数的字段的可见性
2. 解决方案
构造函数中字段的可见性由该字段是否被声明为val或var或无val、var，是否为字段添加了private决定，解决方案如下
· 如果字段被声明为var，Scala会为其生成getter和setter方法
· 如果字段被声明为val，Scala会为只其生成getter方法
· 如果字段无var或var，Scala将不会生成getter或setter方法
· var和val字段可以使用private关键字修饰，这样可以防止生成getter或setter方法
如果字段被声明为var，则表示该字段的值是可变的，所以Scala为其生成getter和setter函数，下面示例中的字段被声明为var，则表示可变
如果字段被声明为val，则表示该字段的值是不可变的，如同Java的final，因此，其不会有setter方法，但是有getter方法
当构造函数中的参数没有使用var或者val声明时，其可见性变得十分严格，Scala不会为其生成setter或getter方法
除了将变量定义为val或var之外，还可以使用private关键字修饰字段，private关键字可以防止Scala生成getter或setter方法，因此该字段只能在类内部访问
在类外访问name字段时，发生异常，而在类函数中访问时正常
3. 讨论
当字段定义为val时，则不会产生setter，若定义为var时，则会产生setter和getter，private关键可以提供其他的灵活性。case类中的构造器中的参数与上述情况不太相同，如果你没有使用var或val修饰字段，如
case class Person(name: String)
此时你也可以访问该字段，就像该字段被定义为val一样
2.3 定义辅助构造器
1. 问题描述
你要定义类的一个或多个辅助构造函数，以便用户不同方法来创建对象实例
2. 解决方案
将辅助构造函数定义为名字为this的类的方法，你可以定义多个辅助构造函数，但是它们需要有不同的函数签名(参数列表)，每个构造函数必须调用前面定义的多个构造函数中的一个。
class Pizza (var crustSize: Int, var crustType: String) { // one-arg auxiliary constructor def this(crustSize: Int) { this(crustSize, Pizza.DEFAULT_CRUST_TYPE) } // one-arg auxiliary constructor def this(crustType: String) { this(Pizza.DEFAULT_CRUST_SIZE, crustType) } // zero-arg auxiliary constructor def this() { this(Pizza.DEFAULT_CRUST_SIZE, Pizza.DEFAULT_CRUST_TYPE) } override def toString = s"A $crustSize inch pizza with a $crustType crust" } object Pizza { val DEFAULT_CRUST_SIZE = 12 val DEFAULT_CRUST_TYPE = "THIN" def main(args: Array[String]): Unit = { val p1 = new Pizza(Pizza.DEFAULT_CRUST_SIZE, Pizza.DEFAULT_CRUST_TYPE) val p2 = new Pizza(Pizza.DEFAULT_CRUST_SIZE) val p3 = new Pizza(Pizza.DEFAULT_CRUST_TYPE) val p4 = new Pizza println(p1) println(p2) println(p3) println(p4) } }
运行结果
A 12 inch pizza with a THIN crust A 12 inch pizza with a THIN crust A 12 inch pizza with a THIN crust A 12 inch pizza with a THIN crust
3. 讨论
关键点如下
· 辅助构造函数时以this为名字的类方法
· 每个辅助构造函数必须以对先前定义的构造函数的调用开始
· 每个辅助构造函数必须有不同的函数签名
· 构造函数通过this来调用其他构造函数
上述示例中的所有辅助构造函数都调用了主构造函数，但是不是只能调用主构造函数，还可调用辅助构造函数，如下所示
def this(crustType: String) { this(Pizza.DEFAULT_CRUST_SIZE) this.crustType = Pizza.DEFAULT_CRUST_TYPE }
同时，crustSize和crustType都是主构造函数中的参数，其可以使得Scala为其生成setter和getter函数，你也可以使用如下方法，其需要更多代码
class Pizza () { var crustSize = 0 var crustType = "" def this(crustSize: Int) { this() this.crustSize = crustSize } def this(crustType: String) { this() this.crustType = crustType } // more constructors here ... override def toString = s"A $crustSize inch pizza with a $crustType crust" }
case类是一个可以生成很多样板代码的特殊类，为case类添加辅助构造器与常规类的做法不相同，这是因为它们不是真正的构造函数：它们是类的伴生对象中的apply
方法，为了进行验证，先定义一个Person的case类
在val p = new Person("leesf", 25)代码后，由于语法糖的存在，Scala编译器将其转化为了如下代码
val p = Person.apply("leesf", 25)
这是伴生对象中的apply方法，如果你想要为case类添加构造函数，你只需要在伴生对象中添加apply方法即可
// the case class case class Person (var name: String, var age: Int) // the companion object object Person { def apply() = new Person("<no name>", 0) def apply(name: String) = new Person(name, 0) }
测试代码如下
object CaseClassTest extends App { val a = Person() // corresponds to apply() val b = Person("leesf") // corresponds to apply(name: String) val c = Person("dyd", 25) println(a) println(b) println(c) // verify the setter methods work a.name = "leesf" a.age = 25 println(a) }
运行结果
Person(<no name>,0) Person(leesf,0) Person(dyd,25) Person(leesf,25)
2.4 定义私有主构造函数
1. 问题描述
你想要生成类私有的主构造函数，如强制执行单例模式
2. 解决方案
为了让主构造器私有，需要在类名和构造函数所接受的任何参数之间插入private关键字
class Order private { ... } class Person private (name: String) { ... }
在REPL中，定义了私有类后，不能创建类实例
3. 讨论
在Scala中强制单例模式的一种简单方法就是使主构造器变为private，然后在伴生对象中添加getInstance方法
class Brain private { override def toString = "This is the brain." } object Brain { val brain = new Brain def getInstance = brain } object SingletonTest extends App { val brain = Brain.getInstance println(brain) }
运行结果：
This is the brain.
其中伴生类对象中的getInstance是静态方法
在Java中，你可以在类中定义静态方法来创建文件工具类，但在Scala中，你只需要将这些方法放在对象中即可
object FileUtils { def readFile(filename: String) = { // code here ... } def writeToFile(filename: String, contents: String) { // code here ... } }
说明：可以通过FileUtils.readFile和FileUtils.writeToFile来调用相应的方法
2.5 为构造函数参数提供默认值
1. 问题描述
你想要为构造器参数提供默认值，给其他类调用构造函数时可决定是否指定该参数
2. 解决方案
在构造函数声明中给予参数默认值，这里有一个简单的声明，Socket类有一个构造函数参数名为timeout，默认值为10000
class Socket (val timeout: Int = 10000)
由于构造函数提供了默认参数，因此在调用时可以不指定timeout的值
也可以指定timeout的值
如果你更喜欢调用构造函数时使用命名参数的方法，你也可以用如下方法调用构造函数
3. 讨论
默认参数可以有效消除辅助构造函数，如下的构造函数相当于两个构造函数（不指定参数值和指定参数值）
class Socket (val timeout: Int = 10000)
若没有默认参数这一特性，则需要定义一个辅助构造函数
class Socket(val timeout: Int) { def this() = this(10000) override def toString = s"timeout: $timeout" }
你可以为多参数的构造函数提供多个默认值
class Socket(val timeout: Int = 1000, val linger: Int = 2000) { override def toString = s"timeout: $timeout, linger: $linger" }
尽管你只定义了一个构造函数，但实际上有三个构造函数
在创建对象时你也可以提供参数名
2.6 覆盖默认的访问器和修改器
1. 问题描述
你想要覆盖Scala为你生成的访问器和修改器
2. 解决方案
这是一个技巧的问题，如果你想坚持用Scala的命名约定时，你不能重写Scala为你生成的getter和setter方法，例如Person类有name参数，以下代码将不会被编译
为了解决这个问题，可以构造函数的字段名，如将name改为_name
name方法为访问器，name_=方法为修改器
如果你不想使用Scala为你定义访问器和修改器的名字，你可以自由更改，如改为getName、setName。
3. 讨论
如果你将类构造器的字段设置为var，则Scala会自动生成getter和setter方法，对于如下类
class Stock (var symbol: String)
首先使用scalac进行编译，然后使用javap Stock进行反编译，结果如下
可以看到Scala生成了symbol方法和symbol_$eq方法，可以直接通过方法名调用，对于symbol_$eq而言，还可以使用symbol_=来调用
如果本想对字段加private，然而没有加，如下类
class Stock (var _symbol: String) { def symbol = _symbol def symbol_= (s: String) { this.symbol = s println(s"symbol was updated, new value is $symbol") } }
同样经过编译和反编译，结果如下
可以看到姿势的_symbol函数和_symbol_$eq函数都变为public了，而加private修饰时，其结果如下
2.7 防止生成getter和setter方法
1. 问题描述
当你定义类的构造函数参数为var时，Scala将会自动生成setter和getter方法，若是val，则生成getter方法，但是你既不需要setter，也不需要getter
2. 解决方案
将字段使用private或者private[this]修饰，如下面示例
class Stock { var delayedPrice: Double = _ private var currentPrice: Double = _ }
使用scalac进行编译，再使用javap进行反编译，结果如下
可以看到delayedPrice字段生成了getter和setter方法，而currentPrice字段则没有生成getter和setter方法
3. 讨论
将字段定义为private，这样其只能被同类的所有实例访问，例如，所有的Stock实例可以互相访问currentPrice字段，如下面示例的结果为true
将字段定义为private[this]将会使字段变为对象私有，只有包含它的对象能够访问，同类的实例将无法访问其他实例的字段
可以看到在this对象的方法中无法访问that对象的price字段
2.8 将代码块或函数赋值给字段
1. 问题描述
你想要使用代码块或通过调用函数初始化类中的字段
2. 解决方案
设置字段等于代码块或函数，如果算法需要运行一段时间，则可以设置为lazy，下面示例中，text被设置成等于代码块，它要么返回文件中包含的文本，要么返回错误信息，这取决于该文件是否存在和是否能被读取
class Foo { // set \'text\' equal to the result of the block of code val text = { var lines = "" try { lines = io.Source.fromFile("F:/test.txt").getLines.mkString } catch { case e: Exception => lines = "Error happened" } lines } println(text) } object Test extends App { val f = new Foo }
运行结果
This is a test file.
对text的赋值和println都在Foo类构造器中，当新生实例时会被执行，因此，编译运行该示例时要么返回文件中的内容，要么发生错误，在catch中被捕获
3. 讨论
当字段被定义成lazy时，只有当被访问时才会被初始化
class Foo { val text = io.Source.fromFile("F:/test.txt").getLines.foreach(println) } object Test extends App { val f = new Foo }
运行结果
This is a test file.
当字段使用lazy修饰时
class Foo { lazy val text = io.Source.fromFile("F:/test.txt").getLines.foreach(println) } object Test extends App { val f = new Foo }
无任何结果输出
2.9 设置未初始化的var字段类型
1. 问题描述
你想要设置未初始化的var字段的类型，你可能会这样写，但是不知道如何结尾
var x =
2. 解决方案
通常，将字段定义为Option，对于有些类型，如String和numeric字段，你可以指明初始值，例如，你想要用户在社交网中注册，注册使用到的信息只有username和password，因此，你可以有如下类定义
case class Person(var username: String, var password: String)
之后，你也需要用户的其他信息，如age, first name, last name, address，可以有如下定义
case class Person(var username: String, var password: String) { var age = 0 var firstName = "" var lastName = "" var address = None: Option[Address] } case class Address(city: String, state: String, zip: String)
即使用Option[Address]类型的None作为缺省值，可以使用如下
val p = Person("leesf", "secret")
p.address = Some(Address("WH", "HB", "43000"))
当需要访问address的字段时，可以如下
p.address.foreach { a =>
println(a.city)
println(a.state)
println(a.zip)
}
当p.address为None时，则会跳过，为Some时，则会打印相应信息
3. 讨论
编译器有时会自动给出类型，如下所示
var i = 0 // Int var d = 0.0 // Double
当需要自定义类型时，可以如下
var b: Byte = 0 var c: Char = 0 var f: Float = 0 var l: Long = 0 var s: Short = 0
2.10 处理继承时的构造器参数
1. 问题描述
你想要扩展基类，并且需要使用基类中声明的构造函数参数，以及子类中的新参数
2. 解决方案
还是使用var和val来定义构造函数参数，当定义子类构造函数时，父类构造函数中的字段不再使用var修饰，在子类构造函数中定义新的字段
class Person (var name: String, var address: Address) { override def toString = if (address == null) name else s"$name @ $address" }
首先定义了Person基类，然后定义Employee子类
class Employee (name: String, address: Address, var age: Int) extends Person (name, address) { // rest of the class }
Employee继承Person类，不再使用var修饰name和address，但是age在父类中不存在，则使用var修饰，其中Address类如下
case class Address (city: String, state: String)
可以使用如下方法创建子类
val lee = new Employee("Leesf", Address("JZ", "HB"), 25)
3. 讨论
为了理解构造函数参数在子类中是如何工作的，也可帮助理解Scala是如何翻译你的代码的，由于Person的参数被定义为var
class Person (var name: String, var address: Address) { override def toString = if (address == null) name else s"$name @ $address" }
Scala编译器将会生成getter和setter
此时，如果Employee继承Person，在Employee构造函数中如何处理name和address字段，加入没有新的参数，那么至少有两种选择
// Option 1: define name and address as \'var\' class Employee (var name: String, var address: Address) extends Person (name, address) { ... } // Option 2: define name and address without var or val class Employee (name: String, address: Address) extends Person (name, address) { ... }
由于Scala已经在Person类中生成了setter和getter函数，一种解决办法就是在Employee的构造函数的参数不用var修饰
// this is correct class Employee (name: String, address: Address) extends Person (name, address) { ... }
由于Employee的构造函数中并未使用var修饰，因此Scala不会为字段生成getter和setter方法，验证代码如下
case class Address (city: String, state: String) class Person (var name: String, var address: Address) { override def toString = if (address == null) name else s"$name @ $address" } class Employee (name: String, address: Address) extends Person (name, address) { }
使用javap反编译Employee，结果如下
可以看到Scala并未为Employee类生成任何setter和getter方法
2.11 调用父类构造函数
1. 问题描述
当创建子类构造函数时，你想控制父类构造函数
2. 解决方案
你可以通过子类的主构造函数来控制父类构造函数，但是不能通过子类的辅助构造函数来控制父类构造函数，当定义子类时，你可以通过定义extends部分来控制子类所调用的父类构造器，例如，Dog类被定义为调用Animal类，其有name参数
class Animal (var name: String) { // ... } class Dog (name: String) extends Animal (name) { // ... }
如果Animal类有多个构造函数，Dog子类可以调用任意的父类构造函数
// (1) primary constructor class Animal (var name: String, var age: Int) { // (2) auxiliary constructor def this (name: String) { this(name, 0) } override def toString = s"$name is $age years old" } // calls the Animal one-arg constructor class Dog (name: String) extends Animal (name) { println("Dog constructor called") }
由于辅助构造函数的第一行必须要调用其他构造函数，因此，辅助构造函数不能调用父类构造函数，下面代码中，Employee类的主构造含可以调用Person类的任意构造函数，但是Employee的辅助构造函数只能调用其他构造函数
case class Address (city: String, state: String) case class Role (role: String) class Person (var name: String, var address: Address) { // no way for Employee auxiliary constructors to call this constructor def this (name: String) { this(name, null) address = null } override def toString = if (address == null) name else s"$name @ $address" } class Employee (name: String, role: Role, address: Address) extends Person (name, address) { def this (name: String) { this(name, null, null) } def this (name: String, role: Role) { this(name, role, null) } def this (name: String, address: Address) { this(name, null, address) } }
所以无法通过子类辅助构造函数来控制父类构造函数，因为辅助构造函数必须要调用其他构造函数，所有的辅助构造函数最终会调用主构造函数，最终由主构造函数调用辅助构造函数
2.12 何时使用抽象类
1. 问题描述
Scala有traits特性，并且traits比抽象类更灵活，那么何时使用抽象类呢
2. 解决方案
以下两种原因需要使用抽象类
· 你想要创建一个包含构造函数参数的基类
· 代码将会被Java代码调用
考虑第一种情况，traits不允许构造函数参数，如下所示
trait Animal(name: String) // this won\'t compile
当基类构造函数必须含有参数时应该使用抽象类
abstract class Animal(name: String)
考虑第二种情况是你的代码将会被Java调用，traits中实现的方法无法被Java访问
3. 讨论
当构造函数有参数时，需要使用抽象类而非traits，但是，一个类只能继承一个抽象类，其与Java类似，当类中抽象方法时，该类就是抽象，方法体未定义的方法就是抽象方法
def speak // no body makes the method abstract
不需要使用abstract关键字，如下示例
abstract class BaseController(db: Database) { def save { db.save } def update { db.update } def delete { db.delete } // abstract def connect // an abstract method that returns a String def getStatus: String // an abstract method that takes a parameter def setServerName(serverName: String) }
其中connect、getStatus、setServerName为抽象方法，子类必须要实现或者是为抽象类
2.13 在抽象基类（或traits）中定义属性
1. 问题描述
你想要在抽象类或traits中定义具体的或抽象属性，以便所有的子类都可以引用
2. 解决方案
你可以在抽象类或traits中定义var或val字段，该字段可以是抽象的或者是具体定义的，下面示例展示了Pet抽象类中的抽象val和var字段，并且有一个sayHello的具体方法，以及重写的toString方法
abstract class Pet (name: String) { val greeting: String var age: Int def sayHello { println(greeting) } override def toString = s"I say $greeting, and I\'m $age" }
Dog和Cat类继承Pet，并且提供了greeting和age的具体实现，其中，字段给再次定义成val或var
class Dog (name: String) extends Pet (name) { val greeting = "Woof" var age = 2 } class Cat (name: String) extends Pet (name) { val greeting = "Meow" var age = 5 }
可使用如下
object AbstractFieldsDemo extends App { val dog = new Dog("Fido") val cat = new Cat("Morris") dog.sayHello cat.sayHello println(dog) println(cat) // verify that the age can be changed cat.age = 10 println(cat) }
运行结果如下
Woof
Meow
I say Woof, and I\'m 2
I say Meow, and I\'m 5
I say Meow, and I\'m 10
3. 讨论
你可以在抽象类中定义val或var的抽象字段，抽象字段在抽象类中的工作机制非常有趣
· 抽象的var字段也会生成getter和setter方法
· 抽象的val字段会生成getter方法
· 当在抽象类或traits中定义抽象的var或val字段时，Scala并不会生成该字段，只会生成方法
当在具体类中重写父类抽象的var或val字段时，一定要再次注明val或var，因为父类中不存在该字段，不需要使用override关键字，当在抽象类中使用def来定义无参数的方法时，可以在子类中定义为val
abstract class Pet (name: String) { def greeting: String } class Dog (name: String) extends Pet (name) { val greeting = "Woof" } object Test extends App { val dog = new Dog("Fido") println(dog.greeting) }
当在抽象类中定义具体的val字段时，你可以提供一个初始值，然后在子类中进行重写
abstract class Animal { val greeting = "Hello" // provide an initial value def sayHello { println(greeting) } def run } class Dog extends Animal { override val greeting = "Woof" // override the value def run { println("Dog is running") } }
在如下示例中，greeting在父类和子类中都定义了
abstract class Animal { val greeting = { println("Animal"); "Hello" } } class Dog extends Animal { override val greeting = { println("Dog"); "Woof" } } object Test extends App { new Dog }
运行结果
Animal
Dog
为了防止抽象类中的val字段被子类覆盖，可以将其定义为final
abstract class Animal { final val greeting = "Hello" // made the field \'final\' } class Dog extends Animal { val greeting = "Woof" // this line won\'t compile }
你也可以在抽象类中定义var变量，并为其赋值，然后在具体子类中引用它们
abstract class Animal { var greeting = "Hello" var age = 0 override def toString = s"I say $greeting, and I\'m $age years old." } class Dog extends Animal { greeting = "Woof" age = 2 }
greeting字段和age字段在Animal类中都被定义和初始化了，在Dog类中就没有必要再重新声明为var或val类型了
在上述讨论中，不应该使用null值，可以使用Option/Some/None来初始化字段
trait Animal { val greeting: Option[String] var age: Option[Int] = None override def toString = s"I say $greeting, and I\'m $age years old." } class Dog extends Animal { val greeting = Some("Woof") age = Some(2) } object Test extends App { val d = new Dog println(d) }
运行结果
I say Some(Woof), and I\'m Some(2) years old.
2.14 使用样例类生成样板代码
1. 问题描述
你需要使用样例类来生成样板代码，如生成setter和getter方法，还有apply, unapply, toString, equals, hashCode等方法
2. 解决方案
将类定义成样例类，并且添加相应的构造函数参数
case class Person(name: String, relation: String)
将类定义为样例类后，会生成很多样板代码，如
· 生成apply方法，所以不需要是new关键字就可以创建实例
· 为构造函数参数生成getter方法，因为其默认是val的，当被定义为var时，会生成setter方法
· 会生成缺省的toString方法
· 生成unapply方法，在模式匹配中将会很方便
· 生成equals和hashCode方法
· 生成copy方法
3. 讨论
样例类在模式匹配中很实用，其默认参数为val，当创建样例类时，Scala会为你生成很多样板代码
2.15 定义equals方法（对象相等）
1. 讨论
你想要定义一个equals方法来比较不同对象之间的相等性
2. 解决方案
如同Java一样，你在类中定义equals和hashCode来比较两个对象，但与Java不同的是，你使用 == 来比较两个对象的相等性，下面定义了equals方法和hashCode方法
class Person (name: String, age: Int) { def canEqual(a: Any) = a.isInstanceOf[Person] override def equals(that: Any): Boolean = that match { case that: Person => that.canEqual(this) && this.hashCode == that.hashCode case _ => false } override def hashCode:Int = { val prime = 31 var result = 1 result = prime * result + age; result = prime * result + (if (name == null) 0 else name.hashCode) return result } }
接着可以使用 == 来比较两个Person对象是否相等
3. 讨论
在Java中，==是比较两个对象的引用是否相等，而在Scala中，其是根据用户定义逻辑进行比较，其调用equals方法，在涉及继承时，也可以使用如上方法
class Employee(name: String, age: Int, var role: String) extends Person(name, age) { override def canEqual(a: Any) = a.isInstanceOf[Employee] override def equals(that: Any): Boolean = that match { case that: Employee => that.canEqual(this) && this.hashCode == that.hashCode case _ => false } override def hashCode:Int = { val ourHash = if (role == null) 0 else role.hashCode super.hashCode + ourHash } }
2.16 创建内部类
1. 问题描述
你希望创建一个内部类，以将类排除在公共API之外，或者封装您的代码
2. 解决方案
将类声明在另一个类中，如下示例
class PandorasBox { case class Thing (name: String) var things = new collection.mutable.ArrayBuffer[Thing]() things += Thing("Evil Thing #1") things += Thing("Evil Thing #2") def addThing(name: String) { things += new Thing(name) } }
可以在PandorasBox内部使用things集合
object ClassInAClassExample extends App { val p = new PandorasBox p.things.foreach(println) }
运行结果
Evil Thing #1
Evil Thing #2
并且可以调用addThing方法
p.addThing("Evil Thing #3")
p.addThing("Evil Thing #4")
3. 讨论
与Java的内部类属于外部类不同，Scala中的内部类绑定到外部类的对象上