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

面向对象编程：

• 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
• 对象：用户
• 行为：登录、连接JDBC、读取数据库
• 属性：用户名、密码
• Scala语言是一个完全面向对象编程语言。万物皆对象
• 对象的本质：对数据和行为的一个封装。

函数式编程：

• 面向过程编程: 分析解决问题所需要的步骤, 然后用函数把这些步骤一一实现;

二、函数基本语法

基本语法：

三、函数和方法的区别

• 为完成某一功能的程序语句的集合，称为函数
• 类中的函数称为方法
• Scala语言可以在任何的语法结构中声明任何的语法
• 函数没有重载和重写的概念。方法可以进行重载和重写
• Scala中函数可以嵌套定义

四、函数定义

• 函数1:无参，无返回值
• 函数2:无参，有返回值
• 函数3:有参，无返回值
• 函数4:有参，有返回值
• 函数5:多参，无返回值
• 函数6:多参，有返回值

package com.bigdata

object function {
  def main(args: Array[String]): Unit = {
    //函数1：无参，无返回值
    def f1(): Unit = {
      println("函数1：无参数，无返回值")
    }

    f1()

    //函数2；无参，有返回值
    def f2(): Int = {
      println("函数2：无参，有返回值")
      return 12
    }

    println(f2())

    //函数3：有参数，无返回值
    def f3(name: String): Unit = {
      println("函数3：有参数，无返回值 " + name)
    }

    f3("好好学scala")

    //函数4：有参数，有返回值
    def f4(name: String): String = {
      println("函数4：有参数，有返回值 " + name)
      return "好好学scala " + name
    }

    println(f4("加油"))

    //函数5：多参数，无返回值
    def f5(name: String, hobby: String): Unit = {
      println("函数5：多参数，无返回值")
      println(name + "喜欢" + hobby)
    }

    f5("飞", "足球")


    //函数6：多参数，有返回值
    def f6(a: Int,b: Int): Int = {
      println("函数6：多参数，有返回值")
      return a + b
    }

    println(f6(3,6))

  }
}

输出如下所示：

函数1：无参数，无返回值
函数2：无参，有返回值
12
函数3：有参数，无返回值 好好学scala
函数4：有参数，有返回值 加油
好好学scala 加油
函数5：多参数，无返回值
飞喜欢足球
函数6：多参数，有返回值
9

五、函数参数

• 可变参数
• 如果参数列表中存在多个参数，可变参数一般放置在最后
• 参数默认值，一般将有默认值的参数放置在参数列表的后面
• 带名参数

package com.bigdata

object function {
  def main(args: Array[String]): Unit = {
    //1.可变参数
    def f7(str: String*): Unit = {
      println(str)
    }
    f7("足球")
    f7("足球","羽毛球")

    //2.参数列表中存在多个参数，那么可变参数一般放置在最后
    def f8(str1: String,str2: String*): Unit = {
      println("str1: " + str1 + " str2: " + str2)
    }

    f8("足球","羽毛球","乒乓球")

    //3.参数默认值，一般有默认值的参数放置在参数列表的后面
    def f9(name: String = "huoying"): Unit = {
      println(name)
    }
    f9()
    f9("haizeiwang")

    //4.带名参数
    def f10(name: String = "鸣人", age: Int): Unit = {
      println(s"${age}岁的${name}在学习")
    }
    
    f10("佐助",20)
    f10(age = 11,name= "卡卡西")
    f10(age=5)

  }

}

输出如下所示：

1。可变参数
WrappedArray(足球)
1。可变参数
WrappedArray(足球, 羽毛球)
2。参数列表中存在多个参数，那么可变参数一般放置在最后 
str1: 足球 str2: WrappedArray(羽毛球, 乒乓球)
3。参数默认值，一般有默认值的参数放置在参数列表的后面
huoying
3。参数默认值，一般有默认值的参数放置在参数列表的后面
haizeiwang
4。带名参数
20岁的佐助在学习
4。带名参数
11岁的卡卡西在学习
4。带名参数
5岁的鸣人在学习

六、函数至简原则

1. return可以省略，Scala会使用函数体的最后一行代码作为返回值
2. 如果函数体只有一行代码，可以省略花括号
3. 返回值类型如果能够推断出来，那么可以省略，：和返回值类型一起省略
4. 如果有return，则不能省略返回值类型，必须指定
5. 如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
6. Scala如果期望是无返回值类型，可以省略等号
7. 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
8. 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
9. 如果不关心名称，只关心逻辑处理，那么函数名def可以省略

object function2 {

  def main(args: Array[String]): Unit = {
    //1.return可以省略，Scala会使用函数体的最后一行代码作为返回值
    def f1(name: String): String = {
      return name
    }

    println(f1("足球"))

    def f1bak(name :String): String = {
      name
    }

    println(f1bak("篮球"))

    // 2. 如果函数体只有一行代码，可以省略花括号
    def f2(name: String): String = name
    println(f2("羽毛球"))

    //3. 返回值类型如果能够推断出来，那么可以省略，：和返回值类型一起省略

    def f3(name: String) = name
    println(f3("水球"))

    //4. 如果有return，则不能省略返回值类型，必须指定
    def f4(name: String): String = {
      return name
    }

    //5. 如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
    def f5(name: String): Unit = {
      return name
    }

    println(f5("哈哈"))

    //6. Scala如果期望是无返回值类型，可以省略等号
    def f6(name: String) {
      println(f6("水球"))
    }

    //7. 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def f7(): Unit = {
      println("强啊")
    }

    f7

    // 8. 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
    def f8: Unit = {
      println(" 8. 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略")
    }

    f8

    // 9.如果不关心名称，只关心逻辑处理，那么函数名def可以省略
    def f9(name: String): Unit = {
      println(name)
    }
    //匿名函数，lambda表达式
    (name: String) => {println(name)}

  }

  }

七、匿名函数

• 没有名字的函数就是匿名函数
• (x:Int)=>{函数体}
• x：表示输入参数类型
• Int：表示输入参数类型
• 函数体：表示具体代码逻辑

匿名函数的至简原则

object LambdaTest {
  def main(args: Array[String]): Unit = {
    val fun = (name: String) => {println(name)}
    fun("篮球")



    //匿名函数作为参数
    def f(func: String => Unit): Unit = {
      func("足球")
    }

    f(fun)
    println("--------")
    f((name: String) => {println(name)})
  }
}

匿名函数的至简原则

1. 参数的类型可以省略，会根据形参进行自动推导
2. 类型省略后，发现只有一个参数，则圆括号可以省略。其他情况，没有参数和参数超过1的永远不能省略圆括号。
3. 匿名函数如果只有一行，则大括号也可以省略
4. 如果参数只出现一次，则参数省略且后面参数可以用_代替。
5. 如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线

object LambdaTest {
  def main(args: Array[String]): Unit = {
    val fun = (name: String) => {println(name)}
    fun("篮球")



    //匿名函数作为参数
    def f(func: String => Unit): Unit = {
      func("足球")
    }

    f(fun)
    println("--------")
    f((name: String) => {println(name)})

    //1。参数的类型可以省略，会根据形参进行自动推导
    f((name) => {println(name)})


    //2。类型省略后，发现只有一个参数，则圆括号可以省略。其他情况，没有参数和参数超过1的永远不能省略圆括号。
    f(name => {println(name)})

    //3。匿名函数如果只有一行，则大括号也可以省略
    f(name => println(name))

    //4. 如果参数只出现一次，则参数省略且后面参数可以用_代替。
    f(println(_))

    //5.如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
    f(println)
  }

}

二元函数使用示例：

object LambdaTest {
  def main(args: Array[String]): Unit = {

  println("-----------------")
  //定义一个二元运算函数，只操作1和2两个数，具体运算通过参数传入
  def dualFunctionOneAndTwo(fun:(Int,Int)=>Int): Int = {
    fun(1,2)
  }

  val add = (a:Int,b:Int) => a + b
  val minus = (a:Int,b:Int) => a - b
  println(dualFunctionOneAndTwo(add))
  println(dualFunctionOneAndTwo(minus))

  //二元函数简化
  println("-------------二元函数简化----------")
  println(dualFunctionOneAndTwo(_ + _))
  println(dualFunctionOneAndTwo(_ - _))
  println(dualFunctionOneAndTwo(-_ + _))

}}

输出如下所示：

-----------------
3
-1
-------------二元函数简化----------
3
-1
1