scala的Trait和样例类

scala的Trait和CaseClass

Trait

注意：

• 1 case _ 表示什么都匹配不上，放在诸多匹配的最后
• 2 match 既可以匹配值还可以匹配类型
• 3 匹配过程中会有数值的转换
• 4 自上向下匹配，匹配上后向下匹配
• 5 模式匹配外部的{}可以省略

/**
  * 模式匹配
  */
object Match {
  def main(args: Array[String]): Unit = {
    val tp = (1,1.0,"abc",'D',true)
    val iterator: Iterator[Any] = tp.productIterator
    iterator.foreach(MatchTest)
  }

 def MatchTest(o:Any)= {
   o match {
     case 1=> println("value is 1")
     case i:Int=> println(s"类型是Int，$i")
     case d:Double=> println(s"类型是Double $d")
     case _=> println("没有匹配上数据")
   }
 }

CaseClass样例类

样例类是包括了一些基本方法的类

注意：

• 使用了case关键字定义的类，是特殊的类
• 实现了构造参数的getter方法，默认是val，可以在参数设置为var
• 样例类实现了toString equals copy hashCode等方法
• 可以new,也可以不new
• 如果样例类中无其他逻辑，可以将{}去掉

/**
  * 样例类
  */
 case class Person1(var name:String,age:Int){

}

object CaseClass {
  def main(args: Array[String]): Unit = {
    val p1 = new Person1("zhangsan",age = 18)
    val p2 = new Person1("zhangsan",age = 18)
    println(p1.equals((p2)))

隐式转换

​ 隐式值和隐式参数

​ 在调用时不给定值/参数，就会用定义好的值，只是值时隐式的

​ 隐式转换函数

​ new出的对象通过隐式类型的装换，得到其他类中的方法

​ 隐式类

​ 通过a类得到b类信息

/**
  *隐式值和隐式参数
  */
object Demo11_Implicit1 {
  //隐式参数  如果有多个值想要隐式参数就采用柯里化方式，将隐式参数写后面
  def sayName(age:Int)(implicit name:String)={
    println(s"$name is a student")
  }
  def main(args: Array[String]): Unit = {
    //隐式值
    implicit val name:String = "zhangsan"
    sayName(18)

**
  * 隐式转换函数
  * 一种作用域内只能定义一种（参数，进出类型）相同类型的，只能存在一个
  */
class Animal(name:String){
  def canFly()={
    println(s"$name can fly")
  }
}
class Rabbit(xname:String){
  val name = xname
}

object Demo11_Implicit2 {
  implicit def RebbitToAnimal(r:Rabbit)={
    new Animal(r.name)
  }

  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit("rabbit")
    //本身new的Rabbit类没有canFly方法，找进来Rubbit类出去是Animal类的隐式方法
    rabbit.canFly()

/**
  * 隐式类
  * 不能在外部直接定义隐式类
  */
class Rabbit1(xname:String){
  val name = xname
}
object Demo11_Implicit3 {

  implicit  class Animal1(r:Rabbit1){
    def showName()={
      println(s"${r.name} is Rabbit...")
    }
  }

  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit1("RABBIT")
    rabbit.showName()
  }

Actor通信模型

相当于 Java 中的线程，解决了多线程锁的机制，消息队列，异步非阻塞，

特征：

​ 消息传递模型，基本 特征极是消息传递

​ 消息发送是异步的，非阻塞

​ 消息一旦发送成功，不能修改

​ Actor间传递锁，自己检查消息队列，非阻塞

/**
  * 给Actor发送消息
  */
class MyActor extends Actor{
  override def act(): Unit = {
    receive{
      case s:String => println(s"$s is String")
      case _=>println("NONE")
    }
  }
}
object Actor1 {
  def main(args: Array[String]): Unit = {
    val actor = new MyActor
    actor.start()

    actor ! "hi"
  }

import scala.actors.Actor
/**
  * Actor1之间通信
  */
case class Msg(actor: Actor,message:String)

class MyActor1 extends Actor{
  override def act(): Unit = {
    while (true){
    receive{
      case msg:Msg=>{
        if ("hello~".equals(msg.message)){
          println(msg.message)
          msg.actor ! "hi~"
        }else if("Could you ?".equals(msg.message)){
          println(msg.message)
          msg.actor !"no..."
        }
      }
      case _=>println("no match")
    }
  }
}
}
class MyActor2(actor: Actor) extends Actor{
  actor ! Msg(this,"hello~")
  override def act(): Unit = {
    while (true){
    receive{
      case s:String =>{
        if ("hi~".equals(s)){
          println(s)
          actor ! Msg(this,"Could you ?")
        }else if ("no...".equals(s)){
          println(s)
          println("...")
        }
      }
      case _=> println("no match")
    }
  }