1、面向对象编程和函数式编程

对比

2、函数定义格式

def 函数名 ([参数名: 参数类型], ...)[[: 返回值类型] =] {
语句... //完成某个功能
return 返回值
}

def test(s:String) : String ={
      return "abc"
    }

3、函数的各种简化和变形

1）省略return (方法体内最后一行为返回的值)

  def test1(s:String) : String ={
      "abc"
    }
    println(test1("a")) // abc

2) 省略返回值类型（scala会自动判断最后一行值的类型）

  def test2(s:String)  ={
      "abc"
    }
  println(test2("a")) // abc

3) 省略入参

  def test3()  ={
      "abc"
    }
  println(test3()) // abc

4)省略大括号（）当方法体内只有一行代码时，可以省略{ }

    def test4()  ="abc"
    println(test4()) // abc

5)省略小括号 当方法没有入参时，可以省略（）

    def test5  = "abc"
    println(test5) // abc  若方法省了小括号，在调用时也可以省略小括号

def test5 = "abc"
val ssss = "abc"
方法和变量只有关键字不一样

6)补充

方法省略等号，返回值为Unit

    def test6(){
      "abc"
    }
    println(test6()) // ()

方法体没有返回值是Unit,
只要定义的返回值时Unit,不管方法体最后一行是什么都会返回Unit

//方法体没有返回值是Unit,
    // 要定义的返回值时Unit,不管方法体最后一行是什么都会返回Unit类型
    def test1(s:String) : Unit ={

    }
    def test2(s:String) : Unit ={
      "abc"
    }
    println(test1("a")) // ()
    println(test2("a")) // ()

7）可变参

  def test7(s:String*)={ 
     for(i<- s){
        println(i)
      }
    }

    test7("张三","里斯") //张三
                        //里斯

4、Scala是完全面向函数的语言

注意：

函数的类型：() => Int、Int => Int 、(Int) = >Int等

1）函数可以赋值给变量

2）函数可以作为函数的参数

   def f5(f6 : () => Int): Int ={
      f6()+10
    }

    def f(): Int ={
      5
    }

    println(f5(f)) //15

简化(匿名函数)

    def f5(f6 : () => Int): Int ={
      f6()+10
    }

    println(f5(()=>{5})) //15

    val a = ()=>{"a"}
    println(a) // <function0>
    println(a()) // a

匿名函数加强（匿名函数传递的是一段逻辑）

    def f7(f : (Int) => Unit) : Unit = {
      f(10)
    }

    f7((i) => {println(i)}) //10
    f7((i) => println(i)) //10
    f7(i => println(i)) //10
    f7(println(_)) //10

   def f8(f:(Int,Int) => Int): Int = {
      f(10,10)
    }

    println(f8((x:Int,y:Int) => {x+y})) // 20
    println(f8((x,y) => { x+y })) // 20
    println(f8((x,y) => x+y)) // 20
    println(f8(_+_)) // 20

3）函数可以作为函数的返回值

  def f()={
      "scala"
    }

    def f1() ={
      f  //当方法没有入参时，调用时可以省略小括号
    }

    println(f1()) // scala
    println(f1()()) // 直接提示错误

    def f()={
      "scala"
    }

    def f1() ={
      f _  // 有 _ 返回才是函数，而不是值
    }

    println(f1()) // <function0>
    println(f1()()) // scala

解释：一般情况下，f标识传递引用，f()表示实际调用

f _ :中的 _ 如果不写返回值并不是一个函数，而是f函数的返回值。在函数f1中，函数f也会执行(因为无参函数调用，可以省略小括号)。

简化

    def f1():() => String ={
      def f() : String ={
        "scala"
      }
      f _  //scala中函数哪里都写可以，这种只是相当于把f函数写道f1里面
    }

    print(f1()())

解释：

()=>String 代表返回的是一个函数，没有入参，返回值是String的函数

再变型

   def f2(i :Int) : Int => Int ={
      def f3(j:Int): Int ={
        i*j
      }
      f3 _
    }

    println(f2(3)(4)) //12

注意：正常再触发f3函数时，f2已经弹栈，入参i不能再f3中拿到运用，这里有个闭包的概念。把i 的生命周期改变，就像再把i和j打成一个包，放到f3里面

关于闭包的类比：
类似java堆栈，通常认知，方法进栈，对象进堆
1、栈上分配
public void test(){
User user = new User
//如果创建千万对象，弹栈后，方法之外的地方也没有用到这些对象，则这些对象随着方法弹栈，不进入堆中
}
2、逃逸分析
public User test(){
User user = new User
return user
// 方法返回了对象，这时不在随方法弹栈，逃逸进入堆中
}

柯里化（上面的简化）

  def f2(i:Int)(j:Int) : Int = {
      i*j
    }

    println(f2(3)(4))

5、其他知识点

惰性函数

    def sum(i:Int,j:Int): Int ={
      println("sum函数执行了")
      i+j
    }

    val res = sum(10,20)
    println("----------x----------")
    println("----------x----------")
    println("----------x----------")
    println(res)

结果:sum函数执行了
----------x----------
----------x----------
----------x----------
30

    lazy val res = sum(10,20)
    println("*******x********")
    println("*******x********")
    println("*******x********")
    println(res)

结果：
*******x********
*******x********
*******x********
sum函数执行了
30

惰性函数加载时才执行
lazy不能修饰var变量
lazy修饰函数和变量，都会导致延迟加载

6、scala基础语法-函数式编程