日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網營銷解決方案
Scala講座：混入多重繼承、類型層次和集合

本文節(jié)選自最近在日本十分流行的Scala講座系列的第四篇，由JavaEye的fineqtbull翻譯。本系列的作者牛尾剛在日本寫過不少有關Java和Ruby的書籍，相當受歡迎。

創(chuàng)新互聯(lián)公司專注于企業(yè)成都全網營銷推廣、網站重做改版、日照網站定制設計、自適應品牌網站建設、H5開發(fā)、商城網站建設、集團公司官網建設、成都外貿網站制作、高端網站制作、響應式網頁設計等建站業(yè)務，價格優(yōu)惠性價比高，為日照等各大城市提供網站開發(fā)制作服務。

序言

上一次對比Java說明了Scala的特點和類定義的方法。這一次將更加深入一點，還是以迷你旅行的方式探險一下Scala的語法特點。

接下來介紹一下用代替Java接口的特征(Trait)來實現的混入（mix-in）多重繼承、類型層次和集合。

用特征來實現混入(mix-in)式的多重繼承

Scala里相當于Java接口的是特征(Trait)。Trait的英文意思是特質和性狀（本文稱其為特征），實際上他比接口還功能強大。與接口不同的是，它還可以定義屬性和方法的實現。Scala中特征被用于服務于單一目的功能模塊的模塊化中。通過混合這種特征（模塊）群來實現各種應用程序的功能要求，Scala也是按照這個構想來設計的。

一般情況下Scala的類只能夠繼承單一父類，但是如果是特征的話就可以繼承多個，從結果來看就是實現了多重繼承。這可以被認為是同Ruby模塊基本相同的功能。就看一下下面的例子吧。為了辨認方便，此后的特征名稱前都加上前綴字母T。特征既可以繼承類也可以繼承其他特征。

 
 
 
 
    
  
  
  
  
  1. class Person ; //實驗用的空類，如果使用了上一次的Person類，則下面的 
    2. 
  
  
  
  
  2. //PianoplayingTeacher類就需要構造參數了 
    3. 
  
  
  
  
  3. trait TTeacher extends Person { 
    4. 
  
  
  
  
  4. def teach //虛方法，沒有實現 
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6. trait TPianoPlayer extends Person { 
    7. 
  
  
  
  
  7. def playPiano = {println("I’m playing piano. ")} //實方法，已實現 
    8. 
  
  
  
  
  8. } 
    9. 
  
  
  
  
  9. class PianoplayingTeacher extends Person with TTeacher with TPianoPlayer { 
    10. 
  
  
  
  
  10. def teach = {println("I’m teaching students. ")} //定義虛方法的實現 
    11. 
  
  
  
  
  11. } 
    12.

如上所示，可以連著多個with語句來混合多個特征到一個類中。***個被繼承源用extends，第二個以后的就用with語句。正如大家所知道的，可以生成實例的是非抽象(abstract)的類。另外請注意一下從特征是不可以直接創(chuàng)建實例的。

那么就實際運行一下吧。

 
 
 
 
    
  
  
  
  
  1. scala> val t1 = new PianoplayingTeacher 
    2. 
  
  
  
  
  2. t1: PianoplayingTeacher = PianoplayingTeacher@170a650
    3. 
  
  
  
  
  3. scala> t1.playPiano 
    4. 
  
  
  
  
  4. I’m playing piano. 
    5. 
  
  
  
  
  5. scala> t1.teach 
    6. 
  
  
  
  
  6. I’m teaching students. 
    7.

實際上如下所示，可以在創(chuàng)建對象時才將特征各自的特點賦予對象。

 
 
 
 
    
  
  
  
  
  1. scala> val tanakaTaro = new Person with TTeacher with TPianoPlayer { 
    2. 
  
  
  
  
  2. | def teach = {println("I'm teaching students.")} } 
    3. 
  
  
  
  
  3. tanakaTaro: Person with TTeacher with TPianoPlayer = $anon$1@5bcd91
    4. 
  
  
  
  
  4. scala> tanakaTaro playPiano 
    5. 
  
  
  
  
  5. I’m playing piano. 
    6. 
  
  
  
  
  6. scala> tanakaTaro teach 
    7. 
  
  
  
  
  7. I'm teaching students. 
    8.

用特征來方便地實現面向方面的編程

充分利用特征的功能之后，就能方便地實現現今流行的面向方面編程（AOP）了。

首先，用特征來聲明表示基本動作方法的模塊Taction。

 
 
 
 
    
  
  
  
  
  1. trait TAction { 
    2. 
  
  
  
  
  2. def doAction 
    3. 
  
  
  
  
  3. } 
    4.

接著作為被加入的方面，定義一下加入了前置處理和后置處理的特征TBeforeAfter。

 
 
 
 
    
  
  
  
  
  1. trait TBeforeAfter extends TAction { 
    2. 
  
  
  
  
  2. abstract override def doAction { 
    3. 
  
  
  
  
  3. println("/entry before-action") //doAction的前置處理 
    4. 
  
  
  
  
  4. super.doAction // 調用原來的處理 
    5. 
  
  
  
  
  5. println("/exit after-action") //doAction的后置處理 
    6. 
  
  
  
  
  6. } 
    7. 
  
  
  
  
  7. } 
    8.

通過上面的abstract override def doAction {}語句來覆蓋虛方法。具體來說這當中的super.doAction是關鍵，他調用了TAction的doAction方法。其原理是，由于doAction是虛方法，所以實際被執(zhí)行的是被調用的實體類中所定義的方法。

那么將實際執(zhí)行的實體類RealAction作為TAction的子類來實現吧。

 
 
 
 
    
  
  
  
  
  1. class RealAction extends TAction { 
    2. 
  
  
  
  
  2. def doAction = { println("** real action done!! **") } 
    3. 
  
  
  
  
  3. } 
    4.

接著就執(zhí)行一下。

 
 
 
 
    
  
  
  
  
  1. scala> val act1 = new RealAction with TBeforeAfter 
    2. 
  
  
  
  
  2. act1: RealAction with TBeforeAfter = $anon$1@3bce70
    3. 
  
  
  
  
  3. scala> act1.doAction 
    4. 
  
  
  
  
  4. /entry before-action 
    5. 
  
  
  
  
  5. ** real action done!! ** 
    6. 
  
  
  
  
  6. /exit after-action 
    7.

僅僅這樣還不好玩，接著為他定義一下別的方面，然后將這些方面加入到同一對象的方法中。接著定義一個將源方法執(zhí)行兩遍的方面。

 
 
 
 
    
  
  
  
  
  1. trait TTwiceAction extends TAction { 
    2. 
  
  
  
  
  2. abstract override def doAction { 
    3. 
  
  
  
  
  3. for ( i <- 1 to 2 ) { // 循環(huán)執(zhí)行源方法的方面 
    4. 
  
  
  
  
  4. super.doAction // 調用源方法doAction 
    5. 
  
  
  
  
  5. println( " ==> No." + i ) 
    6. 
  
  
  
  
  6. } 
    7. 
  
  
  
  
  7. } 
    8. 
  
  
  
  
  8. } 
    9.

下面，將TBeforeAfter和TtwiceAction混合在一起后執(zhí)行一下。

 
 
 
 
    
  
  
  
  
  1. scala> val act2 = new RealAction with TBeforeAfter with TTwiceAction 
    2. 
  
  
  
  
  2. act2: RealAction with TBeforeAfter with TTwiceAction = $anon$1@1fcbac1
    3. 
  
  
  
  
  3. scala> act2.doAction 
    4. 
  
  
  
  
  4. /entry before-action 
    5. 
  
  
  
  
  5. ** real action done!! ** 
    6. 
  
  
  
  
  6. /exit after-action 
    7. 
  
  
  
  
  7. ==> No.1
    8. 
  
  
  
  
  8. /entry before-action 
    9. 
  
  
  
  
  9. ** real action done!! ** 
    10. 
  
  
  
  
  10. /exit after-action 
    11. 
  
  
  
  
  11. ==> No.2
    12.

伴隨著原來方法的before/after動作一起各自執(zhí)行了兩次。接著將混入順序顛倒后再試一下。

 
 
 
 
    
  
  
  
  
  1. scala> val act3 = new RealAction with TTwiceAction with TBeforeAfter 
    2. 
  
  
  
  
  2. act3: RealAction with TTwiceAction with TBeforeAfter = $anon$1@6af790
    3. 
  
  
  
  
  3. scala> act3.doAction 
    4. 
  
  
  
  
  4. /entry before-action 
    5. 
  
  
  
  
  5. ** real action done!! ** 
    6. 
  
  
  
  
  6. ==> No.1
    7. 
  
  
  
  
  7. ** real action done!! ** 
    8. 
  
  
  
  
  8. ==> No.2
    9. 
  
  
  
  
  9. /exit after-action 
    10.

這樣執(zhí)行后，原來的實現方法被循環(huán)執(zhí)行了兩次，但是before/after則在循環(huán)以外整體只執(zhí)行了一次。這是根據with語句定義的順序來執(zhí)行的，知道了這原理之后也就沒有什么奇怪的了。Scala特性的如此混入順序是和AspectJ的方面以及Spring的interceptor相同的。

這樣不僅是before和after動作，只要更改了特征的實現就可以將各種方面動態(tài)地加入到原來的對象中去了，讀者自己也可以嘗試一下各種其他情況。

在Java中通過Decorator或Template Method模式來想盡辦法實現的功能，在Scala中只要通過特征就可以輕松到手了。從這還可以延展開來，通過在原來的方法中插入掛鉤的方法，即所謂的攔截者式面向方面的方法，就可以輕松地將各個方面通過特征來組件化了。

請讀者如果想起Scala是怎樣的強類型和靜態(tài)化語言的話，那么就能夠明白通過特征來加入新功能的特

點給他帶來了多大的靈活性。

Scala的類型體系（基本類型）

Scala中可使用的基本數據都以類的形式被定義了，所以基本類型與用戶定義類型可以認為是沒有區(qū)別的。雖然這么說，Scala還是提供了與Java的數據類型相對應的類定義群（圖 4-１）。這絕不是包裝類，在編譯后他們將被映射為Java的字節(jié)碼，所以性能上是絕對沒有問題的。

圖 4-１與Scala基本類型相對應的類群

如下例程序所示，對于整數對象7可以響應各種消息（方法）。既可以執(zhí)行toString方法來轉換成字符串，又可以使用to這個執(zhí)行Int => Range的方法。附帶說一下，7 to 20相當于7.to(20)，該方法的執(zhí)行結果是Range(7,8, 9, … 19, 20)。對于該范圍對象適用了foreach( (i)=>print(i) )，print _則與一個參數的匿名函數(i) => print(i)相當。

 
 
 
 
    
  
  
  
  
  1. scala> 7.toString 
    2. 
  
  
  
  
  2. res2: java.lang.String = 7
    3. 
  
  
  
  
  3. scala> 7 to 20 foreach( print _ ) 
    4. 
  
  
  
  
  4. 7891011121314151617181920
    5.

實際上，Scala在編譯器自動引入的Predef單例對象中定義了為了兼容Java基礎類型所存在的類型別名。例如boolean, char, byte, short, int, long, float, double被定義了，這些別名實際上是引用了Scala.Boolean,Scala.Char,Scala.Byte等Scala的類?？赡艿脑挘瑸榱颂岣摺癝cala中說所有數據都是對象”這種意識，建議盡量一開始就使用Int、Boolean、Float等原來的類名。

不過，在Scala種并沒有類型轉換操作符，而是在所有類的基類Any中定義了具有同等功能的方法asInstanceOf[X]。用這方法就可以把類型轉換為X了。Any類中同時還定義了相當于instanceof操作符的isInstanceOf[X]方法。

圖 4-２Scala類層次的基本結構

特別是該類層次中Iterable下的集類型在函數式編程中大顯身手。其中的可變(mutable)與非可變（immutable）兩大系列的類層次基本上呈現出鏡像關系，可以充分發(fā)揮出函數式語言功能的當然就是非可變集類型群了。

結束語

這一講以迷你旅行的形式說明了一下Scala語法的特點，函數定義和函數式編程就賣個關子放到下一講去吧。


分享標題：Scala講座：混入多重繼承、類型層次和集合
轉載注明：http://www.5511xx.com/article/dpeideh.html