目录
一、声明变量
val/var 变量标识:变量类型 = 初始值
- val定义的是不可重新赋值的变量
- var定义的是可重新赋值的变量
- scala中定义变量类型写在变量名后面
- scala的语句最后不需要添加分号
二、类型推断定义变量
scala> val name = "tom"
name: String = tomscala可以自动根据变量的值来自动推断变量的类型，这样编写代码更加简洁。
三、惰性赋值
当有一些变量保存的数据较大时，但是不需要马上加载到JVM内存。可以使用惰性赋值来提高效率。
语法格式：
lazy val/var 变量名 = 表达式四、字符串
双引号
val/var 变量名 = "字符串"插值表达式
插值表达式可以有效避免大量字符串的拼接。
val/var 变量名 = s"${变量/表达式}字符串"在定义字符串之前添加s
在字符串中，可以使用${}来引用变量或者编写表达式
使用三引号
大段的文本需要保存，可以使用三引号来定义字符串。例如：保存一大段的SQL语句。三个引号中间的所有字符串都将作为字符串的值。
val/var 变量名 = """字符串1
字符串2"""val sql = """select
| *
| from
| t_user
| where
| name = "zhangsan""""
println(sql)
五、数据类型与操作符
scala中的类型以及操作符绝大多数和Java一样
数据类型
| 基础类型 |
类型说明 |
| Byte |
8位带符号整数 |
| Short |
16位带符号整数 |
| Int |
32位带符号整数 |
| Long |
64位带符号整数 |
| Char |
16位无符号Unicode字符 |
| String |
Char类型的序列（字符串） |
| Float |
32位单精度浮点数 |
| Double |
64位双精度浮点数 |
| Boolean |
true或false |
注意下 scala类型与Java的区别
- scala中所有的类型都使用大写字母开头
- 整形使用Int而不是Integer
- scala中定义变量可以不写类型，让scala编译器自动推断
运算符
| 类别 |
操作符 |
| 算术运算符 |
+、-、*、/ |
| 关系运算符 |
>、<、==、!=、>=、<= |
| 逻辑运算符 |
&&、||、! |
- scala中没有，++、--运算符
与Java不一样，在scala中，可以直接使用==、!=进行比较，它们与equals方法表示一致。而比较两个对象的引用值，使用eq
scala类型层次结构
| 类型 |
说明 |
| Any |
所有类型的父类，,它有两个子类AnyRef与AnyVal |
| AnyVal |
所有数值类型的父类 |
| AnyRef |
所有对象类型（引用类型）的父类 |
| Unit |
表示空，Unit是AnyVal的子类。它类似于Java中的void，但scala要比Java更加面向对象 |
| Null |
Null是AnyRef的子类，也就是说它是所有引用类型的子类。可以将null赋值给任何对象类型 |
| Nothing |
所有类型的子类 不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型 |
六、条件表达式
条件表达式就是if表达式。scala条件表达式的语法和Java一样。
scala> val sex = "male"
sex: String = male
scala> val result = if(sex == "male") 1 else 0
result: Int = 1
与Java不一样的是，
- 在scala中，条件表达式也是有返回值的
- 在scala中，没有三元表达式，可以使用if表达式替代三元表达式
块表达式
- scala中，使用{}表示一个块表达式
- 和if表达式一样，块表达式也是有值的
- 值就是最后一个表达式的值
scala> val a = {
| println("1 + 1")
| 1 + 1
| }七、循环
在scala中，可以使用for和while，但一般推荐使用for表达式，因为for表达式语法更简洁
for表达式
for(i <- 表达式/数组/集合) {
// 表达式
}简单循环
使用for表达式打印1-10的数字
参考代码1
scala> val nums = 1.to(10)
nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9，10)
scala> for(i <- nums) println(i)参考代码2
// 中缀调用法
scala> for(i <- 1 to 10) println(i)嵌套循环
使用for表达式，打印以下字符
*****
*****
*****
for(i <- 1 to 3; j <- 1 to 5) {print("*");if(j == 5) println("")}守卫
for表达式中，可以添加if判断语句，这个if判断就称之为守卫。我们可以使用守卫让for表达式更简洁。
for(i <- 表达式/数组/集合 if 表达式) {
// 表达式
}示例
使用for表达式打印1-10之间能够整除3的数字
// 添加守卫，打印能够整除3的数字
for(i <- 1 to 10 if i % 3 == 0) println(i)for推导式
在for循环体中，可以使用yield表达式构建出一个集合，我们把使用yield的for表达式称之为推导式
示例
生成一个10、20、30...100的集合
// for推导式：for表达式中以yield开始，该for表达式会构建出一个集合
val v = for(i <- 1 to 10) yield i * 10while循环
scala中while循环和Java中是一致的
示例
打印1-10的数字
scala> var i = 1
i: Int = 1
scala> while(i <= 10) {
| println(i)
| i = i+1
| }八、break和continue
- scala中，没有break/continue关键字
- 如果一定要使用break/continue，就需要使用scala.util.control包的Break类的breable和break方法。
实现break
用法
- 导入Breaks包import scala.util.control.Breaks._
- 使用breakable将for表达式包起来
- for表达式中需要退出循环的地方，添加break()方法调用
示例
使用for表达式打印1-100的数字，如果数字到达50，退出for表达式
// 导入scala.util.control包下的Break
import scala.util.control.Breaks._
breakable{
for(i <- 1 to 100) {
if(i >= 50) break()
else println(i)
}
}实现continue
用法
continue的实现与break类似，但有一点不同：
实现continue是用breakable{}将for表达式的循环体包含起来
示例
打印1-100的数字，使用for表达式来遍历，如果数字能整除10，不打印
// 导入scala.util.control包下的Break
import scala.util.control.Breaks._
for(i <- 1 to 100 ) {
breakable{
if(i % 10 == 0) break()
else println(i)
}
}九、方法
一个类可以有自己的方法，scala中的方法和Java方法类似。但scala与Java定义方法的语法是不一样的。
定义方法
def methodName (参数名:参数类型, 参数名:参数类型) : [return type] = {
// 方法体：一系列的代码
}- 参数列表的参数类型不能省略
- 返回值类型可以省略，由scala编译器自动推断
- 返回值可以不写return，默认就是{}块表达式的值
示例
- 定义一个方法，实现两个整形数值相加，返回相加后的结果
- 调用该方法
scala> def add(a:Int, b:Int) = a + b
m1: (x: Int, y: Int)Int
scala> add(1,2)
res10: Int = 3返回值类型推断
scala定义方法可以省略返回值，由scala自动推断返回值类型。
定义递归方法，不能省略返回值类型
定义递归方法（求阶乘）
10 * 9 * 8 * 7 * 6 * ... * 1
scala> def m2(x:Int) = {
| if(x<=1) 1
| else m2(x-1) * x
| }
<console>:13: error: recursive method m2 needs result type
else m2(x-1) * x十、方法参数
scala中的方法参数，使用比较灵活。它支持以下几种类型的参数：
- 默认参数
- 带名参数
- 变长参数
默认参数
在定义方法时可以给参数定义一个默认值。
// x，y带有默认值为0
def add(x:Int = 0, y:Int = 0) = x + y
add()带名参数
在调用方法时，可以指定参数的名称来进行调用。
def add(x:Int = 0, y:Int = 0) = x + y
add(x=1)变长参数
如果方法的参数是不固定的，可以定义一个方法的参数是变长参数。
def 方法名(参数名:参数类型*):返回值类型 = {
方法体
}在参数类型后面加一个*号，表示参数可以是0个或者多个
scala> def add(num:Int*) = num.sum
add: (num: Int*)Int
scala> add(1,2,3,4,5)
res1: Int = 15十一、方法调用方式
在scala中，有以下几种方法调用方式，
- 后缀调用法
- 中缀调用法
- 花括号调用法
- 无括号调用法
后缀调用法
这种方法与Java没有区别。
对象名.方法名(参数)
使用后缀法Math.abs求绝对值
scala> Math.abs(-1)
res3: Int = 1中缀调用法
语法 注意空格
对象名 方法名 参数
例如：1 to 10
如果有多个参数，使用括号括起来
示例
使用中缀法Math.abs求绝对值
scala> Math abs -1
res4: Int = 1操作符即方法
scala中，+ - * / %等操作符都是方法,操作符是一个方法名字是符号的方法。
花括号调用法
Math.abs{
// 表达式1
// 表达式2
}
方法只有一个参数，才能使用花括号调用法
使用花括号调用法Math.abs求绝对值
scala> Math.abs{-10}
res13: Int = 10无括号调用法
如果方法没有参数，可以省略方法名后面的括号
- 定义一个无参数的方法，打印"hello"
- 使用无括号调用法调用该方法
参考代码
def m3()=println("hello")
m3()十二、函数
定义函数
val 函数变量名 = (参数名:参数类型, 参数名:参数类型....) => 函数体
- 函数是一个对象（变量）
- 类似于方法，函数也有输入参数和返回值
- 函数定义不需要使用def定义
- 无需指定返回值类型
scala> val add = (x:Int, y:Int) => x + y
add: (Int, Int) => Int = <function2>
scala> add(1,2)
res3: Int = 3方法和函数的区别
- 方法是隶属于类或者对象的，在运行时，它是加载到JVM的方法区中
- 可以将函数对象赋值给一个变量，在运行时，它是加载到JVM的堆内存中
- 函数是一个对象，继承自FunctionN，函数对象有apply，curried，toString，tupled这些方法。方法则没有
方法无法赋值给变量
scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int
scala> val a = add
<console>:12: error: missing argument list for method add
Unapplied methods are only converted to functions when a function type is expected.
You can make this conversion explicit by writing `add _` or `add(_,_)` instead of `add`.
val a = add方法转换为函数
- 有时候需要将方法转换为函数，作为变量传递，就需要将方法转换为函数
- 使用_即可将方法转换为函数
scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int
scala> val a = add _
a: (Int, Int) => Int = <function2>