本文繼續(xù)探索 Scala 的語言和庫支持，我們將改造一下計(jì)算器 DSL 并最終 “完成它”。DSL 本身有點(diǎn)簡單 — 一個(gè)簡單的計(jì)算器，目前為止只支持 4 個(gè)基本數(shù)學(xué)運(yùn)算符。但要記住，我們的目標(biāo)是創(chuàng)建一些可擴(kuò)展的、靈活的對象，并且以后可以輕松增強(qiáng)它們以支持新的功能。

繼續(xù)上次的討論……

說明一下，目前我們的 DSL 有點(diǎn)零亂。我們有一個(gè)抽象語法樹（Abstract Syntax Tree ），它由大量 case 類組成……

清單 1. 后端（AST）

package com.tedneward.calcdsl  
{  
  // ...  
 
  private[calcdsl] abstract class Expr  
  private[calcdsl]  case class Variable(name : String) extends Expr  
  private[calcdsl]  case class Number(value : Double) extends Expr  
  private[calcdsl]  case class UnaryOp(operator : String, arg : Expr) extends Expr  
  private[calcdsl]  case class BinaryOp(operator : String, left : Expr, right : Expr)  
   extends Expr  
 
}  

……對此我們可以提供類似解釋器的行為，它能最大限度地簡化數(shù)學(xué)表達(dá)式……

清單 2. 后端（解釋器）

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    def simplify(e: Expr): Expr = {  
      // first simplify the subexpressions  
      val simpSubs = e match {  
        // Ask each side to simplify  
        case BinaryOp(op, left, right) => BinaryOp(op, simplify(left), simplify(right))  
        // Ask the operand to simplify  
        case UnaryOp(op, operand) => UnaryOp(op, simplify(operand))  
        // Anything else doesn't have complexity (no operands to simplify)  
        case _ => e  
      }  
 
      // now simplify at the top, assuming the components are already simplified  
      def simplifyTop(x: Expr) = x match {  
        // Double negation returns the original value  
        case UnaryOp("-", UnaryOp("-", x)) => x  
    
        // Positive returns the original value  
        case UnaryOp("+", x) => x  
    
        // Multiplying x by 1 returns the original value  
        case BinaryOp("*", x, Number(1)) => x  
    
        // Multiplying 1 by x returns the original value  
        case BinaryOp("*", Number(1), x) => x  
    
        // Multiplying x by 0 returns zero  
        case BinaryOp("*", x, Number(0)) => Number(0)  
    
        // Multiplying 0 by x returns zero  
        case BinaryOp("*", Number(0), x) => Number(0)  
    
        // Dividing x by 1 returns the original value  
        case BinaryOp("/", x, Number(1)) => x  
    
        // Dividing x by x returns 1  
        case BinaryOp("/", x1, x2) if x1 == x2 => Number(1)  
    
        // Adding x to 0 returns the original value  
        case BinaryOp("+", x, Number(0)) => x  
    
        // Adding 0 to x returns the original value  
        case BinaryOp("+", Number(0), x) => x  
    
        // Anything else cannot (yet) be simplified  
        case e => e  
      }  
      simplifyTop(simpSubs)  
    }  
    
    def evaluate(e : Expr) : Double =  
    {  
      simplify(e) match {  
        case Number(x) => x  
        case UnaryOp("-", x) => -(evaluate(x))  
        case BinaryOp("+", x1, x2) => (evaluate(x1) + evaluate(x2))  
        case BinaryOp("-", x1, x2) => (evaluate(x1) - evaluate(x2))  
        case BinaryOp("*", x1, x2) => (evaluate(x1) * evaluate(x2))  
        case BinaryOp("/", x1, x2) => (evaluate(x1) / evaluate(x2))  
      }  
    }  
  }  
}  

……我們使用了一個(gè)由 Scala 解析器組合子構(gòu)建的文本解析器，用于解析簡單的數(shù)學(xué)表達(dá)式……

清單 3. 前端

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    object ArithParser extends JavaTokenParsers  
    {  
      def expr: Parser[Any] = term ~ rep("+"~term | "-"~term)  
      def term : Parser[Any] = factor ~ rep("*"~factor | "/"~factor)  
      def factor : Parser[Any] = floatingPointNumber | "("~expr~")"   
        
      def parse(text : String) =  
      {  
        parseAll(expr, text)  
      }  
    }  
      
    // ...  
  }  
}  

……但在進(jìn)行解析時(shí)，由于解析器組合子當(dāng)前被編寫為返回 Parser[Any] 類型，所以會(huì)生成 String 和 List 集合，實(shí)際上應(yīng)該讓解析器返回它需要的任意類型（我們可以看到，此時(shí)是一個(gè) String 和 List 集合）。

要讓 DSL 成功，解析器需要返回 AST 中的對象，以便在解析完成時(shí)，執(zhí)行引擎可以捕獲該樹并對它執(zhí)行 evaluate()。對于該前端，我們需要更改解析器組合子實(shí)現(xiàn)，以便在解析期間生成不同的對象。

#p#

清理語法

對解析器做的第一個(gè)更改是修改其中一個(gè)語法。在原來的解析器中，可以接受像 “5 + 5 + 5” 這樣的表達(dá)式，因?yàn)檎Z法中為表達(dá)式（expr）和術(shù)語（term）定義了 rep() 組合子。但如果考慮擴(kuò)展，這可能會(huì)引起一些關(guān)聯(lián)性和操作符優(yōu)先級問題。以后的運(yùn)算可能會(huì)要求使用括號(hào)來顯式給出優(yōu)先級，以避免這類問題。因此第一個(gè)更改是將語法改為要求在所有表達(dá)式中加 “()”。

回想一下，這應(yīng)該是我一開始就需要做的事情；事實(shí)上，放寬限制通常比在以后添加限制容易（如果最后不需要這些限制），但是解決運(yùn)算符優(yōu)先級和關(guān)聯(lián)性問題比這要困難得多。如果您不清楚運(yùn)算符的優(yōu)先級和關(guān)聯(lián)性；那么讓我大致概述一下我們所處的環(huán)境將有多復(fù)雜。考慮 Java 語言本身和它支持的各種運(yùn)算符（如 Java 語言規(guī)范中所示）或一些關(guān)聯(lián)性難題（來自 Bloch 和 Gafter 提供的 Java Puzzlers），您將發(fā)現(xiàn)情況不容樂觀。

因此，我們需要逐步解決問題。首先是再次測試語法：

清單 4. 采用括號(hào)

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    // ...  
      
    object OldAnyParser extends JavaTokenParsers  
    {  
      def expr: Parser[Any] = term ~ rep("+"~term | "-"~term)  
      def term : Parser[Any] = factor ~ rep("*"~factor | "/"~factor)  
      def factor : Parser[Any] = floatingPointNumber | "("~expr~")"   
        
      def parse(text : String) =  
      {  
        parseAll(expr, text)  
      }  
    }  
    object AnyParser extends JavaTokenParsers  
    {  
      def expr: Parser[Any] = (term~"+"~term) | (term~"-"~term) | term  
      def term : Parser[Any] = (factor~"*"~factor) | (factor~"/"~factor) | factor  
      def factor : Parser[Any] = "(" ~> expr <~ ")" | floatingPointNumber  
        
      def parse(text : String) =  
      {  
        parseAll(expr, text)  
      }  
    }  
      
    // ...  
  }  
}  

我已經(jīng)將舊的解析器重命名為 OldAnyParser，添加左邊的部分是為了便于比較；新的語法由 AnyParser 給出；注意它將 expr 定義為 term + term、term - term，或者一個(gè)獨(dú)立的 term，等等。另一個(gè)大的變化是 factor 的定義，現(xiàn)在它使用另一種組合子 ~> 和 <~ 在遇到 ( 和 ) 字符時(shí)有效地拋出它們。

因?yàn)檫@只是一個(gè)臨時(shí)步驟，所以我不打算創(chuàng)建一系列單元測試來查看各種可能性。不過我仍然想確保該語法的解析結(jié)果符合預(yù)期，所以我在這里編寫一個(gè)不是很正式的測試：

清單 5. 測試解析器的非正式測試

package com.tedneward.calcdsl.test  
{  
  class CalcTest  
  {  
    import org.junit._, Assert._  
      
    // ...  
      
    _cnnew1@Test def parse =  
    {  
      import Calc._  
        
      val expressions = List(  
        "5",  
        "(5)",  
        "5 + 5",  
        "(5 + 5)",  
        "5 + 5 + 5",  
        "(5 + 5) + 5",  
        "(5 + 5) + (5 + 5)",  
        "(5 * 5) / (5 * 5)",  
        "5 - 5",  
        "5 - 5 - 5",  
        "(5 - 5) - 5",  
        "5 * 5 * 5",  
        "5 / 5 / 5",  
        "(5 / 5) / 5" 
      )  
        
      for (x <- expressions)  
        System.out.println(x + " = " + AnyParser.parse(x))  
    }  
  }  
} 

請記住，這純粹是出于教學(xué)目的（也許有人會(huì)說我不想為產(chǎn)品代碼編寫測試，但我確實(shí)沒有在編寫產(chǎn)品代碼，所以我不需要編寫正式的測試。這只是為了方便教學(xué)）。但是，運(yùn)行這個(gè)測試后，得到的許多結(jié)果與標(biāo)準(zhǔn)單元測試結(jié)果文件相符，表明沒有括號(hào)的表達(dá)式（5 + 5 + 5）執(zhí)行失敗，而有括號(hào)的表達(dá)式則會(huì)執(zhí)行成功。真是不可思議！

不要忘了給解析測試加上注釋。更好的方法是將該測試完全刪除。這是一個(gè)臨時(shí)編寫的測試，而且我們都知道，真正的 Jedi 只在研究或防御時(shí)使用這些源代碼，而不在這種情況中使用。

#p#

清理語法

現(xiàn)在我們需要再次更改各種組合子的定義?；仡櫼幌?A >上一篇文章，expr、term 和 factor 函數(shù)中的每一個(gè)實(shí)際上都是 BNF 語句，但注意每一個(gè)函數(shù)返回的都是一個(gè)解析器泛型，參數(shù)為 Any（Scala 類型系統(tǒng)中一個(gè)基本的超類型，從其名稱就可以知道它的作用：指示可以包含任何對象的潛在類型或引用）；這表明組合子可以根據(jù)需要返回任意類型。我們已經(jīng)看到，在默認(rèn)情況下，解析器可以返回一個(gè) String，也可以返回一個(gè) List（如果您還不信的話，可以在運(yùn)行的測試中加入臨時(shí)測試。這也會(huì)看到同樣的結(jié)果）。

要將它更改為生成 case 類 AST 層次結(jié)構(gòu)的實(shí)例（Expr 對象），組合子的返回類型必須更改為 Parser[Expr]。如果讓它自行更改，編譯將會(huì)失??；這三個(gè)組合子知道如何獲取 String，但不知道如何根據(jù)解析的內(nèi)容生成 Expr 對象。為此，我們使用了另一個(gè)組合子，即 ^^ 組合子，它以一個(gè)匿名函數(shù)為參數(shù)，將解析的結(jié)果作為一個(gè)參數(shù)傳遞給該匿名函數(shù)。

如果您和許多 Java 開發(fā)人員一樣，那么就要花一點(diǎn)時(shí)間進(jìn)行解析，讓我們查看一下實(shí)際效果：

清單 6. 產(chǎn)品組合子

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    object ExprParser extends JavaTokenParsers  
    {  
      def expr: Parser[Expr] =  
        (term ~ "+" ~ term) ^^ { case lhs~plus~rhs => BinaryOp("+", lhs, rhs) } |  
        (term ~ "-" ~ term) ^^ { case lhs~minus~rhs => BinaryOp("-", lhs, rhs) } |  
        term   
 
      def term: Parser[Expr] =  
        (factor ~ "*" ~ factor) ^^ { case lhs~times~rhs => BinaryOp("*", lhs, rhs) } |  
        (factor ~ "/" ~ factor) ^^ { case lhs~div~rhs => BinaryOp("/", lhs, rhs) } |  
        factor  
 
      def factor : Parser[Expr] =  
        "(" ~> expr <~ ")" |  
        floatingPointNumber ^^ {x => Number(x.toFloat) }  
        
      def parse(text : String) = parseAll(expr, text)  
    }  
    
    def parse(text : String) =  
      ExprParser.parse(text).get  
 
    // ...  
  }  
    
  // ...  
}  

^^ 組合子接收一個(gè)匿名函數(shù)，其解析結(jié)果（例如，假設(shè)輸入的是 5 + 5，那么解析結(jié)果將是 ((5~+)~5)）將會(huì)被單獨(dú)傳遞并得到一個(gè)對象 — 在本例中，是一個(gè)適當(dāng)類型的 BinaryObject。請?jiān)俅巫⒁饽Ｊ狡ヅ涞膹?qiáng)大功能；我將表達(dá)式的左邊部分與 lhs 實(shí)例綁定在一起，將 + 部分與（未使用的）plus 實(shí)例綁定在一起，該表達(dá)式的右邊則與 rhs 綁定，然后我分別使用 lhs 和 rhs 填充 BinaryOp 構(gòu)造函數(shù)的左邊和右邊。

現(xiàn)在運(yùn)行代碼（記得注釋掉臨時(shí)測試），單元測試集會(huì)再次產(chǎn)生所有正確的結(jié)果：我們以前嘗試的各種表達(dá)式不會(huì)再失敗，因?yàn)楝F(xiàn)在解析器生成了派生 Expr 對象。前面已經(jīng)說過，不進(jìn)一步測試解析器是不負(fù)責(zé)任的，所以讓我們添加更多的測試（包括我之前在解析器中使用的非正式測試）：

清單 7. 測試解析器（這次是正式的）

package com.tedneward.calcdsl.test  
{  
  class CalcTest  
  {  
    import org.junit._, Assert._  
      
    // ...  
      
    @Test def parseAnExpr1 =  
      assertEquals(  
        Number(5),  
        Calc.parse("5")  
      )  
    @Test def parseAnExpr2 =  
      assertEquals(  
        Number(5),  
        Calc.parse("(5)")  
      )  
    @Test def parseAnExpr3 =  
      assertEquals(  
        BinaryOp("+", Number(5), Number(5)),  
        Calc.parse("5 + 5")  
      )  
    @Test def parseAnExpr4 =  
      assertEquals(  
        BinaryOp("+", Number(5), Number(5)),  
        Calc.parse("(5 + 5)")  
      )  
    @Test def parseAnExpr5 =  
      assertEquals(  
        BinaryOp("+", BinaryOp("+", Number(5), Number(5)), Number(5)),  
        Calc.parse("(5 + 5) + 5")  
      )  
    @Test def parseAnExpr6 =  
      assertEquals(  
        BinaryOp("+", BinaryOp("+", Number(5), Number(5)), BinaryOp("+", Number(5),  
                 Number(5))),  
        Calc.parse("(5 + 5) + (5 + 5)")  
      )  
      
    // other tests elided for brevity  
  }  
} 

讀者可以再增加一些測試，因?yàn)槲铱赡苈┑粢恍┎怀Ｒ姷那闆r（與 Internet 上的其他人結(jié)對編程是比較好的）。

完成最后一步

假設(shè)解析器正按照我們想要的方式在工作 — 即生成 AST — 那么現(xiàn)在只需要根據(jù) AST 對象的計(jì)算結(jié)果來完善解析器。這很簡單，只需向 Calc 添加代碼，如清單 8 所示……

清單 8. 真的完成啦！

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    // ...  
      
    def evaluate(text : String) : Double = evaluate(parse(text))  
  }  
}  

……同時(shí)添加一個(gè)簡單的測試，確保 evaluate("1+1") 返回 2.0……

清單 9. 最后，看一下 1 + 1 是否等于 2

package com.tedneward.calcdsl.test  
{  
  class CalcTest  
  {  
    import org.junit._, Assert._  
      
    // ...  
      
    @Test def add1 =  
      assertEquals(Calc.evaluae("1 + 1"), 2.0)  
  }  
} 

……然后運(yùn)行它，一切正常！

#p#

擴(kuò)展 DSL 語言

如果完全用 Java 代碼編寫同一個(gè)計(jì)算器 DSL，而沒有碰到我遇到的問題（在不構(gòu)建完整的 AST 的情況下遞歸式地計(jì)算每一個(gè)片段，等等），那么似乎它是另一種能夠解決問題的語言或工具。但以這種方式構(gòu)建語言的強(qiáng)大之處會(huì)在擴(kuò)展性上得到體現(xiàn)。

例如，我們向這種語言添加一個(gè)新的運(yùn)算符，即 ^ 運(yùn)算符，它將執(zhí)行求冪運(yùn)算；也就是說，2 ^ 2 等于 2 的平方 或 4。向 DSL 語言添加這個(gè)運(yùn)算符需要一些簡單步驟。

首先，您必須考慮是否需要更改 AST。在本例中，求冪運(yùn)算符是另一種形式的二進(jìn)制運(yùn)算符，所以使用現(xiàn)有 BinaryOp case 類就可以。無需對 AST 進(jìn)行任何更改。

其次，必須修改 evaluate 函數(shù)，以使用 BinaryOp("^", x, y) 執(zhí)行正確的操作；這很簡單，只需添加一個(gè)嵌套函數(shù)（因?yàn)椴槐卦谕獠靠吹竭@個(gè)函數(shù)）來實(shí)際計(jì)算指數(shù)，然后向模式匹配添加必要的代碼行，如下所示：

清單 10. 稍等片刻

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    // ...  
      
    def evaluate(e : Expr) : Double =  
    {  
      def exponentiate(base : Double, exponent : Double) : Double =  
        if (exponent == 0)   
          1.0 
        else 
          base * exponentiate(base, exponent - 1)  
 
      simplify(e) match {  
        case Number(x) => x  
        case UnaryOp("-", x) => -(evaluate(x))  
        case BinaryOp("+", x1, x2) => (evaluate(x1) + evaluate(x2))  
        case BinaryOp("-", x1, x2) => (evaluate(x1) - evaluate(x2))  
        case BinaryOp("*", x1, x2) => (evaluate(x1) * evaluate(x2))  
        case BinaryOp("/", x1, x2) => (evaluate(x1) / evaluate(x2))  
        case BinaryOp("^", x1, x2) => exponentiate(evaluate(x1), evaluate(x2))  
      }  
    }  
  }  
}  

注意，這里我們只使用 6 行代碼就有效地向系統(tǒng)添加了求冪運(yùn)算，同時(shí)沒有對 Calc 類進(jìn)行任何表面更改。這就是封裝！

（在我努力創(chuàng)建最簡單求冪函數(shù)時(shí)，我故意創(chuàng)建了一個(gè)有嚴(yán)重 bug 的版本 —— 這是為了讓我們關(guān)注語言，而不是實(shí)現(xiàn)。也就是說，看看哪位讀者能夠找到 bug。他可以編寫發(fā)現(xiàn) bug 的單元測試，然后提供一個(gè)無 bug 的版本）。

但是在向解析器添加這個(gè)求冪函數(shù)之前，讓我們先測試這段代碼，以確保求冪部分能正常工作：

清單 11. 求平方

package com.tedneward.calcdsl.test  
{  
  class CalcTest  
  {  
    // ...  
      
    @Test def evaluateSimpleExp =  
    {  
      val expr =  
        BinaryOp("^", Number(4), Number(2))  
      val results = Calc.evaluate(expr)  
      // (4 ^ 2) => 16  
      assertEquals(16.0, results)  
    }  
    @Test def evaluateComplexExp =  
    {  
      val expr =  
        BinaryOp("^",  
          BinaryOp("*", Number(2), Number(2)),  
          BinaryOp("/", Number(4), Number(2)))  
      val results = Calc.evaluate(expr)  
      // ((2 * 2) ^ (4 / 2)) => (4 ^ 2) => 16  
      assertEquals(16.0, results)  
    }  
  }  
} 

運(yùn)行這段代碼確保可以求冪（忽略我之前提到的 bug），這樣就完成了一半的工作。

最后一個(gè)更改是修改語法，讓它接受新的求冪運(yùn)算符；因?yàn)榍髢绲膬?yōu)先級與乘法和除法的相同，所以最簡單的做法是將它放在 term 組合子中：

清單 12. 完成了，這次是真的！

package com.tedneward.calcdsl  
{  
  // ...  
 
  object Calc  
  {  
    // ...  
      
    object ExprParser extends JavaTokenParsers  
    {  
      def expr: Parser[Expr] =  
        (term ~ "+" ~ term) ^^ { case lhs~plus~rhs => BinaryOp("+", lhs, rhs) } |  
        (term ~ "-" ~ term) ^^ { case lhs~minus~rhs => BinaryOp("-", lhs, rhs) } |  
        term   
 
      def term: Parser[Expr] =  
        (factor ~ "*" ~ factor) ^^ { case lhs~times~rhs => BinaryOp("*", lhs, rhs) } |  
        (factor ~ "/" ~ factor) ^^ { case lhs~div~rhs => BinaryOp("/", lhs, rhs) } |  
        (factor ~ "^" ~ factor) ^^ { case lhs~exp~rhs => BinaryOp("^", lhs, rhs) } |  
        factor  
 
      def factor : Parser[Expr] =  
        "(" ~> expr <~ ")" |  
        floatingPointNumber ^^ {x => Number(x.toFloat) }  
        
      def parse(text : String) = parseAll(expr, text)  
    }  
      
  // ...  
  }  
}  
   

當(dāng)然，我們需要對這個(gè)解析器進(jìn)行一些測試……

清單 13. 再求平方

package com.tedneward.calcdsl.test  
{  
  class CalcTest  
  {  
    // ...  
      
    @Test def parseAnExpr17 =  
      assertEquals(  
        BinaryOp("^", Number(2), Number(2)),  
        Calc.parse("2 ^ 2")  
      )  
    @Test def parseAnExpr18 =  
      assertEquals(  
        BinaryOp("^", Number(2), Number(2)),  
        Calc.parse("(2 ^ 2)")  
      )  
    @Test def parseAnExpr19 =  
      assertEquals(  
        BinaryOp("^", Number(2),  
          BinaryOp("+", Number(1), Number(1))),  
        Calc.parse("2 ^ (1 + 1)")  
      )  
    @Test def parseAnExpr20 =  
      assertEquals(  
        BinaryOp("^", Number(2), Number(2)),  
        Calc.parse("2 ^ (2)")  
      )  
  }  
} 

……運(yùn)行并通過后，還要進(jìn)行最后一個(gè)測試，看一切是否能正常工作：

清單 14. 從 String 到平方

package com.tedneward.calcdsl.test  
{  
  class CalcTest  
  {  
    // ...  
      
    @Test def square1 =  
      assertEquals(Calc.evaluate("2 ^ 2"), 4.0)  
  }  
} 

成功啦！

結(jié)束語

顯然，還要做更多工作才能使這門簡單的語言變得更好；不管您對該語言的各個(gè)部分測試（AST、解析器、簡化引擎，等等）感覺如何，僅僅將該語言編寫為基于解釋器的對象都可以通過更少的代碼來實(shí)現(xiàn)（也可能更快，這取決于您的熟練程度），甚至可以動(dòng)態(tài)地計(jì)算表達(dá)式的值，而不是將它們轉(zhuǎn)換為 AST 后再進(jìn)行計(jì)算。

向系統(tǒng)添加另一種運(yùn)算符是非常簡單的。該語言的設(shè)計(jì)也使它的擴(kuò)展非常容易，擴(kuò)展時(shí)不需要修改很多代碼。事實(shí)上，我們可以通過許多增強(qiáng)來演示該方法的內(nèi)在靈活性：

◆我們可以從使用 Doubles 轉(zhuǎn)向使用 BigDecimals 或 BigIntegers，而不是用 java.math 包（以允許進(jìn)行更大和/或更準(zhǔn)確的計(jì)算）。

◆我們可以在語言中支持十進(jìn)制數(shù)（當(dāng)前解析器中不支持）。

◆我們可以使用單詞（“sin”、“cos”、“tan” 等）而不是符號(hào)來添加運(yùn)算符。

◆我們甚至可以添加變量符號(hào)（“x = y + 12”）并接受 Map 作為 evaluate() 函數(shù)的參數(shù)，該函數(shù)包含每個(gè)變量的初始值。

◆更重要的是，DSL 完全隱藏在 Calc 類后面，這意味著從 Java 代碼調(diào)用它與從 Scala 調(diào)用它一樣簡單。所以即使在沒有完全采用 Scala 作為首選語言

◆項(xiàng)目中，也可以用 Scala 編寫部分系統(tǒng)（那些最適合使用函數(shù)性/對象混合語言的部分），而且 Java 開發(fā)人員可以輕松地調(diào)用它們。

【相關(guān)閱讀】

1. Scala編程語言專題
2. 從Java走進(jìn)Scala:構(gòu)建計(jì)算器 解析器組合子入門
3. 從Java走進(jìn)Scala:簡單的計(jì)算器 case類和模式匹配
4. 從Java走進(jìn)Scala:包和訪問修飾符
5. 從Java走進(jìn)Scala:使用元組、數(shù)組和列表