【Scala】Scala之Objec
一、前言
前面學習了Scala的Methods，接著學習Scala中的Object
二、Object
Object在Scala有兩種含義，在Java中，其代表一個類的例項，而在Scala中，其還是一個關鍵字，本篇首先將會把object當成一個類的例項看待，展示如何將物件從一種型別轉化為另一種型別，之後將展示如何建立單例物件，Scala中還存在包物件，在Scala中，經常有如下定義
type Throwable = java.lang.Throwable type Exception = java.lang.Exception type Error = java.lang.Error type Seq[+A] = scala.collection.Seq[A] val Seq = scala.collection.Seq
使用type定義可以使得程式碼更為簡潔，可使用伴生物件來建立靜態方法，並且伴生物件可以使得在建立類物件時不需要使用new關鍵字，如下所示
val siblings = List(Person("Kim"), Person("Julia"), Person("Kenny"))
2.1 物件轉化
1. 問題描述
你需要將一個類的例項從一種型別轉化為另一種型別，如動態建立物件
2. 解決方案
使用asInstanceOf方法進行型別轉化，如下的lookup方法返回的物件將給轉化為Recognizer物件
val recognizer = cm.lookup("recognizer").asInstanceOf[Recognizer]
以上程式碼在Java中如下
Recognizer recognizer = (Recognizer)cm.lookup("recognizer");
asInstanceOf方法是定義在Any類中的，所以任何類中都可以使用該方法
3. 討論
在動態程式設計中，經常需要從一個類轉化為另一個類，如在Spring框架中使用ApplicationContext檔案來初始化Bean
// open/read the application context fileval ctx = new ClassPathXmlApplicationContext("applicationContext.xml") // instantiate our dog and cat objects from the application context val dog = ctx.getBean("dog").asInstanceOf[Animal] val cat = ctx.getBean("cat").asInstanceOf[Animal]
在進行數字型別轉化時，也可以使用asInstanceOf方法
當需要與Java進行互動時，也可以使用asInstanceOf方法
val objects = Array("a", 1)
val arrayOfObject = objects.asInstanceOf[Array[Object]]
AJavaClass.sendObjects(arrayOfObject)
與Java類似，型別轉化可能會丟擲ClassCastException異常
可以使用try/catch來解決此問題
2.2 與Java的.class對應的方法
1. 問題描述
當一個API需要你傳遞Class物件，在Java中，你可以使用.class，但是在Scala則行不通
2. 解決方案
使用Scala的classOf方法，如下所示
val info = new DataLine.Info(classOf[TargetDataLine], null)
在Java中則使用如下
info = new DataLine.Info(TargetDataLine.class, null);
classOf方法定義在Predef物件中，因此可以在沒有import情況直接使用
3. 討論
該方法可以讓你開始學習反射，如下示例可以訪問String類的方法
2.3 確定物件的類
1. 問題描述
在Scala中，你不需要顯示的宣告型別，你偶爾也想要列印一個物件的類或型別以明白Scala的工作機制
2. 解決方案
你可以使用物件的getClass方法來確定Scala為你自動賦值的型別，如當需要了解可變引數的工作流程時，可以呼叫getClass方法，得知不同情況，型別也不相同
def printAll(numbers: Int*) { println("class: " + numbers.getClass) }
當使用多個引數呼叫printAll方法和不使用引數呼叫printAll方法，其結果不相同
當處理Scala的XML庫時，該方法非常有效，可以知道在不同情形下所處理的類，如下，<p>標籤下包含了一個子類
當在<p>標籤中新增<br/>標籤後，其結果如下
3. 討論
若在IDE中無法得知物件的型別，可以使用getClass方法來獲取物件型別
2.4 使用物件啟動應用
1. 問題描述
你想要使用main方法來啟動一個應用，或者為指令碼提供一個入口
2. 解決方案
啟動應用有兩種方法，其一讓類繼承App，其二是定義一個物件並定義main方法
對於第一種方法，其通用做法如下
object Hello extends App { println("Hello, world") }
此時object內的語句會自動執行，第二種方法是定義main方法
object Hello2 { def main(args: Array[String]) { println("Hello, world") } }
3. 討論
上述兩種方法中，都是通過object來啟動應用的
2.5 使用Object建立單例
1. 問題描述
你想要建立一個單例物件
2. 解決方案
使用object關鍵字來建立單例物件
object CashRegister { def open { println("opened") } def close { println("closed") } }
由於CashRegister被定義為成object，因此僅僅只有一個例項，被呼叫的方法就相當於Java中的靜態方法，呼叫如下
object Main extends App { CashRegister.open CashRegister.close }
在建立工具方法時，該方法同樣有效
import java.util.Calendar import java.text.SimpleDateFormat object DateUtils { // as "Thursday, November 29" def getCurrentDate: String = getCurrentDateTime("EEEE, MMMM d") // as "6:20 p.m." def getCurrentTime: String = getCurrentDateTime("K:m aa") // a common function used by other date/time functions private def getCurrentDateTime(dateTimeFormat: String): String = { val dateFormat = new SimpleDateFormat(dateTimeFormat) val cal = Calendar.getInstance() dateFormat.format(cal.getTime()) } }
由於方法是定義在object中，因此可以直接使用DateUtils來呼叫這些方法，如同Java中呼叫靜態方法
DateUtils.getCurrentDate
DateUtils.getCurrentTime
在使用actors時，單例物件可以產生可重用的訊息，如果你有可以接受和傳送訊息的actor，你可以使用如下方法建立單例
case object StartMessage case object StopMessage
這些物件將會被作為訊息，並且可被傳遞到actor中
inputValve ! StopMessage
outputValve ! StopMessage
3. 討論
當使用伴生物件時，一個類就既可以有非靜態方法又可以有靜態方法
2.6 使用伴生物件建立靜態成員
1. 問題描述
你想要為一個類建立例項方法和類方法，但是Scala中沒有static關鍵字
2. 解決方案
在class中定義非靜態成員，在object中定義靜態成員，物件與類要有相同的名字並且位於同一個檔案中，該物件稱為伴生物件
使用該方法可以讓你建立靜態成員（欄位和方法）
// Pizza class class Pizza (var crustType: String) { override def toString = "Crust type is " + crustType } // companion object object Pizza { val CRUST_TYPE_THIN = "thin" val CRUST_TYPE_THICK = "thick" def getFoo = "Foo" }
Pizza類和Pizza物件在同一個檔案中(Pizza.scala)，Pizza物件中的成員等效於Java類中的靜態成員
println(Pizza.CRUST_TYPE_THIN)
println(Pizza.getFoo)
你也可按照常規方法建立Pizza物件
var p = new Pizza(Pizza.CRUST_TYPE_THICK) println(p)
3. 討論
class和object具有相同的名稱並且在同一個檔案中，class中定義的是非靜態成員，object中定義的是靜態成員
class和其伴生物件可以互相訪問對方的私有成員，如下面object的double方法可以訪問class中的私有變數secret
class Foo { private val secret = 2 } object Foo { // access the private class field 'secret' def double(foo: Foo) = foo.secret * 2 } object Driver extends App { val f = new Foo println(Foo.double(f)) // prints 4 }
如下的class類中的非靜態方法可以訪問伴生物件中的靜態私有變數
class Foo { // access the private object field 'obj' def printObj { println(s"I can see ${Foo.obj}") } } object Foo { private val obj = "Foo's object" } object Driver extends App { val f = new Foo f.printObj }
2.7 將常用程式碼放在包物件中
1. 問題描述
你想要使方法、欄位和其他程式碼處於包級別，而不需要class或者object
2. 解決方案
將程式碼放置在包物件下面，如將你的程式碼放置在package.scala檔案中，例如，如果你想要程式碼被com.hust.grid.leesf.model包下所有類可用，那麼建立一個位於com/hust/grid/leesf/model目錄下的package.scala檔案，在package.scala中，在包宣告中移除model，並且以其作為名字來建立包，大致如下
package com.hust.grid.leesf package object model {
其他程式碼放置在model中，如下所示
package com.hust.grid.leesf package object model { // field val MAGIC_NUM = 42 // method def echo(a: Any) { println(a) } // enumeration object Margin extends Enumeration { type Margin = Value val TOP, BOTTOM, LEFT, RIGHT = Value } // type definition type MutableMap[K, V] = scala.collection.mutable.Map[K, V] val MutableMap = scala.collection.mutable.Map }
此時，在com.hust.grid.leesf.model包下面類、物件、介面等可以隨意訪問上述定義的欄位、方法等
package com.hust.grid.leesf.model object MainDriver extends App { // access our method, constant, and enumeration echo("Hello, world") echo(MAGIC_NUM) echo(Margin.LEFT) // use our MutableMap type (scala.collection.mutable.Map) val mm = MutableMap("name" -> "Al") mm += ("password" -> "123") for ((k,v) <- mm) printf("key: %s, value: %s\n", k, v) }
3. 討論
最疑惑的是將package物件放在哪裡，其包名和物件名
如果你想要讓你的程式碼在com.hust.grid.leesf.model包中可見，那麼將package.scala放在com/hust/grid/leesf/model目錄下，而在package.scala中，其包名應該如下
package com.hust.grid.leesf
然後使用model作為物件名
package object model {
最後大致如下
package com.hust.grid.leesf package object model {
包中可以存放列舉型別、常量和隱式轉換
2.8 不使用new關鍵字來建立物件例項
1. 問題描述
當不使用new關鍵字來建立物件時，Scala程式碼會顯得相對簡潔，如下所示
val a = Array(Person("John"), Person("Paul"))
2. 解決方案
有兩種方式
· 為類建立伴生物件，然後定義apply方法，其簽名與構造方法簽名相同
· 將類定義為case類
為Person物件定義了伴生物件，然後定義apply方法並接受引數
class Person { var name: String = _ } object Person { def apply(name: String): Person = { var p = new Person p.name = name p } }
現在你可以不使用new關鍵字來建立Person物件了
val dawn = Person("Dawn")
val a = Array(Person("Dan"), Person("Elijah"))
Scala編譯器會對伴生物件中的apply進行特殊處理，讓你不使用new關鍵字即可建立物件
將類定義為case類，並且接受相應引數
case class Person (var name: String)
現在可以採用如下方法建立物件
val p = Person("Fred Flinstone")
Scala會為case類的伴生物件建立apply方法
3. 討論
編譯器會對伴生物件的apply做特殊處理，這是Scala的語法糖
val p = Person("Fred Flinstone")
上述程式碼會被轉化為如下程式碼
val p = Person.apply("Fred Flinstone")
apply方法是工廠方法，Scala的此語法糖讓你不用new關鍵字即可建立物件
可以在伴生物件中建立多個apply方法，這樣相當於多個建構函式
class Person { var name = "" var age = 0 } object Person { // a one-arg constructor def apply(name: String): Person = { var p = new Person p.name = name p } // a two-arg constructor def apply(name: String, age: Int): Person = { var p = new Person p.name = name p.age = age p } }
可以使用如下方法建立物件
val fred = Person("Fred")
val john = Person("John", 42)
為了給case類建立多個建構函式，需要知道case類背後的邏輯
當使用scala編譯器編譯case類時，你會發生其生成了兩個檔案，Person$.class和Person.class檔案，當使用javap反編譯Person$.class檔案時，其輸出如下
其包含了一個返回Person物件的apply方法
public Person apply(java.lang.String);
String對應的是case類中的name
case class Person (var name: String)
使用javap命令可以看到在Person.class中為name生成的getter和setter函式
在如下程式碼中，存在case類和apply方法
// want accessor and mutator methods for the name and age fields case class Person (var name: String, var age: Int) // define two auxiliary constructors object Person { def apply() = new Person("<no name>", 0) def apply(name: String) = new Person(name, 0) }
由於name和age都是var的，所以會生成getter和setter，在object中定義了兩個apply函式，因此可以使用如下三種方式來生成Person物件
object Test extends App { val a = Person() val b = Person("Al") val c = Person("William Shatner", 82) println(a) println(b) println(c) // test the mutator methods a.name = "Leonard Nimoy" a.age = 82 println(a) }
其結果如下
Person(<no name>,0) Person(Al,0) Person(William Shatner,82) Person(Leonard Nimoy,82)
2.9 使用apply來實現工廠方法
1. 問題描述
為了讓子類宣告應該建立哪種型別的物件，並且只在一處能夠建立物件，你想要實現工廠方法
2. 解決方案
可以使用伴生物件的apply方法來實現工廠方法，你可將工廠實現演算法放置在apply方法中
假設你想要建立一個Animal工廠，並且返回Cat和Dog，在Animal類的伴生物件中實現apply方法，你就可以使用如下方式建立不同物件
val cat = Animal("cat") // creates a Cat
val dog = Animal("dog") // creates a Dog
首先需要建立一個Animal的trait
trait Animal {
def speak
}
然後在相同檔案中建立伴生物件，建立實現Animal的類，一個合適的apply方法
object Animal { private class Dog extends Animal { override def speak { println("woof") } } private class Cat extends Animal { override def speak { println("meow") } } // the factory method def apply(s: String): Animal = { if (s == "dog") new Dog else new Cat } }
然後就可以使用如下語句建立不同物件
val cat = Animal("cat") // creates a Cat
val dog = Animal("dog") // creates a Dog
3. 討論
如果不使用apply方法來實現工廠方法，也可以使用如下的getAnimal方法來實現上述功能
// an alternative factory method (use one or the other) def getAnimal(s: String): Animal = { if (s == "dog") return new Dog else return new Cat }
然後可以使用如下方法建立不同物件
val cat = Animal.getAnimal("cat") // returns a Cat
val dog = Animal.getAnimal("dog") // returns a Dog
以上兩種方法都是可行的
三、總結
本篇學習了Scala中的object及其相應的用法，其在Scala的實際程式設計中應用也是非常廣泛，也謝謝各位園友觀看~