Scale

Scala 簡介

Scala 是 Scalable Language 的簡寫，是一門多範式的編程語言

聯邦理工學院洛桑（EPFL）的Martin Odersky於2001年基於Funnel的工作開始設計Scala。

Funnel是把函數式編程思想和Petri網相結合的一種編程語言。

Odersky先前的工作是Generic Java和javac（Sun Java編譯器）。Java平臺的Scala於2003年底/2004年初發布。.NET平臺的Scala發佈於2004年6月。該語言第二個版本，v2.0，發佈於2006年3月。

截至2009年9月，最新版本是版本2.7.6 。Scala 2.8預計的特性包括重寫的Scala類庫（Scala collections library）、方法的命名參數和默認參數、包對象（package object），以及Continuation。

2009年4月，Twitter宣佈他們已經把大部分後端程序從Ruby遷移到Scala，其餘部分也打算要遷移。此外， Wattzon已經公開宣稱，其整個平臺都已經是基於Scala基礎設施編寫的。

Scala 特性

面向對象特性

Scala是一種純面向對象的語言，每個值都是對象。對象的數據類型以及行爲由類和特質描述。

類抽象機制的擴展有兩種途徑：一種途徑是子類繼承，另一種途徑是靈活的混入機制。這兩種途徑能避免多重繼承的種種問題。

函數式編程

Scala也是一種函數式語言，其函數也能當成值來使用。Scala提供了輕量級的語法用以定義匿名函數，支持高階函數，允許嵌套多層函數，並支持柯里化。Scala的case class及其內置的模式匹配相當於函數式編程語言中常用的代數類型。

更進一步，程序員可以利用Scala的模式匹配，編寫類似正則表達式的代碼處理XML數據。

靜態類型

Scala具備類型系統，通過編譯時檢查，保證代碼的安全性和一致性。類型系統具體支持以下特性：

泛型類
協變和逆變
標註
類型參數的上下限約束
把類別和抽象類型作爲對象成員
複合類型
引用自己時顯式指定類型
視圖
多態方法

擴展性

Scala的設計秉承一項事實，即在實踐中，某個領域特定的應用程序開發往往需要特定於該領域的語言擴展。Scala提供了許多獨特的語言機制，可以以庫的形式輕易無縫添加新的語言結構：

任何方法可用作前綴或後綴操作符
可以根據預期類型自動構造閉包。

併發性
Scala使用Actor作爲其併發模型，Actor是類似線程的實體，通過郵箱發收消息。Actor可以複用線程，因此可以在程序中可以使用數百萬個Actor,而線程只能創建數千個。在2.10之後的版本中，使用Akka作爲其默認Actor實現。

入門

似乎一切語言的學習，都從“Hello, World!”開始，這次也不能免俗，先來第一個程序：
編程工具推薦使用intelliJ IDEA

安裝intelliJ IDEA教程參考

object HelloWorld {
    def main(args: Array[String]): Unit = {
        println("Hello, world!")
    }
} 

def main(args: Array[String]) - Scala程序從main()方法開始處理，這是每一個Scala程序的強制程序入口部分。
我的理解是主函數，基本每個費腳本語言程序都有。

Scala 基礎語法

如果你之前是一名 Java 程序員，並瞭解 Java 語言的基礎知識，那麼你能很快學會 Scala 的基礎語法。

Scala 與 Java 的最大區別是：Scala 語句末尾的分號 ; 是可選的。

我們可以認爲 Scala 程序是對象的集合，通過調用彼此的方法來實現消息傳遞。接下來我們來理解下，類，對象，方法，實例變量的概念：

對象 - 對象有屬性和行爲。例如：一隻狗的狀屬性有：顏色，名字，行爲有：叫、跑、吃等。對象是一個類的實例。

類 - 類是對象的抽象，而對象是類的具體實例。

方法 - 方法描述的基本的行爲，一個類可以包含多個方法。

字段 - 每個對象都有它唯一的實例變量集合，即字段。對象的屬性通過給字段賦值來創建。

scale基本跟java類似，一些使用上面更靈活更簡潔，方法和類的定義基本和java一樣,省去了理解上的不少麻煩。
輸出：scale 的輸出沒有java那麼長一串，只需要很簡單的println()
就可以輸出你想要的數據：

object HelloWorld {
   /* 這是我的第一個 Scala 程序
    * 以下程序將輸出'Hello World!' 
    */
   def main(args: Array[String]) {
      println("Hello, world!") // 輸出 Hello World
      var s = myＡdd(7,8)　　//調用方法函數
   }
    #方法定義
　　def myＡdd(int2: Int ,int1: Int): Int={
//Int 是返回數據的類型
      var result =  int2+int1
      return result
  }
}

創建一個person類：

/**
  * Created by zhuan on 16-10-8.
  */
class Ｐerson(x:Int,y:Int) {
  var age:Int = x;
  var salary:Int = y;

  def judge(){
    if(age<salary/３00){
      println("you are a successful man!")
    }else{
      println("you are a lose man...")
    }

  }

}

根據上述Person類New一個Person對象：

 var NewMan = new Ｐerson(35,7500);

初學者可能對var 和val 搞不清，作用差不多，好像都能用，其實不然：
val 值不可變(等同於java裏的 final )
而var 是可變，由於不是本文重點，更多細節區別不在贅述。
導包上的區別：一次可以同一目錄下的多個包

import java.awt.{Color, Font}

// 重命名成員
import java.util.{HashMap => JavaHashMap}

// 隱藏成員
import java.util.{HashMap => _, _} // 引入了util包的所有成員，但是HashMap被隱藏了

Scale數據類型：

變量的聲明：

var myVar : String = "Foo"
var myVar : String = "Too"

var VariableName : DataType [=  Initial Value]

val VariableName : DataType [=  Initial Value]
//不聲明初始值
var myVar :Int;
val myVal :String;

函數聲明：

def functionName ([參數列表]) : [return type]

def functionName ([參數列表]) : [return type] = {
   function body
   return [expr]
}

Scala 訪問修飾符

Scala 訪問修飾符基本和Java的一樣，分別有：private，protected，public。

如果沒有指定訪問修飾符符，默認情況下，Scala對象的訪問級別都是 public。

Scala 中的 private 限定符，比 Java 更嚴格，在嵌套類情況下，外層類甚至不能訪問被嵌套類的私有成員。

有特色的閉包函數，感覺有點像python裏面的lambda函數：

object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " +  multiplier(1) )  
      println( "muliplier(2) value = " +  multiplier(2) )  
   }  
   var factor = 3  
   val multiplier = (i:Int) => i * factor  
}  

數據結構

數組：

var z:Array[String] = new Array[String](3)

//或

var z = new Array[String](3)

var z = Array("Runoob", "Baidu", "Google")

多維數組：

import Array._

object Test {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)

      // 創建矩陣
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }

      // 打印二維陣列
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }

   }
}

這裏順便提一下，scale特有的for 循環：

for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }

   }

scale使用<- 這個符號給i 賦值，這個賦值符號跟Ｒ語言的<-是一樣的，根據Ｒ來理解似乎是兩者並不是完全意義上的相等，而是一種類似Ｃ語言一樣的指針指代關係，似乎這樣的符號比＝更貼切。
for (i <- 0 to 2)　等價於：for (int i=0;i<=2;i++)

list

// 字符串列表
val site: List[String] = List("Runoob", "Google", "Baidu")

// 整型列表
val nums: List[Int] = List(1, 2, 3, 4)

// 空列表
val empty: List[Nothing] = List()

// 二維列表
val dim: List[List[Int]] =
   List(
      List(1, 0, 0),
      List(0, 1, 0),
      List(0, 0, 1)
   )

// 字符串列表
val site = "Runoob" :: ("Google" :: ("Baidu" :: Nil))

// 整型列表
val nums = 1 :: (2 :: (3 :: (4 :: Nil)))

// 空列表
val empty = Nil

// 二維列表
val dim = (1 :: (0 :: (0 :: Nil))) ::
          (0 :: (1 :: (0 :: Nil))) ::
          (0 :: (0 :: (1 :: Nil))) :: Nil

參考文檔

Scala Iterator（迭代器）

object Test {
   def main(args: Array[String]) {
      val it = Iterator("Baidu", "Google", "Runoob", "Taobao")

      while (it.hasNext){
         println(it.next())
      }
   }
}