一、概述

• Scala语言是基于Java开发的，所以其编译后的文件也是字节码文件，并可以运行在JVM中。
• Scala这门语言体现了面向对象，函数式编程等多种不同的语言范式，且融合了不同语言新的特性。即Scala是一门可伸缩的软件编程语言

二、win安装scala

1. 官网下载安装包
   scala官网下载安装包

2. 安装scala
   a.解压文件：scala-2.12.11.zip，解压目录要求无中文无空格（java软件内部会读取本地路径，有空格和中文会导致乱码）
   b.配置环境变量
   
   

3. 验证是否安装成功（出现下图说明scala安装成功了）
   

4. idea安装插件
   有网：
   
   无网络：
   下载地址（下载和idea版本匹配的插件包）：
   https://plugins.jetbrains.com/plugin/1347-scala/versions
   安装插件：
   

三、scala demo

package com.demo.helloworld

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("hello world")
  }
}
1
2
3
4
5
6
7

控制台输出结果：

D:\ruanjian\jdk8\bin\java.exe "-javaagent:D:\ruanjian\idea\IntelliJ IDEA 2021.1.3\lib\idea_rt.jar=7720:D:\ruanjian\idea\IntelliJ IDEA 2021.1.3\bin" -Dfile.encoding=UTF-8 -classpath D:\ruanjian\jdk8\jre\lib\charsets.jar;D:\ruanjian\jdk8\jre\lib\deploy.jar;D:\ruanjian\jdk8\jre\lib\ext\access-bridge-64.jar;D:\ruanjian\jdk8\jre\lib\ext\cldrdata.jar;D:\ruanjian\jdk8\jre\lib\ext\dnsns.jar;D:\ruanjian\jdk8\jre\lib\ext\jaccess.jar;D:\ruanjian\jdk8\jre\lib\ext\jfxrt.jar;D:\ruanjian\jdk8\jre\lib\ext\localedata.jar;D:\ruanjian\jdk8\jre\lib\ext\nashorn.jar;D:\ruanjian\jdk8\jre\lib\ext\sunec.jar;D:\ruanjian\jdk8\jre\lib\ext\sunjce_provider.jar;D:\ruanjian\jdk8\jre\lib\ext\sunmscapi.jar;D:\ruanjian\jdk8\jre\lib\ext\sunpkcs11.jar;D:\ruanjian\jdk8\jre\lib\ext\zipfs.jar;D:\ruanjian\jdk8\jre\lib\javaws.jar;D:\ruanjian\jdk8\jre\lib\jce.jar;D:\ruanjian\jdk8\jre\lib\jfr.jar;D:\ruanjian\jdk8\jre\lib\jfxswt.jar;D:\ruanjian\jdk8\jre\lib\jsse.jar;D:\ruanjian\jdk8\jre\lib\management-agent.jar;D:\ruanjian\jdk8\jre\lib\plugin.jar;D:\ruanjian\jdk8\jre\lib\resources.jar;D:\ruanjian\jdk8\jre\lib\rt.jar;D:\ruanjian\ideaworkspace\ScalaDemo\scala\target\classes;D:\ruanjian\scala\scala-2.12.11\lib\scala-library.jar;D:\ruanjian\scala\scala-2.12.11\lib\scala-parser-combinators_2.12-1.0.7.jar;D:\ruanjian\scala\scala-2.12.11\lib\scala-reflect.jar;D:\ruanjian\scala\scala-2.12.11\lib\scala-swing_2.12-2.0.3.jar;D:\ruanjian\scala\scala-2.12.11\lib\scala-xml_2.12-1.0.6.jar com.demo.helloworld.HelloWorld
hello world

Process finished with exit code 0
1
2
3
4

四、scala 基础语法

1. 注释和数据类型：

a. 和java一样，分为单行 多行 文档注释

package com.demo.helloworld

/**
 * 文档注释
 * */
object ScalaComment {
  // 单行注释
  /*
  * 多行注释
  * */
}
1
2
3
4
5
6
7
8
9
10
11

b.Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意引用对象类型(AnyRef)

2.变量：

语法： var | val 变量名 ：变量类型 = 变量值

package com.demo.helloworld

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

    // var | val 变量名 ：变量类型 = 变量值
    var username :String = "zhansan"
    val password :String = "zhansan"

    // 1.变量的类型如果能够通过变量值推断出来，那么可以省略类型声明，
    // 这里的省略，并不是不声明，而是由Scala编译器在编译时自动声明编译的。
    var username1 = "zhansan"
    val password1 = "zhansan"

    // 2. Java语法中变量在使用前进行初始化就可以，但是Scala语法中是不允许的，必须显示进行初始化操作。
    var username2 //报错
    var username2 = ""

    // 3. 可变变量 使用关键字var进行声明 
    // 不可变变量使用关键字val进行声明, 类似于Java语言中的final关键字
    var username3 = "zhansan"
    val password3 = "zhansan"
    
  }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3 .分支控制:单分支、双分支、多分支

a. 单分支:
IF...ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块
语法：
if(布尔表达式) {
1
2
3
4

// 如果布尔表达式为 true 则执行该语句块
}

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
		}
    }
}
1
2
3
4
5
6
7
8

b.双分支：
语法：
if(布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
} else {
// 如果布尔表达式为 false 则执行该语句块
}

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
		} else {
    		println("false")
		}
   }
}
1
2
3
4
5
6
7
8
9
10

c. 多分支：
语法：
if(布尔表达式1) {
// 如果布尔表达式1为 true，则执行该语句块
} else if ( 布尔表达式2 ) {
// 如果布尔表达式2为 true，则执行该语句块
}…
} else {
// 上面条件都不满足的场合，则执行该语句块
}

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        if ( age < 18 ) {
            println("童年")
        } else if ( age <= 30 ) {
            println("青年")
        } else if ( age <= 50 ) {
            println("中年")
        } else {
            println("老年")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：Scala语言中没有三元运算符的，使用if分支判断来代替三元运算符

4. 循环控制

a. for循环
语法：
for ( 循环变量 <- 数据集 ) {
循环体
}

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) ) { // 范围集合
            println("i = " + i )
        }
        for ( i <- 1 to 5 ) { // 包含5
            println("i = " + i )
        }
        for ( i <- 1 until 5 ) { // 不包含5
            println("i = " + i )
        }
		
		// 循环步长
		for ( i <- Range(1,5,2) ) {// 不包含5 
            println("i = " + i )
        }
        for ( i <- 1 to 5 by 2 ) {// 不包含5
            println("i = " + i )
        }
		// 循环嵌套
		 for ( i <- Range(1,5) ) {
            for ( j <- Range(1,4) ) {
                println("i = " + i + ",j = " + j )
            }
        }
        // 循环守卫：满足条件走循环体
         for ( i <- Range(1,5) if i != 3  ) {
            println("i = " + i )
        }
        // 引入变量
         for ( i <- Range(1,5); j = i - 1 ) {
            println("j = " + j )
        }
        // 表达式的返回值 关键词 yield 
        val result = for ( i <- Range(1,5) ) yield {
            i * 2
        }
        println(result)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

b. while
语法:
while( 循环条件表达式 ) {
循环体
}

一种特殊的while循环就是，先执行循环体，再判断循环条件是否成立
do {
循环体
} while ( 循环条件表达式 )

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 0
        while ( i < 5 ) {
            println(i)
            i += 1
        }
        // do while
        var ii = 5
        do {
            println(ii)
        } while ( ii < 5 )
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

scala是完全面向对象的语言，所以无法使用break，continue关键字这样的方式来中断，或继续循环逻辑，而是采用了函数式编程的方式代替了循环语法中的break和continue

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        scala.util.control.Breaks.breakable {
            for ( i <- 1 to 5 ) {
                if ( i == 3 ) {
                    scala.util.control.Breaks.break
                }
                println(i)
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

5.函数式编程

将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的功能按照指定的步骤，解决问题。

方法也是函数，只不过类中声明的函数称之为方法，其他场合声明的就是函数了。类中的方法是有重载和重写的。而函数可就没有重载和重写的概念了，但是函数可以嵌套声明使用。

a. 基本语法：
[修饰符] def 函数名 ( 参数列表 ) [:返回值类型] = {
函数体
}
例如：
private def test( s : String ) : Unit = {
println(s)
}

object ScalaFunction {
    def main(args: Array[String]): Unit = {
    	// 查看编译文件之后：
    		//1.函数被编译还是方法
    		//2.函数和方法名一致，调用时，默认调用函数；如果想调用方法，可以使用this.方法名
    	// 函数 无参数 无返回值
        def fun1(): Unit = {
            println("函数体")
        }
        fun1()
       // 无参数 有返回值
       def fun2(): String = {
            "zhangsan"
        }
        println( fun2() )
        // 有参无返回值
        def fun3( name:String ): Unit = {
            println( name )
        }
        fun3("zhangsan")
        //有参有返回值
        def fun4(name:String): String = {
            "Hello " + name
        }
        println( fun4("zhangsan") )
        // 多参无返回值
        def fun5(hello:String, name:String): Unit = {
            println( hello + " " + name )
        }
        fun5("Hello", "zhangsan")
        //多参有返回值
       def fun6(hello:String, name:String): String = {
            hello + " " + name
        }
        println( fun6("Hello", "zhangsan"))
    }
 	// 方法    
    def fun1(): Unit = {
            println("函数体")
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

注意：函数参数没有限制，如果有多个参数，java中使用…,scala中使用*

object ScalaFunction {
    def main(args: Array[String]): Unit = {
    	// 可变参数
        def fun7(names:String*): Unit = {
            println(names)
        }
        fun7()
        fun7( "zhangsan" )
        fun7( "zhangsan", "lisi" )
    }
    // 可变参数不能放置在参数列表的前面，一般放置在参数列表的最后
    // Error
    def fun77(names:String*, name:String): Unit = {
            
    }
    // 正确
    def fun777( name:String, names:String* ): Unit = {
            println( name )
            println( names )
    }

	//参数默认值
	def fun8( name:String, password:String = "000000" ): Unit = {
            println( name + "," + password )
    }
        fun8("zhangsan", "123123")
        fun8("zhangsan")
       
    //带名参数
    def fun9( password:String = "000000", name:String ): Unit = {
            println( name + "," + password )
        }
        fun9("123123", "zhangsan" )
        fun9(name="zhangsan")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

---- 简化版本
简单来说就是：能省则省。

package com.function

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

    def test1():String = {
      return "zhangsan"
    }

    // 1. 省略return关键字：函数体会将满足条件的最后一行代码的执行结果作为返回值返回
    def test2():String = {
      "zhangsan"
    }

    //2.省略返回值类型 :根据返回值idea可以推断出来类型，可省略返回值
    def test3() = {
      "zhangsan"
    }

    // 3. 省略花括号: 如果函数体的代码只有一行，花括号可以省略
    def test4() = "zhangsan"

    // 4.省略括号：当参数列表没参数的时候是可以省略括号的，调用的时候是注意不需要加（）即：println(test5)
    def test5 = "zhangsan"

    // 5. 省略等号：如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略
    def test6() {
      "zhangsan"
    }

    //6.省略函数名称和关键字：需要同时把返回值类型一起省略,等号加上箭头
    () => { // 匿名函数
      println("zhangsan")
    }

  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

6.高阶函数编程

所谓的高阶函数，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构。