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())
  }
}

总结：

构造函数和JAVA不一样，直接类名后加参数
伴生类中主要声明动态属性，伴生对象主要声明静态属性。

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)    
  }
}

注意：

继承的多个trait中如果有同名的方法和属性，必须要在类中使用“override”重新定义。
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")
    }
  }  
}

注意：

模式匹配不仅可以匹配值，还可以匹配类型
模式匹配中，如果匹配到对应的类型或值，就不再继续往下匹配
模式匹配中，都匹配不上时，会匹配到 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")
      }
    } }    
  }
}

注意：

样例类默认实现了toString,equals，copy和hashCode等方法。
样例类可以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的特征：