scala-函数式编程

一、scala是函数式编程和面向对象的结合

先学习基础，到面向对象，再到高级部分

二、概念

方法：

函数：和方法一样，只是函数运用更加灵活；函数是一等公民，像变量一样可以作为参数使用，也可将函数赋值给一个变量，重要的是函数的创建不依赖类或者对象。

函数式编程：是一种编程范式，思想就是将过程作为一个整体，可以被调用；最重要为函数；函数可以是一种数据类型，作为输入输出；

三、函数

def 函数名 ([参数名: 参数类型], ...)[[: 返回值类型] =] {
语句...
return 返回值
}

1) 函数声明关键字为 def (definition)
2) [参数名: 参数类型], ...：表示函数的输入(就是参数列表), 可以没有。 如果有，多个参数使用逗
号间隔
3) 函数中的语句：表示为了实现某一功能代码块
4) 函数可以有返回值,也可以没有
返回值形式 1: : 返回值类型 = 
返回值形式 2: = 表示返回值类型不确定，使用类型推导完成
返回值形式 3: 表示没有返回值，return 不生效
5) 如果没有 return ,默认以执行到最后一行的结果作为返回值

注意：

1) 函数的形参列表可以是多个, 如果函数没有形参，调用时 可以不带()

2) 形参列表和返回值列表的数据类型可以是值类型和引用类型

object Details01 {

  def main(args: Array[String]): Unit = {
    val dog = new Dog
    val dog1 = test01(2, dog)
    println("dog1.name:"+dog1.name)
    println("dog.name:"+dog.name)
    println(dog.hashCode() + " " + dog1.hashCode())
  }

  def test01(n1:Int,dog: Dog): Dog ={
    println("N1:"+n1)
    dog.name = "jack"
    dog
  }

}

class Dog{
  var name =""
}

3) Scala 中的函数可以根据函数体最后一行代码自行推断函数返回值类型。那么在这种情况下， return 关键字可以省略

def getSum(n1: Int, n2: Int): Int = {
 n1 + n2
}

4) 因为 Scala 可以自行推断，所以在省略 return 关键字的场合，返回值类型也可以省略

def getSum(n1: Int, n2: Int) = { 
 n1 + n2
}

5) 如果函数明确使用 return 关键字，那么函数返回就不能使用自行推断了,这时要明确写成 : 返 回类型 = ，当然如果你什么都不写，即使有 return 返回值为()

6) 如果函数明确声明无返回值（声明 Unit），那么函数体中即使使用 return 关键字也不会有返回值

7) 如果明确函数无返回值或不确定返回值类型，那么返回值类型可以省略(或声明为 Any)

8) Scala 语法中任何的语法结构都可以嵌套其他语法结构(灵活)，即：函数中可以再声明/定义函数， 类中可以再声明类 ，方法中可以再声明/定义方法

9) Scala 函数的形参，在声明参数时，直接赋初始值(默认值)，这时调用函数时，如果没有指定实参，则会使用默认值。如果指定了实参，则实参会覆盖默认值。

object Details04 {
  def main(args: Array[String]): Unit = {
    println(sayOk("mary"))
  }

  def sayOk(name : String = "rose"): String = {
    return name + " ok! "
  }
}

10) 如果函数存在多个参数，每一个参数都可以设定默认值，那么这个时候，传递的参数到底是覆 盖默认值，还是赋值给没有默认值的参数，就不确定了(默认按照声明顺序[从左到右])。在这种情况下， 可以采用带名参数

11) 递归函数未执行之前是无法推断出来结果类型，在使用时必须有明确的返回值类型

12) Scala 函数支持可变参数； 注： args 是集合, 通过 for 循环 可以访问到各个值；可变参数需要写在形参列表的最后

def sum(n1: Int, args: Int*) : Int = { 
}

理解为：1 到多个参数
如：sum(10, 30, 10, 3, 45, 7))
n1=10,args={30, 10, 3, 45, 7}

四、过程

返回值为Unit的函数称为过程，等号可以省略，因为有等号会自动推断返回值类型，为了简洁，建议不写等号

五、惰性函数

需要用到才会计算

object LazyDemo01 {
  def main(args: Array[String]): Unit = {
    lazy val res = sum(10, 20)
    println("-----------------")
    println("res=" + res) 
  }
  
  def sum(n1: Int, n2: Int): Int = {
    println("sum() 执行了..") 
    n1 + n2
  }
}

结果：
-----------------
sum() 执行了..
res=30

注：lazy 不能修饰 var 类型的变量

六、异常

Scala 提供 try 和 catch 块来处理异常。try 块用于包含可能出错的代码。catch 块用于处理 try 块中发 生的异常。可以根据需要在程序中有任意数量的 try...catch 块

1. 在 scala 中只有一个 catch

2. 在 catch 中有多个 case, 每个 case 可以匹配一种异常 case ex: ArithmeticException

3. => 关键符号，表示后面是对该异常的处理代码块

4. finally 最终要执行的

case ex: ArithmeticException=> {
println("为零的算数异常")
}

Scala 异常处理小结：

1) 我们将可疑代码封装在 try 块中。 在 try 块之后使用了一个 catch 处理程序来捕获异常。如果发 生任何异常，catch 处理程序将处理它，程序将不会异常终止。

2) Scala 的异常的工作机制和 Java 一样，但是 Scala 没有“checked(编译期)”异常，即 Scala 没有 编译异常这个概念，异常都是在运行的时候捕获处理。

3) 用 throw 关键字，抛出一个异常对象。所有异常都是 Throwable 的子类型。throw 表达式是有类 型的，就是 Nothing，因为 Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方

def test(): Nothing = {
 throw new ArithmeticException("算术异常")//Exception("异常 NO1 出现~")
 }

 4) 在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的代码里，是一系列 case子句来匹配异常。【前面案例可以看出这个特点, 模式匹配我们后面详解】，当匹配上后 => 有多条语句可以换行写，类似 java 的 switch case x: 代码块..

5) 异常捕捉的机制与其他语言中一样，如果有异常发生， catch 子句是按次序捕捉的。因此，在 catch子句中，越具体的异常越要靠前，越普遍的异常越靠后 ，如果把越普遍的异常写在前，把具体的异常 写在后，在 scala 中也不会报错，但这样是非常不好的编程风格。

6) finally 子句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清 理工作，这点和 Java 一样。

7) Scala 提供了 throws 关键字来声明异常。可以使用方法定义声明异常。 它向调用者函数提供了 此方法可能引发此异常的信息。 它有助于调用函数处理并将该代码包含在 try-catch 块中，以避免程序 异常终止。在 scala 中，可以使用 throws 注释来声明异常  

@throws(classOf[NumberFormatException])//等同于 NumberFormatException.class
 def f11() = {
 "abc".toInt
 }