Java Scala之模式匹配与隐式转换的方法是什么

模式匹配：

Scala中的模式匹配相当于Java中的switch

在Java中我们有switch  case default 这三个组成的基础语法，在Scala中我们是有match  和 case组成  default的作用由case代替

基础语法如下：

val a=10
    val b=20
    var c='+'
    c match {
      case '+'=> println(a+b)
      case '-'=> println(a-b)
      case _  =>println("错误的运算符")
    }

在Scala中是默认从这个case执行到下一个case的  

case _  是代表上述情况都不满足

模式守卫：

如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫

（其实是在case中添加if判断）

 val x=3.153
    val value: Any = x match {
      case i: Double if i >= 0 => i
      case j: Double if j < 0 => -j
      case _ => "type illegal"
    }

类型匹配：

在定义函数时 参数为所有对象的父类Any

 def function(x:Any): Unit ={
      x match {
        case s:String =>println("字符串")
        case i:Int=>println("整数")
        case d:Double=>println("小数")
        case _ =>println("其他")
      }
    }

对象匹配

对象的匹配是比较复杂的，单纯的比较是比较的地址值，两个变量的地址值是肯定不同的

object Test_03MatchObject {
  def main(args: Array[String]): Unit = {
    val sss: person1 = person1("sss", 1)
  sss match {
    case person1("sss",1)=>println("victory")
    case _=>println("defite")
  }
  }
  class person1(val name: String,val age :Int){
  }
  object person1{
    def apply(name: String, age: Int): person1 = new person1(name, age)
    def unapply(arg: person1): Option[(String, Int)] =
      if (arg==null)
      {
        None
      }
      else{
        Some(arg.name,arg.age)
      }  }
}

这里我们在object中定义了unapply方法   unapply方法相当于apply方法的逆应用，apply方法是在object中创建对象，而unapply方法是提取方法，提取操作的对象（传入的参数为对象，根据对象进行提取数据存入Some，与自己的传入的数据进行比较）这个方法也是和apply方法一样不用写方法名。

该方法主要用于解析对象（匹配对象）

样例类：

样例类中的主属性默认为val如果需要使用var则需要自己标注

样例类会自动生成unapply与apply等方法   节省了大量代码

把上述的class与object注释后新建样例类：（大量使用）

  case class person1(val name: String,val age :Int)

偏函数：

偏函数的化简写法：

我们可以直接调用collect函数进行调用偏函数参数直接写case+你需要的操作

化简写法相当于省掉了match,作用相当于 filter+map

在使用map的场景下也能使用偏函数

偏函数的使用：

    val list = List(List(1, 2, 3, 4), List(1), List(8, 5))
    val list1: List[Int] = list.collect({ case List(x, y, _*) => y })
  println(list1)

隐式转换：

官方定义：

当编译器第一次编译失败的时候，会在当前的环境中查找能让代码编译通过的方法，用

于将类型进行转换，实现二次编译

个人理解：

隐式转换是我们在对一个对象调用它所在的类中没有的函数时发生错误所进行的操作

隐式函数：

隐式转换的步骤：

（1）需要现在下边定义一个目标类  在类中定义所调用的方法与逻辑

eg:我们对Int类型数据调用一个不存在的方法：

class MyRichInt(val self :Int)
  {
def myMax(int: Int):Int =
    {
      if (int>self)
        int
        else
        self
    }
  }

（2）在main函数中定义转换器

在开头要引入 ----   implicit 隐式转换的函数再进行定义

 implicit def changeInt(self:Int)  =
    {
new MyRichInt(self)
    }

当隐式转换的的方法相同与自身方法冲突，会使用自身的方法（因为不会编译失败---隐式转换的官方定义）

隐式参数：

在定义函数时我们已经知道了参数默认值  但是调用的时候我们需要加上括号

在这里我们引入了新概念   隐式参数

参数对比样例：

   implicit val name:String="lisi"
    def sayhi(implicit name: String="sd"): Unit =
    {
      println(s"hi $name")
    }
   sayhi
   sayhi()

参数默认值只是在调用函数的后边加一个括号

运行结果：

隐式类：

在普通类的前面添加关键字implicit会自动转换成隐式类

如果隐式转换的目标类转换成隐式类 则不需要在main函数中new隐式类的

可以直接调用指定函数