Scala-函数的初级知识

偏执的太偏执、 2022-08-31 02:24 203阅读 0赞

# Scala函数式编程 #

**面向对象编程（OOP）**

命令式编程

解决问题,分解对象,行为,属性,然后通过对象的关系以及行为的调用来解决问题。

对象:用户

行为:登录、连接 JDBC、读取数据库

属性:用户名、密码

**Scala 语言是一个完全面向对象编程语言。万物皆对象**。

**对象的本质:对数据和行为的一个封装**

计算机执行效率更高

**函数式编程**

解决问题时,将问题分解成一个一个的步骤,将每个步骤进行封装(函数),通过调用这些封装好的步骤,解决问题。

例如:请求->用户名、密码->连接 JDBC->读取数据库

**Scala 语言是一个完全函数式编程语言。万物皆函数。**

**函数的本质:函数可以当做一个值进行传递**

程序员是上手难度更低，编程效率更高；函数式编程是没有副作用的，非常适合运行在分布式上，非常适合大数据的处理。如kafka、spark等均是由scala编写的，scala特别适合用在大数据中。

在 Scala 中函数式编程和面向对象编程完美融合在一起了。

## 函数基础 ##

### 基本语法 ###

![在这里插入图片描述][e295ba43a4a8078c526dc2e71420d9f0.png]

### 函数与方法的区别 ###

1、为完成某一功能的程序语句的集合,称为函数。

2、类中的函数称之方法。

3、Scala 语言可以在任何的语法结构中声明任何的语法

4、函数没有重载和重写的概念;方法可以进行重载和重写

5、Scala 中函数可以嵌套定义

// 函数与方法
    object Test1 { 
    
        def main(args: Array[String]): Unit = { 
    
            // 定义函数
            def sayHi(name: String): Unit = { 
                println(s"hi, $name")
            }
    
            // 调用函数
            sayHi("bobo")
            // 调用对象方法
            Test1.sayHi("alice")
        }
    
        // 定义对象方法
        def sayHi(name: String): Unit = { 
            println(s"Hi, $name")
        }
    }

### 函数定义 ###

1、函数 1:无参,无返回值

2、函数 2:无参,有返回值

3、函数 3:有参,无返回值

4、函数 4:有参,有返回值

5、函数 5:多参,无返回值

6、函数 6:多参,有返回值

### 函数参数 ###

1、可变参数

2、如果参数列表中存在多个参数,那么可变参数一般放置在最后

3、参数默认值,一般将有默认值的参数放置在参数列表的后面

4、带名参数

// 函数参数
    object Test2 { 
        def main(args: Array[String]): Unit = { 
    
            // 1、可变参数
            def f1(str: String*): Unit = { 
                println(str)
            }
            f1("alice")             // WrappedArray(alice)
            f1("aaa", "bbb", "ccc") // WrappedArray(aaa, bbb, ccc)
    
    
            // 2、如果参数列表中存在多个参数,那么可变参数一般放置在最后
            def f2(str1: String, str2: String*): Unit = { 
                println(s"str1: ${str1}, str2: ${str2}")
            }
            f2("alice")                   // str1: alice, str2: WrappedArray()
            f2("aaa", "bbb", "ccc") // str1: aaa, str2: WrappedArray(bbb, ccc)
    
            // 3、参数默认值,一般将有默认值的参数放置在参数列表的后面
            def f3(name: String = "test"): Unit = { 
                println(s"I am $name")
            }
            f3()                 // I am test
            f3("hahaha")  // I am hahaha
    
            // 4、带名参数
            def f4(name: String = "wuwuwu", age: Int): Unit = { 
                println(s"I am $name, age is $age")
            }
    
            f4("test", 11)    // I am test, age is 11
            f4(age = 100, name = "hahaha") // I am hahaha, age is 100
            f4(age = 1)                    // I am wuwuwu, age is 1
        }
    }

### 函数至简原则 ###

函数至简原则:**能省则省**

1、return 可以省略,Scala 会使用函数体的最后一行代码作为返回值

2、如果函数体只有一行代码,可以省略花括号

3、返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起省略)

4、如果有 return,则不能省略返回值类型,必须指定

5、如果函数明确声明 unit,那么即使函数体中使用 return 关键字也不起作用

6、Scala 如果期望是无返回值类型,可以省略等号

7、如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加

8、如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略

9、如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略

// 函数至简原则
    object Test3 { 
    
        def main(args: Array[String]): Unit = { 
    
            def f0(name: String): String = { 
                return name;
            }
            println(f0("test0")) // test0
    
            // 1、return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
            def f1(name: String): String = { 
                name;
            }
            println(f1("test1")) // test1
    
            // 2、如果函数体只有一行代码,可以省略花括号
            def f2(name: String): String = name
            println(f2("test2")) // test2
    
            // 3、返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起省略)
            def f3(name: String) = name
            println(f3("test3")) // test3
    
            // 4、如果有 return,则不能省略返回值类型,必须指定
            def f4(name: String): String = { 
                return name;
            }
            println(f4("test4")) // test4
    
            // 5、如果函数明确声明 unit,那么即使函数体中使用 return 关键字也不起作用
            def f5(name: String): Unit = { 
                return name;
            }
            println(f5("test5")) // ()
    
            // 6、Scala 如果期望是无返回值类型,可以省略等号
            // 称为过程
            def f6(name: String) { 
                println(name)           // test6
            }
            println(f6("test6")) // ()
    
            // 7、如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加
            def f7(): Unit = { 
                println("test7")
            }
            f7() // test7
            f7   // test7
    
            // 8、如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略
            def f8: Unit = { 
                println("test8")
            }
    // f7()
            f8   // test8
    
            // 9、如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略
            def f9(name: String): Unit = { 
                println(name)
            }
            // 匿名函数，lambda表达式
            (name: String) => {  println(name) }
        }
    }

[e295ba43a4a8078c526dc2e71420d9f0.png]: /images/20220829/48c18b155d714acfbc42b7335aff1fdd.png