Scala总结（一）——基础语法

scala 第一个程序——helloworld

//继承App
object HelloWorld extends App {
  println("hello world")
}
//直接使用main方法
object HelloWorld2 {
  def main(args: Array[String]): Unit = {
    println("hello world")
  }
}

声明值和变量

声明变量两种方式 val , var

val a1=10//声明后不可变
var a2=10//声明后可变
var a2=5

1、scala 默认为匿名变量分配 val
2、val 定义的变量虽然不能改变其引用的内存地址，但是可以改变其引用的对象的内部的其
他属性值。
3、为了减少可变性引起的 bug，应该尽可能地使用不可变变量。变量类型可以省略，解析
器会根据值进行推断。val 和 var 声明变量时都必须初始化

常用类型

Boolean true 或 false

Byte 8位，有符号

Short 16 位, 有符号

Int 32 位, 有符号

Long 64 位, 有符号

Char 16 位, 无符号

Float 32 位, 单精度浮点数

Double 64 位, 双精度浮点数

String 其实就是由 Char 数组组成

与 Java 中的数据类型不同，Scala 并不区分基本类型和引用类型，所以这些类型都是对象，
可以调用相对应的方法。String 直接使用的是 java.lang.String. 不过，由于 String 实际是一系
列 Char 的不可变的集合，Scala 中大部分针对集合的操作，都可以用于 String，具体来说，
String 的这些方法存在于类 scala.collection.immutable.StringOps 中。
由于 String 在需要时能隐式转换为 StringOps，因此不需要任何额外的转换，String 就可以使
用这些方法。
每一种数据类型都有对应的 Rich* 类型，如 RichInt、RichChar 等，为基本类型提供了更多
的有用操作。

算术运算符重载

±*/%可以完成和 Java 中相同的工作，但是有一点区别，他们都是方法。你几乎可以用任何
符号来为方法命名

scala> 1 + 2
等同于：
scala> 1.+(2)

Scala 中没有++、–操作符，需要通过+=、-=来实现同样的效果。

调用函数与方法

在 scala 中，一般情况下我们不会刻意的去区分函数与方法的区别，但是他们确实是不同的
东西。后面我们再详细探讨。首先我们要学会使用 scala 来调用函数与方法。

1. 调用函数，求方根

scala> import scala.math._
scala> sqrt(100)

2. 调用方法，静态方法（scala 中没有静态方法这个概念，需要通过伴生类对象来实现）

scala> BigInt.probablePrime(16, scala.util.Random)

3. 调用方法，非静态方法，使用对象调用

scala> "HelloWorld".distinct

4. apply 与 与 update 方法
   apply 方法是调用时可以省略方法名的方法。用于构造和获取元素：
   “Hello”(4) 等同于 “Hello”.apply(4)
   Array(1,2,3) 等同于 Array.apply(1,2,3)
   如：

println("Hello"(4))
println("Hello".apply(4))

在 StringOps 中你会发现一个 def apply(n: Int): Char 方法定义。update 方法也是调用时可以省略方法名的方法，用于元素的更新：
arr(4) = 5 等同于 arr.update(4,5)
如：

val arr1 = newArray[Int](5)
arr1(1) = 2
arr1.update(1, 2)
println(arr1.mkString(","))

option 类型

Scala 为单个值提供了对象的包装器，表示为那种可能存在也可能不存在的值。他只有两个有效的子类对象，一个是 Some，表示某个值，另外一个是 None，表示为空，通过 Option的使用，避免了使用 null、空字符串等方式来表示缺少某个值的做法。

val map1 = Map("Alice" -> 20, "Bob" -> 30)
println(map1.get("Alice"))
println(map1.get("Jone"))

控制结构和函数

if else 表达式

scala 中没有三目运算符，因为根本不需要。scala 中 if else 表达式是有返回值的，如果 if 或者 else 返回的类型不一样，就返回 Any 类型（所有类型的公共超类型）。
例如：if else 返回类型一样

val a3 = 10
val a4 =
if(a3 > 20){
"a3 大于 20"
}else{
"a3 小于 20"
}
println(a4)

例如：if else 返回类型不一样

val a5 =
if(a3 > 20){
"a3 大于 20"
}
println(a5)

如果缺少一个判断，什么都没有返回，但是 Scala 认为任何表达式都会有值，对于空值，使用 Unit 类，写做()，叫做无用占位符，相当于 java 中的 void。
行尾的位置不需要分号，只要能够从上下文判断出语句的终止即可。但是如果在单行中写多个语句，则需要分号分割。在 Scala 中，{}快包含一系列表达式，其结果也是一个表达式。块中最后一个表达式的值就是块的值。

while表达式

Scala 提供和 Java 一样的 while 和 do 循环，与 If 语句不同，While 语句本身没有值，即整个While 语句的结果是 Unit 类型的()。
1) while

var n = 1;
val while1 =
while(n <= 10){
n += 1
}
println(while1)
println(n)

2) while 循环的中断

import scala.util.control.Breaks
val loop = new Breaks
loop.breakable{
while(n <= 20){
n += 1;
if(n == 18){
loop.break()
}
}
}
println(n)

scala 并没有提供 break 和 continue 语句来退出循环，如果需要 break，可以通过几种方法来做 1、使用 Boolean 型的控制变量 2、使用嵌套函数，从函数中 return 3、使用Breaks 对象的 break 方法。

for 表达式

Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称为 for 推导式（for comprehension）或 for 表达式（for expression）。

1) for 示例 1 ：to 左右两边为前闭后闭的访问

for(i <- 1 to 3; j <- 1 to 3){
print(i * j + " ")
}
println()

2) for 示例 2 ：until 左右两边为前闭后开的访问

for(i <- 1 until 3; j <- 1 until 3) {
print(i * j + " ")
}
println()

3) for 示例 3 ：引入保护式（也称条件判断式）该语句只打印 1 3 。保护式满足为 true 则进
为 入循环内部，满足为 false 则跳过，类似于 continue

for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
println()

4) for 示例 4

for(i <- 1 to 3; j = 4 - i) {
print(j + " ")
}
println()

5) for 示例 5 ：将遍历过程中处理的结果返回到一个，使用 yield 关键字

val for5 = for(i <- 1 to 10) yield i
println(for5)

6) for 示例 6 ：使用花括号{} 代替小括号()

for{
i <- 1 to 3
j = 4 - i}
print(i * j + " ")
println()

{}和()对于 for 表达式来说都可以。for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用原括号，当其包含多个表达式时使用大括号。值得注意的是，使用原括号时，早前版本的 Scala 要求表达式之间必须使用分号。

函数

scala 定义函数的标准格式为：

def 函数名(参数名 1: 参数类型 1, 参数名 2: 参数类型 2) : 返回类型 = {函数体}

1) 函数示例 1 ：返回 Unit 类型的函数

def shout1(content: String) : Unit = {
println(content)
}

2) 函数示例 2： ：回 返回 Unit 类型的函数 ， 但是没有显式指定返回类型 。 （ 当然也可以返回 非 Unit 类型的值）

def shout2(content: String) = {
println(content)
}

3) 函数示例 3 ：返回值类型有多种可能，此时也可以省略 Unit

def shout3(content: String) = {
if(content.length >= 3)
content + "喵喵喵~"
else
3
}

4) 函数示例 4： ： 带有默认值参数的函数 ， 调用该函数时 ， 可以只给无默认值的参数传递值 ，也可以都传递，新值会覆盖默认值；传递参数时如果不按照定义顺序，则可以通过参数名来指定。

def shout4(content: String, leg: Int = 4) = {
println(content + "," + leg)
}

5) 函数示例 5 ：变长参数（不确定个数参数，类似 Java 的…） ）

def sum(args: Int*) = {
var result = 0
for(arg <- args)
result += arg
result
}

6) 递归函数：递归函数在使用时必须有明确的返回值类型

def factorial(n: Int): Int = {
if(n <= 0)
1
else
n * factorial(n - 1)
}

1、Scala 可以通过=右边的表达式 推断出函数的返回类型。如果函数体需要多个表达式，可以用代码块{}。
2、可以把 return 当做 函数版本的 break 语句。
3、递归函数一定要指定返回类型。
4、变长参数通过* 来指定，所有参数会转化为一个 seq 序列。

过程

我们将函数的返回类型为 Unit 的函数称之为过程。
1) 定义过程示例 1

def shout1(content: String) : Unit = {
println(content)
}

2) 定义过程示例 2：

def shout1(content: String) = {
println(content)
}

3) 定义过程示例 3：

def shout1(content: String) {
println(content)
}

这只是一个逻辑上的细分，如果因为该概念导致了理解上的混淆，可以暂时直接跳过过程这样的描述。毕竟过程，在某种意义上也是函数。

懒值

当 val 被声明为 lazy 时，他的初始化将被推迟，直到我们首次对此取值，适用于初始化开销较大的场景。
lazy 示例：通过 lazy 关键字的使用与否，来观察执行过程

object Lazy {
def init(): String = {
println("init 方法执行")
"嘿嘿嘿，我来了~"
}
def main(args:Array[String]): Unit = {
lazy val msg = init()
println("lazy 方法没有执行")
println(msg)
}
}

异常

当碰到异常情况时，方法抛出一个异常，终止方法本身的执行，异常传递到其调用者，调用者可以处理该异常，也可以升级到它的调用者。运行系统会一直这样升级异常，直到有调用者能处理它。 如果一直没有处理，则终止整个程序。Scala 的异常的工作机制和 Java 一样，但是 Scala 没有“checked”异常，你不需要声明说函数或者方法可能会抛出某种异常。受检异常在编译器被检查，java 必须声明方法所会抛出的异常类型。
抛出异常：用 throw 关键字，抛出一个异常对象。所有异常都是 Throwable 的子类型。throw表达式是有类型的，就是 Nothing，因为 Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方。
捕捉异常： ：在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的代码里，是一系列 case 字句。
异常捕捉的机制与其他语言中一样，如果有异常发生，catch 字句是按次序捕捉的。因此，在 catch 字句中，越具体的异常越要靠前，越普遍的异常越靠后。 如果抛出的异常不在 catch字句中，该异常则无法处理，会被升级到调用者处。finally 字句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作。

异常示例

object ExceptionSyllabus {
def divider(x: Int, y: Int): Float= {
if(y == 0) throw new Exception("0 作为了除数")
else x / y
}
def main(args:Array[String]): Unit = {
try {
println(divider(10, 3))
} catch {
case ex: Exception => println("捕获了异常：" + ex)
} finally {}
}
}