scala的语法规则 （一）
一 scala解释器
scala解释器像Linux命令一样，执行一条代码，马上就可以让我们看到执行结果，用来测试比较方便。
要启动scala解释器，只需要以下几步：
按住windows键 + r
输入scala即可
Welcome to Scala 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_221).
Type in expressions for evaluation. Or try :help.
scala>
退出解释器
在scala命令提示窗口中执行:quit，即可退出解释器
二 变量
语法格式
java变量：
int a = 0;
在scala中，可以使用val或者var来定义变量，语法格式如下:
val/var 变量标识:变量类型 = 初始值
其中
val定义的是不可重新赋值的变量
var定义的是可重新赋值的变量
scala中定义变量类型写在变量名后面
scala的语句最后不需要添加分号
在解释器中定义一个变量
示例：定义一个变量保存一个人的名字"tom"
scala> val name:String = "tom"
name: String = tom
val和var变量
示例
给名字变量进行重新赋值为Jim，观察其运行结果
scala> name = "Jim"
<console>:12: error: reassignment to val
name = "Jim"
示例
使用var重新定义变量来保存名字"tom"，并尝试重新赋值为Jim，观察其运行结果
scala> var name:String = "tom"
name: String = tom
scala> name = "Jim"
name: String = Jim
优先使用val定义变量，如果变量需要被重新赋值，才使用var
使用类型推断来定义变量
scala的语法要比Java简洁，我们可以使用一种更简洁的方式来定义变量。
scala> val name = "tom"
name: String = tom
scala可以自动根据变量的值来自动推断变量的类型，这样编写代码更加简洁。
惰性赋值
在企业的大数据开发中，有时候会编写非常复杂的SQL语句，这些SQL语句可能有几百行甚至上千行。这些SQL语句，如果直接加载到JVM中，会有很大的内存开销。如何解决？
当有一些变量保存的数据较大时，但是不需要马上加载到JVM内存。可以使用惰性赋值来提高效率。
lazy val/var 变量名 = 表达式
示例
在程序中需要执行一条以下复杂的SQL语句，我们希望只有用到这个SQL语句才加载它。
"""insert overwrite table adm.itcast_adm_personas
select
a.user_id,
a.user_name,
a.user_sex,
a.user_birthday,
a.user_age,
a.constellation,
a.province,
a.city,
a.city_level,
a.hex_mail,
a.op_mail,
a.hex_phone,
a.fore_phone,
a.figure_model,
a.stature_model,
b.first_order_time,
b.last_order_time,
...
d.month1_hour025_cnt,
d.month1_hour627_cnt,
d.month1_hour829_cnt,
d.month1_hour10212_cnt,
d.month1_hour13214_cnt,
d.month1_hour15217_cnt,
d.month1_hour18219_cnt,
d.month1_hour20221_cnt,
d.month1_hour22223_cnt
from gdm.itcast_gdm_user_basic a
left join gdm.itcast_gdm_user_consume_order b on a.user_id=b.user_id
left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""
参考代码：
scala> lazy val sql = """insert overwrite table adm.itcast_adm_personas
| select
| a.user_id,
....
| left join gdm.itcast_gdm_user_buy_category c on a.user_id=c.user_id
| left join gdm.itcast_gdm_user_visit d on a.user_id=d.user_id;"""
sql: String = <lazy>
三 字符串
scala提供多种定义字符串的方式，将来我们可以根据需要来选择最方便的定义方式。
- 使用双引号
- 使用插值表达式
- 使用三引号
使用双引号
示例
有一个人的名字叫"hadoop"，请打印他的名字以及名字的长度。
scala> println(name + name.length)
hadoop6
scala> var name = "hadoop"
name: String = hadoop
scala> println(name + name.length)
hadoop6
使用插值表达式
scala中，可以使用插值表达式来定义字符串，有效避免大量字符串的拼接。
val/var 变量名 = s"${变量/表达式}字符串"
在定义字符串之前添加s
在字符串中，可以使用${}来引用变量或者编写表达式
示例
请定义若干个变量，分别保存：“zhangsan”、30、“male”，定义一个字符串，保存这些信息。
打印输出：name=zhangsan, age=30, sex=male
scala> val name = "zhangsan"
name: String = zhangsan
scala> val age = 30
age: Int = 30
scala> val sex = "male"
sex: String = male
scala> val info = s"name=${name}, age=${age}, sex=${sex}"
info: String = name=zhangsan, age=30, sex=male
scala> println(info)
name=zhangsan, age=30, sex=male
使用三引号
如果有大段的文本需要保存，就可以使用三引号来定义字符串。例如：保存一大段的SQL语句。三个引号中间的所有字符串都将作为字符串的值。
示例
定义一个字符串，保存以下SQL语句
select
*
from
t_user
where
name = "zhangsan"
打印该SQL语句：
val sql = """select
| *
| from
| t_user
| where
| name = "zhangsan""""
println(sql)
scala> val sql = """select
| *
| from
| t_user
| where
| name = "zhangsan""""
sql: String =
select
*
from
t_user
where
name = "zhangsan"
scala> println(sql)
select
*
from
t_user
where
name = "zhangsan"
四 数据类型与操作符
scala中的类型以及操作符绝大多数和Java一样
| 基础类型 | 类型说明 |
|---|---|
| Byte | 8位带符号整数 |
| Short | 16位带符号整数 |
| Int | 32位带符号整数 |
| Long | 64位带符号整数 |
| Char | 16位无符号Unicode字符 |
| String | Char类型的序列（字符串） |
| Float | 32位单精度浮点数 |
| Double | 64位双精度浮点数 |
| Boolean | true或false |
- scala中所有的类型都使用大写字母开头
- 整形使用Int而不是Integer
- scala中定义变量可以不写类型，让scala编译器自动推断
运算符
| 类别 | 操作符 |
|---|---|
| 算术运算符 | +、-、*、/ |
| 关系运算符 | >、<、==、!=、>=、<= |
| 逻辑运算符 | &&、||、! |
| 位运算符 | &、||、^、<<、>> |
-
scala中没有，++、–运算符
-
与Java不一样，在scala中，可以直接使用
==、!=进行比较，它们与equals方法表示一致。而比较两个对象的引用值，使用eq
示例
有一个字符串"abc"，再创建第二个字符串，值为：在第一个字符串后拼接一个空字符串。
然后使用比较这两个字符串是否相等、再查看它们的引用值是否相等。
参考代码
val str1 = "abc"
val str2 = str1 + ""
str1 == str2
str1.eq(str2)
scala> val str1 = "abc"
str1: String = abc
scala> val str2 = str1 + ""
str2: String = abc
scala> str1 == str2
res3: Boolean = true
scala> str1.eq(str2)
res4: Boolean = false
scala类型层次结构
| 类型 | 说明 |
|---|---|
| Any | 所有类型的父类，,它有两个子类AnyRef与AnyVal |
| AnyVal | 所有数值类型的父类 |
| AnyRef | 所有对象类型（引用类型）的父类 |
| Unit | 表示空，Unit是AnyVal的子类，它只有一个的实例{% em %}() {% endem %} 它类似于Java中的void，但scala要比Java更加面向对象 |
| Null | Null是AnyRef的子类，也就是说它是所有引用类型的子类。它的实例是{% em %}null{% endem %} 可以将null赋值给任何对象类型 |
| Nothing | 所有类型的子类 不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型 |
nothing
def main(args: Array[String]): Unit = {
val c = m3(1,0)
}
def m3(x:Int, y:Int):Int = {
if(y == 0) throw new Exception("这是一个异常")
x / y
}
问题
以下代码是否有问题？
val b:Int = null
scala> val b:Int = null
<console>:11: error: an expression of type Null is ineligible for implicit conversion
val b:Int = null
scala会解释报错：
Null类型并不能转换为Int类型，说明Null类型并不是Int类型的子类
五 条件表达式
条件表达式就是if表达式，if表达式可以根据给定的条件是否满足，根据条件的结果（真或假）决定执行对应的操作。scala条件表达式的语法和Java一样。
有返回值的if
与Java不一样的是，
[!NOTE]
- 在scala中，条件表达式也是有返回值的
- 在scala中，没有三元表达式，可以使用if表达式替代三元表达式
示例
定义一个变量sex，再定义一个result变量，如果sex等于"male"，result等于1，否则result等于0
参考代码
scala> val sex = "male"
sex: String = male
scala> val result = if(sex == "male") 1 else 0
result: Int = 1
块表达式
- scala中，使用{}表示一个块表达式
- 和if表达式一样，块表达式也是有值的
- 值就是最后一个表达式的值
问题
请问以下代码，变量a的值是什么？
scala> val a = {
| println("1 + 1")
| 1 + 1
| }
scala> val a = {
| println("1 + 1")
| 1 + 1
| }
1 + 1
a: Int = 2
六 循环
在scala中，可以使用for和while，但一般推荐使用for表达式，因为for表达式语法更简洁
for表达式
语法
for(i <- 表达式/数组/集合) {
// 表达式
}
简单循环
使用for表达式打印1-10的数字
步骤
- 生成1-10的数字（提示：使用to方法）
- 使用for表达式遍历，打印每个数字
参考代码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)
scala> for(i <- 1 to 10) println(i)
1
2
3
4
5
6
7
8
9
10
嵌套循环
使用for表达式，打印以下字符
*****
*****
*****
步骤
- 使用for表达式打印3行，5列星星
- 每打印5个星星，换行
参考代码
for(i <- 1 to 3; j <- 1 to 5) {print("*");if(j == 5) println("")}
scala> 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)
scala> for(i <- 1 to 10 if i % 3 ==0) println(i)
3
6
9
for推导式
-
将来可以使用for推导式生成一个新的集合（一组数据）
-
在for循环体中，可以使用yield表达式构建出一个集合，我们把使用yield的for表达式称之为推导式
示例
生成一个10、20、30…100的集合
参考代码
// for推导式：for表达式中以yield开始，该for表达式会构建出一个集合
val v = for(i <- 1 to 10) yield i * 10
scala> var v = for(i <- 1 to 10) yield i * 10
v: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
while循环
scala中while循环和Java中是一致的
示例
打印1-10的数字
参考代码
scala> var i = 1
i: Int = 1
scala> while(i <= 10) {
| println(i)
| i = i+1
| }
scala> while(i <= 10) {
| println(i)
| i = i+1
| }
1
2
3
4
5
6
7
8
9
10
七 break和continue
- 在scala中，类似Java和C++的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类似，但有一点不同：
[!NOTE]
实现break是用breakable{}将整个for表达式包起来，而实现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] = {
// 方法体：一系列的代码
}
[!NOTE]
- 参数列表的参数类型不能省略
- 返回值类型可以省略，由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自动推断返回值类型。这样方法定义后更加简洁。
[!DANGER]
定义递归方法，不能省略返回值类型
示例
定义递归方法（求阶乘）
10 * 9 * 8 * 7 * 6 * … * 1
参考代码
scala> def m2(x:Int) = {
| if(x<=1) 1
| else m2(x-1) * x
| }
:13: error: recursive method m2 needs result type
else m2(x-1) * x
scala> def m2(x:Int):Int = {
| if(x<=1) 1
| else m2(x-1) * x
| }
m2: (x: Int)Int
scala> m2(3)
res13: Int = 6