Scala六大特性及常用知识点总结（一）

百度百科中对Scala这门语言的简介是这个样子：“Scala是一门多范式的编程语言，一种类似java的编程语言 ，设计初衷是实现可伸缩的语言 、并集成面向对象编程和函数式编程的各种特性。”
作为一门基于JVM的编程语言，Scala和Java在很多方面有相似之处。

Scala官网总结了它的六大特性，翻译成中文它们分别对应着以下六点：

1).Java和Scala可以混编：
Scala基于JVM平台运行，因此它和Java可以自由的混合使用，这也就是在日常书写代码的过程中，经常看到Scala引了许多Java包的原因；
2).类型推测(自动推测类型)：
Scala有Int、Long、Short、Byte、Float、Double、Char、Boolean这些基础数据类型，但与Java不同，在声明变量时，Scala用 var/val 来声明，让其自主判断数据类型。 PS：val——常量，var——变量；一般来说，用val比较多（涉及资源的利用）
3).并发和分布式（Actor）
编码中超级让人蛋疼的事情就是各种各样的锁，而Actor是一种不共享数据，依赖于消息传递的并发编程模式， 有效的避免了死锁、资源争夺等情况。 4).trait———特质，特征(类似java中interfaces 和 abstract结合)
Scala Trait(特征) 相当于 Java 的接口，但实际上它比接口还功能强大。 与接口不同的是，它还可以定义属性和方法的实现。
5).模式匹配（类似java switch） 对Pattern Matching 概念模糊的小伙伴可以搜索一下switch这个关键字。
6).高阶函数 个人感觉，高阶函数可谓Scala的精华所在，大体上可将函数分为九大部分：
A. 常用函数（方法）的定义：

B.递归函数：

 /**
     * 递归方法 
     * 5的阶乘
     */
    def fun2(num :Int) :Int= {
      if(num ==1)
        num
      else 
        num * fun2(num-1)
    }
    print(fun2(5))
  

C.含默认值的方法：
默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值；
如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称。

 def fun3(a :Int = 10,b:Int) = {
      println(a+b)
    }
    fun3(b=2)

D.可变参数的方法：

    /**
     * 可变参数个数的函数
     * 注意：多个参数逗号分开
     */
    def fun4(elements :Int*)={
      var sum = 0;
      for(elem <- elements){
        sum += elem
      }
      sum
    }
    println(fun4(1,2,3,4))

E.匿名函数：

    /**
     * 匿名函数
     * 1.有参数匿名函数
     * 2.无参数匿名函数
     * 3.有返回值的匿名函数
     * 注意：
     * 可以将匿名函数返回给定义的一个变量
     */
    //有参数匿名函数
    val value1 = (a : Int) => {
      println(a)
    }
    value1(1)
    //无参数匿名函数
    val value2 = ()=>{
      println("This is test001")
    }
    value2()
    //有返回值的匿名函数
     val value3 = (a:Int,b:Int) =>{
      a+b
    }
    println(value3(4,4)) 

F.嵌套函数：

    /**
     * 嵌套方法
     * 例如：嵌套方法求5的阶乘
     */
    def fun5(num:Int)={
      def fun6(a:Int,b:Int):Int={
        if(a == 1){
          b
        }else{
          fun6(a-1,a*b)
        }
      }
      fun6(num,1)
    }
    println(fun5(5))

G.偏应用函数：
偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。也就是传说中为了“偷懒”而促成的衍生品。

    /**
     * 偏应用函数
     */
    def log(date :Date, s :String)= {
      println("date is "+ date +",log is "+ s)
    }
    
    val date = new Date()
    log(date ,"a")
    log(date ,"b")
    log(date ,"c")
    
    //想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
    val logWithDate = log(date,_:String)
    logWithDate("log1")
    logWithDate("log2")
    logWithDate("log3")

H.高阶函数：
高阶函数这里泛指函数的参数是函数，函数的返回类型是函数，或者函数的参数和函数的返回类型是函数的函数。

    //函数的参数是函数
    def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
      f(a,100)
    }
    def f(v1 :Int,v2: Int):Int  = {
      v1+v2
    }
    
    println(hightFun(f, 1))
    
    //函数的返回是函数
    //1，2,3,4相加
    def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
      def f2 (v1: Int,v2:Int) :Int = {
        v1+v2+a+b
      }
      f2
    }
    println(hightFun2(1,2)(3,4))
    
    //函数的参数是函数，函数的返回是函数
    def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
      f
    } 
    println(hightFun3(f)(100,200))
    println(hightFun3((a,b) =>{a+b})(200,200))
    //以上这句话还可以写成这样
    //如果函数的参数在方法体中只使用了一次 那么可以写成_表示
    println(hightFun3(_+_)(200,200))

I.柯里化函数:

   /**
     * 柯里化函数
     */
    def fun7(a :Int,b:Int)(c:Int,d:Int) = {
      a+b+c+d
    }
    println(fun7(1,2)(3,4))

我们姑且将柯里化函数视作高阶函数的简化，在此暂不对此作详细分析