Scala 简介一
一、概述
- Scala语言是基于Java开发的，所以其编译后的文件也是字节码文件，并可以运行在JVM中。
- Scala这门语言体现了面向对象，函数式编程等多种不同的语言范式，且融合了不同语言新的特性。即Scala是一门可伸缩的软件编程语言
二、win安装scala
-
官网下载安装包
scala官网下载安装包 -
安装scala
a.解压文件：scala-2.12.11.zip，解压目录要求无中文无空格（java软件内部会读取本地路径，有空格和中文会导致乱码）
b.配置环境变量
-
验证是否安装成功（出现下图说明scala安装成功了）
-
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")
}
}
控制台输出结果：
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
四、scala 基础语法
1. 注释和数据类型：
a. 和java一样，分为单行 多行 文档注释
package com.demo.helloworld
/**
* 文档注释
* */
object ScalaComment {
// 单行注释
/*
* 多行注释
* */
}
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"
}
}
3 .分支控制:单分支、双分支、多分支
a. 单分支:
IF...ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块
语法：
if(布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
}
object ScalaBranch {
def main(args: Array[String]): Unit = {
val b = true
if ( b ) {
println("true")
}
}
}
b.双分支：
语法：
if(布尔表达式) {
// 如果布尔表达式为 true 则执行该语句块
} else {
// 如果布尔表达式为 false 则执行该语句块
}
object ScalaBranch {
def main(args: Array[String]): Unit = {
val b = true
if ( b ) {
println("true")
} else {
println("false")
}
}
}
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("老年")
}
}
}
注意：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)
}
}
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 )
}
}
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)
}
}
}
}
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("函数体")
}
}
注意：函数参数没有限制，如果有多个参数，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")
}
---- 简化版本
简单来说就是：能省则省。
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")
}
}
}
6.高阶函数编程
所谓的高阶函数，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构。