Scala基础知识 - 技术栈

面向对象编程与函数式编程的介绍：

面向对象编程（OOP）和函数式编程（FP）的基本概念。

对象为中心：将数据和操作数据的方法封装为"对象"。

Scala 语言是一个完全面向对象编程语言。万物皆对象对象的本质：对数据和行为的一个封装

函数为中心：将计算视为数学函数的求值，强调纯函数。

Scala 语言是一个完全函数式编程语言。万物皆函数。函数的本质：函数可以当做一个值进行传递
函数的基本语法：

函数定义的关键字（DEF）、函数名、参数及其类型、返回值类型等基本语法。

Scholar语言在声明变量时可以省略显性类型，但内部仍然非常在意数据类型。

案例实操:

函数与方法的区别：

函数是独立的功能集合，而方法是类的函数。

函数没有重载或重写的概念，而方法可以根据形参列表的不同进行重载或重写。

实操演示：

java 复制代码

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

    def test1(): Unit = {
      println("无参，无返回值")
    }

    test1()
  }
  // 函数 2：无参，有返回值
    def test2():String={
      return "无参，有返回值"
    }
      println(test2())
  // 函数 3：有参，无返回值
    def test3(s:String):Unit={ println(s)
    }
    test3("scala")
  // 函数 4：有参，有返回值
    def test4(s:String):String={ return s+"有参，有返回值"
    }
      println(test4("hello "))
  // 函数 5：多参，无返回值
    def test5(name:String, age:Int):Unit={ println(s"$name, $age")
    }
    test5("dalang",40)

}

通过面向对象的方式连接MySQL数据库，包括用户名、密码和URL等属性。

函数式编程

函数的基本语法

函数定义

函数的基本语法，包括关键字DEF、函数名、参数及其类型、返回值类型等。

参数类型和返回值类型在强类型语言中的重要性。

函数调用

函数定义和调用的步骤，指出如果不调用函数，程序不会有任何输出。

如何定义和调用一个简单的函数来打印"hello world"。
函数与方法的区别

函数

出函数没有重载或重写的概念，同名的函数只能有一个。

不同类型的函数定义和调用方法

方法是类的函数，可以重载或重写。

方法需要在类的内部定义，并且可以根据形参列表的不同进行重载。
函数参数的类型

可变参数

可变参数的概念，即在参数类型后面加一个星号表示该参数是可变的。

强调了多个参数时，可变参数一般放置在最后。

函数定义的六种情况

无参无返回值

无参有返回值

有参无返回值

函数参数与质检原则

可变参数

可变参数的概念，即在函数定义时使用星号（*）表示该参数可以接受一个或多个值，甚至可以不传入值。

示例代码

java 复制代码

object TestFunction {
  def main(args: Array[String]): Unit = {
    // （1）可变参数
    def test(s: String*): Unit = {
      println(s)
    }
    // 有输入参数：输出 Array
    test("Hello", "Scala")
    // 无输入参数：输出List()
    test()

    // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
    def test2(name: String, s: String*): Unit = {
      println(name + "," + s)
    }
    test2("jinlian", "dalang")
    // (3)参数默认值
    def test3( name : String, age : Int = 30 ): Unit = {
      println(s"$name, $age")
    }
    // 如果参数传递了值，那么会覆盖默认值
    test3("jinlian", 20)
    // 如果参数有默认值，在调用的时候，可以省略这个参数
    test3("dalang")
    // 一般情况下，将有默认值的参数放置在参数列表的后面
    def test4( sex : String = "男", name : String ): Unit = {
      println(s"$name, $sex")
    }
    // Scala 函数中参数传递是，从左到右
    //test4("wusong")
    //（4）带名参数
    test4(name="ximenqing")


}
}

函数质检原则

函数质检原则的重要性，概括为"能省则省"。
具体原则包括 ：

return 可以省略，函数体的最后一行代码作为返回值。

函数体只有一行时可以省略大括号。

返回值类型可以省略，前提是能推断出来。

有 return 时不能省略返回值类型。

无返回值类型时可以省略等号。

无参数时调用函数可以省略小括号。

不关心名称时可以省略 def。
高阶函数与匿名函数

高阶函数

高阶函数的概念，即函数可以作为值传递、作为参数传递以及作为返回值返回。

示例代码

定义函数、调用函数

匿名函数

匿名函数的语法特点包括：

可以省略函数类型。

只有一个参数时可以省略圆括号。

只有一行代码时可以省略大括号。

参数只出现一次时可以用标识符代替。
闭包、柯里化与递归

闭包

闭包的概念，即函数访问到其外部或局部变量时，该函数及其环境称为闭包。

示例代码展示了闭包的使用方法。

柯里化

柯里化的概念，即将多个参数列表变成多个参数列表，以简化复杂参数的情况。

示例代码展示了柯里化的具体用法。

递归

递归的概念，即函数在其内部调用自身。

递归的使用方法，并强调了递归算法的注意事项：

方法必须调用自身。

方法必须有跳出逻辑。

传递的参数应有规律。

必须声明函数的返回值类型。
惰性加载

惰性加载的概念，即将函数的返回值声明为 lazy，函数的执行会被推迟到取值时。

示例代码

java 复制代码

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

    lazy val res = sum(10, 30)
    println("----------------")
    println("res=" + res)
}

def sum(n1: Int, n2: Int): Int = 
{ println("sum 被 执 行 。 。 。 ") 
return n1 + n2
}
输出结果：

----------------
sum 被执行。。。
res=40