scala的模式匹配

package cn.tedu.scala.day03import scala.util.Random/*** 模式匹配*/
object MatchTest {def main(args: Array[String]): Unit = {val array: Array[Any] = Array("1",2,5.5,true)val index: Int = new Random().nextInt(array.length)val value = array(index)println(value)//模式匹配value match {case "1" =>println("调用了第二个方法")case 2=>println("调用了第二个方法")case _=>println("调用了第三第四个方法")}}
}package cn.tedu.scala.day03import scala.util.Random/*** 模式匹配*/
object MatchTest02 {def main(args: Array[String]): Unit = {val array: Array[Any] = Array("1",2,5.5,7.7,true)val index: Int = new Random().nextInt(array.length)val value = array(index)println(value)value match {case x:String=>println("调用了String的方法")case x:Int=>println("调用用了Int的方法")case x:Double if x>6 =>println(x,"调用用了Double的方法")case x:Boolean=>println("调用用了Boolean方法")case _=>println("Any else")}}
}package cn.tedu.scala.day03object MatchTest03 {def main(args: Array[String]): Unit = {val  list=List(3,1,5)list match {//case 3::1::5::Nil=>println("猜中了")case 3::3::Nil=>println("猜错了")case x::y::z::Nil=>println(s"x:$x,y:$y,z:$z")case x::tail=>println(tail)case _=>println("不猜了")}}
}

样例类 样例对象

/***  样例类重写了Apply方法和toString方法equals和copy*/
case class CaseClassTest(val id:Int) {}
//case object 样例对象单利模式
object CaseClassTest{def main(args: Array[String]): Unit = {val test1: CaseClassTest = new CaseClassTest(11)val test2 = CaseClassTest(11)println(test2.id)}
}

偏函数

package cn.tedu.scala/*** 偏函数*/
object PartialFunctionTest {def main(args: Array[String]): Unit = {val result:String=ff(1)println(result)}//偏函数val ff:PartialFunction[Int,String]={case 1=>"aa"case _=>"bb"}
}

高阶函数

package cn.tedu.scala.day04/*** 函数和方法可以当做是函数和方法的参数*/
object Method_Function {def main(args: Array[String]): Unit = {println(m2(1,2))println(f1(1))//参数传入函数println(mm1(5,6,f))//参数传入方法如果这个参数是函数但是传入的是方法那么这个方法会被转换为函数println(mm1(5,6,m2 _))println("------------------")println(mm2(5,6,m2 _))}//方法def m2(x:Int,y:Int):Int=x+y//函数val  f1:Int=>Double=(value:Int)=>value.toDoubleval  f=(x:Int,y:Int)=>x+yval f2=m2 _def mm1(x:Int,y:Int,ff:(Int,Int)=>Int)=ff(x,y)val mm2=(x:Int,y:Int,ff:(Int,Int)=>Int)=>ff(x,y)
}package cn.tedu.scala.day04/*** 函数和方法可以当做是函数和方法的返回值*/
object Method2_Function {def main(args: Array[String]): Unit = {//方法转为函数val f2=m1 _//函数转为方法def m2=f1println(f2(5,6))println(m2(5,6))println("------------------")//f3是一个方法def  f3=m3(4)println(f3)val result1=f3(5)println(result1)val result2=m3(4)(5)println(result2)}//方法def m1(x:Int,y:Int):Int=x+y//函数val  f1=(x:Int,y:Int)=>x+ydef m3(x:Int)=(y:Int)=>x+y
}

• 柯里化一般来说隐式参数和柯里化是同时使用的

  • 柯里化的两个好处把接收多个参数的，变成接收较少参数的一个函数

  • 由于函数或者方法有默认值如果使用implicit定义的话这个参数会更强大

      def m1(x:Int,y:Int):Int=x+y //m1(2,3) def m1(x:Int,y:Int=10):Int=x+y //m1(2,3) m1(2)def m1(x:Int)(y:Int):Int=x+y//m1(2)(3) m1(2) _def m1(x:Int)(y:Int=10):Int=x+y//m1(2)(3)def m1(x:Int)(implicit y:Int=10):Int=x+y//m1(2) m1(2)(3)			implicit val abc:Int=100def m1(x:Int)(implicit y:Int=10):Int=x+y//m1(2)=102
    

• 闭包

    package cn.tedu.scala/*** 如何实现闭包？* 就是在这个bibao 函数的内部，在定义一个函数add_sum去访问这个sum函数* 闭包的作用：如果正常情况下想要访问一个函数内部的变量值，是不能访问的* 定义了闭之后在函数的内部定义（一个新的函数那么这个函数则和定义的函数是平行关系所以可以访问）* 闭包之后由于外部函数result是平行关系则泽科访问* 但是又不推荐使用，由于sum和add_sum是绑定的，最终add_sum和sum会一直驻留在内存中，最终由很多内存就一直* 被占用着**/object CloserTest {def main(args: Array[String]): Unit = {val result = bibaoresult(2)result(2)result(2)result(2)val result1=bibaoresult(3)//11 函数都是单利的}val bibao = {var sum = 0var add_sum = (x: Int) => {sum += xprintln(sum)}add_sum}}
  

隐式转换

• 如果一个参数的形参被声明为implicit，那么表示当前这个参数会从环境中寻找对应的类型进行隐式值进行替换

• 如果在运行环境中定义了多个隐式变量这会在运行时报错。

• 如果不是在运行环境中定义的隐式变量不在运行环境中，则需要用import导入，变量或方法只能写在object中

    def aa(x:Int)(implicit y:Int=10)=x+y//调用 aa(3)(4)=7//调用 aa(3)=13//implicit val abc=100//调用 aa(3)=103	
  

• 工作机制和java中的封箱拆箱的工作机制一样都是自动帮你完成的。

• 隐式转换什么时候会发生？

  • 当参数类型不匹配是隐式转换会触发尽量寻找一个需要转换的类型。

      package cn.tedu.scala.day04/*** 隐式转换当参数类型不匹配是隐式转换会触发尽量寻找一个需要转换的类型。*/object ImplicitParamTest02 {def main(args: Array[String]): Unit = {def aa(x:Int,y:Int)=x+yprintln(aa(3,5))implicit  def doubleToInt(d:Double)=d.toIntprintln(aa(2,3.0))}}
    

  • 当调用某个对象的方法不存在是可能会被隐式转换为该类型 比如 to 方法

  • 当泛型中需要视图边界的时候

scala的泛型

package cn.tedu.scala.day04
class Student55(id:Int,name:String)
object GenericTypeTest01 {def main(args: Array[String]): Unit = {val studnet55: MyRight[Student55] = new MyRight[Student55]val stu1: Student55 = new Student55(1,"aa")val stu2: Student55 = new Student55(2,"bb")studnet55(stu1)studnet55(stu2)studnet55.choose(stu1,stu2)val lift: MyLift = new MyLiftlift.choose[Student55](stu1,stu2)lift.choose[String]("huangbo","xuzheng")}
}
//泛型类
class MyRight[T]{def choose(one:T,two:T): T ={return one}
}
//泛型方法
class MyLift{def choose[T](one:T,two:T): T ={return one}
}

• scala泛型隐式转换

    package cn.tedu.scala.day04case class Student66[T,S<% Comparable[S]](var name: T, var height: S)object GenericTypeTest02 {/*** T是泛型，T不确定是什么类型，所以不能确定是否包含compareTo方法所以会报编译错误* T <:Comparable[T] 表示传入进来的泛型必须是继承或实现Comparable的类型* T表示是继承树中的任何一个* T <%Comparable[T]除了他的子类外还认识他的隐式转换的类*/def main(args: Array[String]): Unit = {val huangfbo = Student66("huangbo", "170")val xuzheng = Student66("xuzheng", 170)}}
  

• 上下边界

    package cn.tedu.scala.day04/*** 上下边界*/object ShangXiaJie {def main(args: Array[String]): Unit = {test[B](new B())test1[F](new F())}def test[T>:C](one:T): Unit ={println("下界是C")}def test1[T<:C](one:T): Unit ={println("上界是C")}}class Aclass B extends Aclass C extends Bclass D extends Cclass E extends Dclass F extends E
  

本文链接：https://my.lmcjl.com/post/4907.html