初识scala（四）

1.模式匹配

匹配内容

    val a=Array("A","B","C")
    val name= a(Random.nextInt(a.length))
//    println(name)

    name match {
      case "A" =>println("a")
      case "B" =>println("b")
      case _ => println("other")
          }

匹配类型

    def matchType(obj:Any) =obj match {
      case x:Int =>println("Int")
      case s:String =>println("String")
      case m:Map[_,_] =>println("Map")
      case _ =>println("other")
    }

    matchType(1)
    matchType("asdf")
    matchType(Map("asdf"-> 12))
    matchType(1D)

集合匹配

    def matchList(list: List[String]): Unit ={
      list match {
        case "ruoze":: Nil => println("ruoze") //只能匹配”ruoze“一个元素
        case x::y:: Nil => println(s"$x,$y")//能匹配集合中两个元素
        case "ruoze":: tail => println("ruoze.....")//匹配ruoze开头的
        case _ => println("123")
      }
    }
    matchList(List("ruoze"))
    matchList(List("x","y"))
    matchList(List("x","y","z"))
    matchList(List("ruoze","123"))

匹配case

  /**
    * case class   必须要有参数列表
    * case object  不能加参数列表
    *
    * case 跟class区别
    * case class重写了toString ,equals hashCode方法
    * case class默认实现了序列化
    * case class不用new
    *
    * Trait 类似于理解java的Interface
    *
    */

    val casecalss= Array(SubmitTask("1","task"),HeartBeat(10000),OutofTime)

    casecalss(Random.nextInt(casecalss.length)) match{
      case SubmitTask(id,name) => println("SubmitTask")
      case HeartBeat(time) => println("HeartBeat")
      case OutofTime => println("OutofTime")
    }
    try{
      1/0
    }catch {
//      case e:Exception =>println(e.getMessage)
//      case e:Exception =>println(e.getStackTrace)
      case e:ArithmeticException =>println("除数不能为0")
      case e:Exception =>e.printStackTrace()
    }finally {
      //最后资源的释放，一定会执行
      //close
    }
    case class SubmitTask(id:String,name:String)
    case class HeartBeat(time:Long)
    case object OutofTime

2.偏函数

/**
    * 偏函数 PartialFunction
    *包在花括号内没有match的一组case语句
    * A: 输入参数类型
    * B：输出参数类型
    */


  def main(args: Array[String]): Unit = {
    val a=Array("A","B","C")
    val name= a(Random.nextInt(a.length))


    println(say(name))
  }
   def say:PartialFunction[String,String]={
     case "A" => "a"
     case "B" => "b"
     case _ =>  "other"
   }

3.隐式转换

从class Man的定义中可以看出，定义里并没有fly方法，这个时候编译器就会开始找是否有对应的隐式转换可用，根据参数找到implicit def man2superman(man: Man)这个函数，再在里面调用Superman类里面的fly方法。
隐式类型

implicit def man2superman(man: Man): Superman = new Superman(man.name)
      val man = new Man("jepson")
      man.fly()

class Man(val name:String){
}

class Superman(val name:String){
  def fly(): Unit ={
    println(s"$name flying")
  }
}

隐式参数

def sayhello(name:String)=println(s"$name")
    //隐式参数 方法/函数的参数可以使用implicit
    def sayhello2(implicit name:String ="若泽")=println(s"$name")
//    sayhello("ruoze")
    //多个隐式转换只需要写一个
    def add1(x:Int)(implicit y:Int,z:Int)=x+y+z
    
    implicit val ad:Int=5
    println(add(3))

隐式类

    implicit class Cal(x:Int){
      def add(a:Int)=a+x
    }