单例对象
Scala没有静态方法或静态字段，你可以用object这个语法结构来达到同样的目的。对象定义了某个类的单个实例，包含你想要的特性。如，
object Number {
private var num = 0;
def newUniqueNum() = {
num += 1
num
}
def main(args: Array[String]) {
println(Number.newUniqueNum()) //打印1
}
}注：Scala的单例对象和Java中的静态方法/字段调用方式一致。在Scala中，对象的构造器在该对象第一次被使用时调用，若一个对象从未被使用，那么其构造器也不会被执行。对象本质上可以拥有类的所有特性-它甚至可以扩展其它类或特质，但是你不能提供构造器参数。
Scala单例对象使用场景
1.作为存放工具函数或常量的地方
2.高效共享单个不可变实例
3.需要单个实例来协调某个服务时(可参考单例模式)
伴生对象
在Java或C++中，你通常会用到即有实例方法又有静态方法的类。在Scala中，你可以通过类和与类同名的“伴生”对象来达到同样的目的。如
class Num {
private val id = Num.newUniqueNum
private def test() = {}
}
object Num {
private var num = 0
new Num().test()
private def newUniqueNum = {num += 1; num}
}扩展类或特质的对象
一个对象可以扩展类以及一个或多个特质，其结果是一个扩展了指定类以及特质的类的对象，同时拥有在对象中给出的所有特性。一个有用的场景是给出可被共享的缺省对象。举例在来说，考虑在程序中引入一个可撤销动作的类，默认情况下什么都不做，对于这个行为你只需要一个实例即可，可通过对象扩展类实现。如下，
//定义供扩展的抽象类
abstract class UndoableAction(val description : String) {
def undo() : Unit
def redo() : Unit
}
//DoNthingAction扩展自UndoableAction，默认情况下什么都不做。
object DoNothingAction extends UndoableAction("Do nothing") {
override def undo() {}
override def redo() {}
}注：DoNothingAction对象可以被所有需要这个缺省行为的地方共用。
apply方法
我们通常会定义使用对象的apply方法。当遇到如下形式的表达式时，apply方法就会被调用：
Object(参数1, ..., 参数N)
通常，这样一个apply方法返回的是伴生类的对象。举例来说，Array对象定义了apply方法，让我们可以用下面这样的表达式来创建数组：
Array("a","b","c")
为什么我们不使用构造器呢?对于嵌套表达式而言，省去new关键字会方便很多。如，Array(Array(1,7), Array(2,6))。
我们来看一个示例：
class Account(val id: Int, initBalance: Double) {
private var balance = initBalance
def printTe() = println(balance)
}
object Account {
def apply(initBalance: Double) = {
new Account(1, initBalance)
}
}
object Test {
def main(args: Array[String]) {
val account = Account(2.0)
account.printTe
}
}应用程序对象
每个Scala程序都必须从一个对象的main方法开始，这个方法的类型为Array[String] => Unit。如，object Test {
def main(args: Array[String]) {
println("Hello, World!")
}
}除了每次都提供自己的main方法外，你也可以扩展App特质，然后将程序代码翻入构造器方法体内。如，
object Hello extends App {
println("Hello, World!")
}如果你需要命令行参数，则可以通过args属性得到，如
object Hello extends App {
if(args.length > 0){
println("Hello, " + args(0))
}
else{
println("Hello, World!")
}
}scalac Hello.scala
scala -Dscala.time Hello Ming枚举
和Java或C++不同，Scala并没有枚举类型。但是，标准库提供了一个Enumeration助手类，可以用于产出枚举类。例如，定义一个扩展Enumeration类的对象并以Value方法调用初始化枚举中的所有可选值。示例如下，
object Color extends Enumeration {
val Red, Yellow, Green = Value //等同于：val Red = Value; val Yellow = Value; val Green = Value;
}注：上述示例定义了三个字段：Red、Yellow、Green，然后用Value调用将它们初始化。每次调用Value方法都返回内部类的新实例，该内部类也叫做Value。或者你也可以向Value方法传入ID、名称或者两个参数都传。如果不指定，则ID在将前一个枚举值的基础上加一，从零开始。缺省字段名称为字段的名。定义完成后，你就可以用Color.Red、Color.Yellow、Color.Green来引用枚举值了。如果这些变得冗长繁琐，则可以通过import Color._语句直接引入枚举类，然后直接调用Red等字段即可。记住枚举的类型是Color.Value而不是Color，后者是握有这些值的对象。
完整示例1：
object Color extends Enumeration {
val Red = Value(0, "Red")
val Yellow = Value("Yellow")
val Green = Value("Green")
}
object TestEnum {
def main(args: Array[String]): Unit = {
for(color <- Color.values) {
if(color.id == 2){
print(color.id + ": " + color)
}
else{
print(color.id + ": " + color + ",")
}
}
}
}完整示例2：
object Color extends Enumeration {
val Red = Value(0, "Red")
val Yellow = Value("Yellow")
val Green = Value("Green")
}
import Color._
object TestEnum {
def main(args: Array[String]): Unit = {
for(color <- values) {
if(color.id == 2){
print(color.id + ": " + color + ".")
}
else{
print(color.id + ": " + color + ",")
}
}
}
}完整示例3：
object Color extends Enumeration {
type Color = Value //定义类型别名
val Red = Value(0, "Red")
val Yellow = Value("Yellow")
val Green = Value("Green")
}
import Color._
object action {
def doWhat(color: Color) = {
if(color == Red) "stop"
else if(color == Yellow) "hurry up"
else "go"
}
}
object TestEnum {
def main(args: Array[String]) {
println(action.doWhat(Color.Green))
}
}注：输出结果为go。上述示例中使用type关键字定义类型别名，则该枚举的类型变成了Color.Color。
完整示例4：
object Color extends Enumeration {
type Color = Value
val Red = Value(0, "Red")
val Yellow = Value("Yellow")
val Green = Value("Green")
}
object TestEnum {
def main(args: Array[String]) {
print(Color(0) + ":" + Color.withName("Yellow"))
}
}
3417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
