【Scala】Scala之Object

leesf發表於2017-03-03

一、前言

  前面學習了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 file
val 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的實際程式設計中應用也是非常廣泛,也謝謝各位園友觀看~

相關文章