一.Scala 概述

1.1 什么是 Scala

Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种个性。

Scala 运行在 Java 虚拟机上，并兼容现有的 Java 程序。

Scala 源代码被编译成 Java 字节码，所以它能够运行于 JVM 之上，并能够调用现有的 Java 类库。

Scala 官网 https://www.scala-lang.org/

1.2 装置

1.2.1 装置 jdk(1.8 以上版本)

略

1.2.2 装置 Scala

在官网上下载，我这里是 Ubuntu 零碎，抉择版本为 scala-2.12.11.tgz
装置很简略
1）解压文件
2）将解压后的目录搁置在指定目录

# 我这里是 /usr/local 目录
mv scala-2.12.11 /usr/local/

3）配置环境变量
/etc/profile 追加如下内容

# set scala
export SCALA_HOME=/usr/local/scala-2.12.11
export PATH=${PATH}:${SCALA_HOME}/bin

执行 source /etc/profile

4）测试下
如下显示，示意装置胜利

(base) zhaow@zhaow-610:~$ scala
Welcome to Scala 2.12.11 (Java HotSpot(TM) 64-Bit Server VM, Java 11.0.1).
Type in expressions for evaluation. Or try :help.
scala> 

二.Scala 根本语法

2.1 第一个 Scala 程序 HelloWorld

学习编程语言，第一个入门程序，必然是 HelloWorld.scala

object HelloWorld {def main(args: Array[String]): Unit = {
   // 打印 HelloWorld
    println("Hello World!")
  }

}

而后进行编译

scalac HelloWorld.scala

编译之后生成两个文件,

HelloWorld.class
HelloWorld$.class

运行 HelloWorld.class

scala HelloWorld

输入后果 HelloWorld

2.2 正文

Scala 正文与 Java 正文齐全一样

/**
 * 文档正文
 */
object HelloWorld {def main(args: Array[String]): Unit = {
    // 单行正文
    /*
     多行正文 1
     多行正文 2
     */
    println("Hello World!")
  }

}

2.3 标识符

Scala 应用的标识符有两种模式：字符数字和符号

• 字符数字应用字母或是下划线结尾，前面能够接字母或是数字，符号 ”$” 在 Scala 中也看作为字母。然而以 ”$” 结尾的标识符为保留的 Scala 编译器产生的标志符应用，应用程序应该防止应用 ”$” 开始的标识符，免得造成抵触。
• Scala 的命名规定采纳和 Java 相似的 camel 命名标准，首字符小写，比方 toString。类名的首字符还是应用大写。此外也应该防止应用以下划线结尾的标志符以防止抵触。
• Scala 外部实现时会应用本义的标志符，比方:-> 应用 $colon$minus$greater 来示意这个符号。

代码示例

object Scala_Indentifier {def main(args: Array[String]): Unit = {
    // 默认状况下，scala 标识符申明形式和 java 统一
    val name = "张三"
    val user_age = 14
    val address1 = "BJ"
    val _sex = "男"
    val $emain = "123@123.com"
//    val 1name = "张三" // 谬误示范
//    val class = "张三" // 谬误示范

    // Scala 标识符能够应用符号进行申明，但常见语法操作的符号是不能应用的
    // 例如(),[],"",''
    val + = "张三"
    val - = "张三"
    val * = "张三"
    val / = "张三"
//    val (= "张三" // error}

}

2.4 数据类型与类型转换

2.4.1 数据类型

Scala 是齐全面向对象的语言，所以不存在根本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意援用对象类型 (AnyRef)
如下图所示

2.4.2 类型转换

1）主动类型转换

object ScalaDataType {def main(args: Array[String]): Unit = {
    // Scala 主动类型转换
    // 例如 Byte 类型和 Short 类型的主动转换
    val byte_num = 11
    val short_num = byte_num
    val i_num:Int = short_num
 

  }
}

2）强制类型转换

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

    // 将精度打的类型转换为精度小的类型
    // Scala 中应用办法进行转换
    val i_num = 12
    val b_num = i_num.toByte
    // 基本上 Scala 的 AnyVal 类型之间都提供了相应转换的办法
  }
}

3）字符串类型转换
scala 是齐全面向对象的语言，所有的类型都提供了 toString 办法，能够间接转换为字符串

2.5 变量

1）语法申明

object ScalaVariable {def main(args: Array[String]): Unit = {
    // 申明形式 1 var 变量名: 变量类型 = 变量值
    var name1:String = "张三"
    // 申明形式 2 val 变量名: 变量类型 = 变量值
    val name2:String = "张三"
    // var 和 val 申明形式不同之处
    // var 申明形式 变量能够批改，为可变变量
    name1 = "王五"
    // val 申明形式 变量不能够批改，为不可变变量
    name2 = "王五" // 谬误
  }
}

2）精简书写

object ScalaVariable {def main(args: Array[String]): Unit = {
    // 残缺申明规定
    val name1:String = "张三"
    // 其中数据类型能够不指定，这时候，则会进行数据类型的推断
    val name2 = "张三"
    println(name2.getClass.getSimpleName) // 输入后果为 String
  }
}

3）总结

• 申明变量时，数据类型能够指定，也能够不指定，如果不指定，那么就会进行数据类型的推断。
• 如果指定数据类型，数据类型的执行 形式是 在变量名前面写一个冒号，而后写上数据类型。

• scala 外面变量的修饰符有两个，var 和 val。

  • 如果是 var 润饰的变量，那么这个变量的值是能够批改的。
  • 如果是 val 润饰的变量，那么这个变量的值是不能够批改的。

2.5 字符串

Scala 中，字符串的类型实际上就是 Java 中的 String
咱们从 String 的源码能够看到这一点

type String        = java.lang.String

String 是不可变的字符串对象，不可被批改，这与 Java 统一，批改时，会产生一个新的字符串对象。

2.5.1 字符串连贯

object Scala_string {def main(args: Array[String]): Unit = {
    val name:String = "张三"
    val sex:String = "男"
    println(name+":"+sex)
  }
}

2.5.2 字符串传值

代码示例

object Scala_string {def main(args: Array[String]): Unit = {
    val name = "张三"
    // 应用 printf 格式化字符串
    printf("name=%s",name)
  }
}

2.5.3 字符串插值和多行字符串

代码示例

object Scala_string {def main(args: Array[String]): Unit = {
    // 字符串插值
    val name = "张三"
    println(s"name=$name")
    
    // 多行字符串格局，在封装 SQL 或者 JSON 比拟罕用
    // | 默认顶格符
    println(
      s"""
         |select
         |*
         |from
         |demo_tb
         |""".stripMargin)
    
    
  }
}

2.6 运算符

scala 运算符的应用和 Java 运算符的应用基本相同，只是 Scala 中运算符实际上是办法。
示例

object ScalaOper {def main(args: Array[String]): Unit = {
    val i = 10
    // val j = i + 10 // 实际上执行的是办法
    val j = i.+(10)
    println(j)
  }

}

2.7 流程管制

2.7.1 分支语句

代码示例

object Scala_Flow {def main(args: Array[String]): Unit = {
    // 单分支
    val num = 91
    if(num>100){println("num 大于 100")
    }

    // 双分支
    if(num>100){println("num 大于 100")
    }else{println("num 不大于 100")
    }

    // 多分支
    if(num>100){println("num 大于 100")
    }else if(num > 90){println("num 大于 90，且小于等于 100")
    }else{println("num....")
    }

  }
}

另外 if 条件表达式是有返回值的，返回值会依据条件表达式的状况主动进行数据类型推断
代码示例

object Scala_Flow {def main(args: Array[String]): Unit = {
    val age = 20
    val res = if(age > 20) 1 else 0
    println(res)
  }
}

2.7.2 循环语句

1）for 循环

• 根本语法

for (循环变量 <- 数据集) { // 这里的数据集能够是任意类型的数据汇合，如字符串，汇合，数组等
    循环体
}

代码示例

object Scala_Loop {def main(args: Array[String]): Unit = {
    // 示例 1
    for(i <- Range(1,5)){ // 左闭右开，不蕴含 5
      println("i========="+i)
    }
    // 示例 2
    for(i <- 1 to 5){ // 蕴含 5
      println("i=========="+i)
    }

    // 示例 3
    for(i <- 1 until 5){ // 不蕴含 5
      println("i======="+i)
    }

  }
}

• 循环时减少条件判断

代码示例

object Scala_Loop {def main(args: Array[String]): Unit = {for(i <- Range(1,30) if (i%2)==0){println("i========"+i)
    }

  }
}

• 循环步长

object Scala_Loop {def main(args: Array[String]): Unit = {for(i <- Range(1,10,2)){println("i=========="+i)
    }
    for(i <- 1 to 10 by 2){println("i========="+i)
    }

  }
}

• for 循环推导

object Scala_Loop {def main(args: Array[String]): Unit = {
    // for 循环推导式:
    // 如果 for 训话中的循环体以 yield 开始，则该循环会构建一个汇合，每次迭代会生成汇合中的一个值
    val value = for(i <- 1 to 5) yield i * 20
    println(value)
  }
}

2）while 循环

• 根本语法

while(循环条件表达式) {循环体}

• 代码示例

object Scala_Loop {def main(args: Array[String]): Unit = {
    var i = 0
    while (i < 5){println("i========="+i)
      i+=1
    }
  }
}

3）中断循环
Scala 是齐全面向对象的语言，无奈应用 break、continue 这样的关键字。
Scala 采纳函数式编程的形式代替了循环语法中的 break
示例

import scala.util.control.Breaks

object Scala_Loop {def main(args: Array[String]): Unit = {
    Breaks.breakable{for(i <- 1 to 5){if( i==3){Breaks.break}
      }
    }
  }
}

也能够这样导包，简化书写

import scala.util.control.Breaks._

object Scala_Loop {def main(args: Array[String]): Unit = {
    breakable{for(i <- 1 to 5){if( i==3){break}
      }
    }
  }
}