scala的小知識

1、變量和常量的聲明

變量：用var定義，可修改
常量：用val定義，不可修改
當參數沒有修飾，那麼外部無法通過對象來調用，類似於JAVA中的private。

var name = "zhangsan"
val gender = "男"

3、類和對象

半生類：

class Person{
  val name = "zhangsan"
  val age = 18
  def sayName() = {
    "my name is "+ name
  }
}

伴生對象：

object Lesson_Class {
   def main(args: Array[String]): Unit = {
    val person = new Person()
    println(person.age);
    println(person.sayName())
  }
}

總結：

1. 構造函數和JAVA不一樣，直接類名後加參數
2. 伴生類中主要聲明動態屬性，伴生對象主要聲明靜態屬性。

4、if else判斷體
if else
if else if else
5、循環體
for循環
通過索引
增強for循環
雙重循環
帶有判斷條件
yield
while循環
do while循環
總結：

yied關鍵詞能夠將符合要求的元素自動封裝到一個集合中
1 to 10包括10，1 until 10不包括10
scala中不能使用count++，只能使用count = count+1
在scala中沒有break跳出循環，可設置標記，例如var flag = true

6、Trait特性

Scala相當於JAVA中的接口但是他比接口功能更加強大，與接口不同的是它還可以定義屬性和方法的實現。
Trait可以繼承多個Trait，也就是多繼承，Trait定義的方式與類相似，使用關鍵字trait。

trait Read {
  val readType = "Read"
  val gender = "m"
  def read(name:String){
	println(name+" is reading")
  }
}

trait Listen {
  val listenType = "Listen"
  val gender = "m"
  def listen(name:String){
	println(name + " is listenning")
  }
}

class Person() extends Read with Listen{
  override val gender = "f"
}

object test {
  def main(args: Array[String]): Unit = {
    val person = new Person()
    person.read("zhangsan")
    person.listen("lisi")
    println(person.listenType)
    println(person.readType)
    println(person.gender)    
  }
}

注意：

1. 繼承的多個trait中如果有同名的方法和屬性，必須要在類中使用“override”重新定義。
2. trait中不可以傳參數。

7、模式匹配

類似於JAVA中的switch case，Scala中也提供了強大的模式匹配機制，一個模式匹配包含了一系列備選項，每個都開始於關鍵字 case。

object Lesson_Match {
  def main(args: Array[String]): Unit = {
    val tuple = Tuple6(1,2,3f,4,"abc",55d)
    val tupleIterator = tuple.productIterator
    while(tupleIterator.hasNext){
      matchTest(tupleIterator.next())
    }   
  }

  def matchTest(x:Any) ={
    x match {
      case x:Int=> println("type is Int")
      case 1 => println("result is 1")
      case 2 => println("result is 2")
      case 3=> println("result is 3")
      case 4 => println("result is 4")
      case x:String => println("type is String")
//    case x :Double => println("type is Double")
      case _ => println("no match")
    }
  }  
}

注意：

1. 模式匹配不僅可以匹配值，還可以匹配類型
2. 模式匹配中，如果匹配到對應的類型或值，就不再繼續往下匹配
3. 模式匹配中，都匹配不上時，會匹配到 case _ ，相當於default

7、樣例類

使用了case關鍵字的定義的類就是樣例類，樣例類是特殊的類。實現了類構造參數的getter方法(構造參數默認被聲明爲val)，當構造參數是聲明爲var類型的，它將幫你實現setter和getter方法。

// 集合模式匹配
case class Person1(name:String,age:Int)

object Lesson_CaseClass {
  def main(args: Array[String]): Unit = {
    val p1 = new Person1("zhangsan",10)
    val p2 = Person1("lisi",20)
    val p3 = Person1("wangwu",30)
    
    val list = List(p1,p2,p3)
    list.foreach { x => {
      x match {
        case Person1("zhangsan",10) => println("zhangsan")
        case Person1("lisi",20) => println("lisi")
        case _ => println("no match")
      }
    } }    
  }
}

注意：

1. 樣例類默認實現了toString,equals，copy和hashCode等方法。
2. 樣例類可以new, 也可以不用new。

8、Actor

類似於JAVA中的Thread。

// Actor與Actor之間的通信
case class Message(actor:Actor,msg:Any)

class Actor1 extends Actor{
  def act(){
    while(true){
      receive{
        case  msg :Message => {
          println("i sava msg! = "+ msg.msg)
          
          msg.actor!"i love you too !"
		 }
        case msg :String => println(msg)
        case  _ => println("default msg!")
      }
    }
  }
}

class Actor2(actor :Actor) extends Actor{
  actor ! Message(this,"i love you !")
	def act(){
		while(true){
			receive{
  			case msg :String => {
  			  if(msg.equals("i love you too !")){
  			    println(msg)
  			   actor! "could we have a date !"
  			  }
  			}
  			case  _ => println("default msg!")
			}
		}
	}
}

object Lesson_Actor2 {
  def main(args: Array[String]): Unit = {
    val actor1 = new Actor1()
    actor1.start()
    val actor2 = new Actor2(actor1)
    actor2.start()
  }
}

Actor的特徵：

1. ActorModel是消息傳遞模型,基本特徵就是消息傳遞
2. 消息發送是異步的，非阻塞的
3. 消息一旦發送成功，不能修改
4. Actor之間傳遞時，自己決定決定去檢查消息，而不是一直等待，是異步非阻塞的