scala面向對象.高階函數,柯里化,Actor編程簡介

1.定義一個類
class Person{
//用val修飾的變量是隻讀屬性，有getter可是沒有setter
val id ="111"
//用var修飾的變量既有getter又有setter
var age:Int =18
//類私有字段，只能在類的內部使用，只有伴生對象內可使用
private var name:String ="aaa"
//對象是由字段，訪問權限更加嚴格,只有person類的方法才能訪問當前對象的pet字段
private[this]val pet="bbb"
}

2.構造器
每一個類都有主主構造器，主構造器的參數直接放置類名後面，與類交織在一塊兒，主構造器會執行類定義中的全部語句

class Person（val name:String）{
//主構造器定義的全部語句都會執行
   println（"執行主構造器"）

  private var age=11
  def this(name:String,age：Int){
  //每一個輔助構造器必須以主構造器或其餘的輔助構造器的調用開始
     this（name）；
    println("執行輔助構造器")
    this.age = age
  }
}

構造器參數能夠不帶var或val，若是不帶val或var的參數至少被一個方法所使用，那麼它將會被提高爲字段
//在類名後面加private就變成了私有的
   class moon private（val name：String，prop：Array[String],private var age:Int =18）{
      println(prop.size))
//prop被下面的方法使用，prop就變成了
      def da = prop.toBuffer
}

object sun{
   def main（args：Array[String]） {
      //私有構造器，只能在伴生對象中使用
      val q = moon("aa",Array("111","222"),20)
      println(q.da())
   }
}

3.單例對象

在Scala中沒有靜態方法和靜態字段，可是可使用object這個語法結構來達到一樣的目的
1.存放工具方法和常量
2.高效共享單個不可變的實例
3.單例模式

object SingletonDemo {
   def main(args: Array[String]) {
      //單例對象，不須要new，用【類名.方法】調用對象中的方法
      val session = SessionFactory.getSession()
      println(session)
   }
}

4.伴生對象

在Scala的類中，與類名相同的對象叫作伴生對象，類和伴生對象之間能夠相互訪問私有的方法和屬性

class Dog {
   val id = 1
   private var name = "itcast"

   def printName(): Unit ={
      //在Dog類中能夠訪問伴生對象Dog的私有屬性
      println( Dog.CONSTANT + name )
   }
}

/**

• 伴生對象
  */
  object Dog {

//伴生對象中的私有屬性
   private val CONSTANT = "汪汪汪 : "

   def main(args: Array[String]) {
     val p = new Dog
     //訪問私有的字段name
     p.name = "123"
     p.printName()
   }
}

5.apply方法

一般咱們會在類的伴生對象中定義apply方法，當遇到類名(參數1,...參數n)時apply方法會被調用
val arr1 = Array(5)
println(arr1.toBuffer)

調用了Array伴生對象的apply方法,arr1中只有一個元素5

6.Scala程序都必須從一個對象的main方法開始，能夠經過擴展App特質，不寫main方法。

7.繼承一個類或實現一個接口，關鍵字都須要使用extends，繼承後再實現須要用關鍵字with，

8.在Scala中重寫一個非抽象的方法必須使用override修飾符

9.類型檢查和轉換須要使用obj.isInstanceOf[C]

10.Scala有一個十分強大的模式匹配機制，能夠應用到不少場合：如switch語句、類型檢查等。
而且Scala還提供了樣例類，對模式匹配進行了優化，能夠快速進行匹配

11.匹配模式

object CaseDemo01 extends App{
  //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello"
   val arr = Array("hello", 1, 2.0, CaseDemo)
   val v = arr(Random.nextInt(4))
   println(v)
   v match {
     case x: Int => println("Int " + x)
     case y: Double if(y >= 0) => println("Double "+ y)
     case z: String => println("String " + z)
     case _ => throw new Exception("not match exception")
  }
}
匹配模式關鍵字使用match，case進行每種類型的匹配
case y: Double if(y >= 0) => ...
模式匹配的時候還能夠添加守衛條件。如不符合守衛條件，將掉入case _中

在Scala中列表要麼爲空（Nil表示空列表）要麼是一個head元素加上一個tail列表。
9 :: List(5, 2) :: 操做符是將給定的頭和尾建立一個新的列表
注意：:: 操做符是右結合的，如9 :: 5 :: 2 :: Nil至關於 9 :: (5 :: (2 :: Nil))

12.Option類型

在Scala中Option類型樣例類用來表示可能存在或也可能不存在的值(Option的子類有Some和None)。Some包裝了某個值，None表示沒有值
def main(args: Array[String]) {
   val map = Map("a" -> 1, "b" -> 2)
   val v = map.get("b") match {
     case Some(i) => i
     case None => 0
   }

13.偏函數

被包在花括號內沒有match的一組case語句是一個偏函數，它是PartialFunction[A, B]的一個實例，A表明參數類型，B表明返回類型，經常使用做輸入模式匹配

def func1: PartialFunction[String, Int] = {
   case "one" => 1
   case "two" => 2
   case _ => -1
}

14.高階函數

定義函數時格式：val 變量名 = (輸入參數類型和個數) => 函數實現和返回值類型和個數
「=」表示將函數賦給一個變量
「=>」左面表示輸入參數名稱、類型和個數，右邊表示函數的實現和返回值類型和參數個數

15.匿名函數

在Scala中，你不須要給每個函數命名，沒有將函數賦給變量的函數叫作匿名函數
arr.map(_ 2)
其中_ 2就是一個匿名函數

16.柯里化

柯里化指的是將原來接受兩個參數的方法變成新的接受一個參數的方法的過程

def m(x: Int)= (y: Int) =>xy
m: (x: Int)Int => Int
看起來比較奇怪即像方法又像函數，能夠理解爲一個方法的實現是 (y: Int) =>xy這個函數

調用val func = m(3)後完全變成了一個函數
func: Int => Int =
至關於將3出入了函數中，val func =(y:Int)=>3*y

func(5)在調用這個函數並傳遞第二個參數，獲得最終結果
Int=15

柯里化通常和隱式轉換一塊兒使用

16.隱式轉換

隱式轉換和隱式參數是Scala中兩個很是強大的功能，利用隱式轉換和隱式參數，你能夠提供優雅的類庫，對類庫的使用者隱匿掉那些枯燥乏味的細節。

隱式轉換函數是指那種以implicit關鍵字聲明的帶有單個參數的函數

/隱式的加強File類的方法
class RichFile(val from: File) {
   def read = Source.fromFile(from.getPath).mkString
}

object RichFile {
   //隱式轉換方法
   implicit def file2RichFile(from: File) = new RichFile(from)
}

object MainApp{
  def main(args: Array[String]): Unit = {
     //導入隱式轉換
    import RichFile._
     //import RichFile.file2RichFile
     println(new File("c://words.txt").read)
  }
}

引入的隱式值>（優先級高於）默認值
若是導入的隱式值有多個同時知足參數會報錯

17.泛型

多重界定符

/* 
  // 表示：A和B爲T上界 
  T <: A with B 
   
  // 表示：A和B爲T下界 
  T >: A with B 
   
  // 表示：同時擁有上界和下界，而且A爲下界，B爲上界，A爲B的子類，順序不能顛倒。 
  T >: A <: B 
   
  // 表示：類型變量界定，即同時知足AT這種隱式值和BT這種隱式值 
  T:A:B 
   
  // 表示：視圖界定，即同時可以知足隱式轉換的A和隱式轉換的B 
  T <% A <% B  
*/

具體泛型使用可見：
http://blog.csdn.net/yuan_xw/article/details/49363749

18.Actor編程

Scala中的Actor可以實現並行編程的強大功能，它是基於事件模型的併發機制，Scala是運用消息（message）的發送、接收來實現多線程的。使用Scala可以更容易地實現多線程應用的開發。

在Scala中，咱們能夠經過複製不可變狀態的資源（即對象，Scala中一切都是對象，連函數、方法也是）的一個副本，再基於Actor的消息發送、接收機制進行並行編程

19.Actor方法執行順序

(1）.首先調用start()方法啓動Actor
(2).調用start()方法後其act()方法會被執行
(3).向Actor發送消息

20.發送消息的方式

! 發送異步消息，沒有返回值。
!? 發送同步消息，等待返回值。
!! 發送異步消息，返回值是 Future[Any]。

21.
class AppleActor extends Actor {

  def act(): Unit = {
     while (true) {
     receive {
         case "start" => println("starting ...")
         case SyncMsg(id, msg) => {
            println(id + ",sync " + msg)
             Thread.sleep(5000)
             sender ! ReplyMsg(3,"finished")
          }
         case AsyncMsg(id, msg) => {
          println(id + ",async " + msg)
          Thread.sleep(5000)
       }
     }
     }
  }
}

object AppleActor {
  def main(args: Array[String]) {
     val a = new AppleActor
     a.start()
     //異步消息
     a ! AsyncMsg(1, "hello actor")
     println("異步消息發送完成")
     //同步消息
     //val content = a.!?(1000, SyncMsg(2, "hello actor"))
     //println(content)
     val reply = a !! SyncMsg(2, "hello actor")
     println(reply.isSet)
     //println("123")
     val c = reply.apply()
     println(reply.isSet)
     println(c)
  }
}
case class SyncMsg(id : Int, msg: String)
case class AsyncMsg(id : Int, msg: String)
case class ReplyMsg(id : Int, msg: String)

receive阻塞（內部阻塞隊列），接受消息,
sender 拿到消息的發送者
isSet判斷val中有沒有值
apply()方法是同步的
react方法複用線程

while（true）和loop的效果同樣的

22. 讀取文件內容source.fromFile(f) f爲文件內容