Scala--基础知识和语法
Scala–基础知识和语法
文章目录
- Scala--基础知识和语法
- 一：基础知识
- 1. scala和java的关系
- 2. Scala解释器
- 二：基础语法
- 1. scala变量的定义
- 2. scala的数据类型
- 3. scala的流程控制结构
- 3.1 if表达式
- 3.2 while表达式
- 3.3 do while 表达式
- 3.5 for循环
- 4 异常控制
一：基础知识
1. scala和java的关系
1、都是基于JVM虚拟机运行的
Scala编译之后的文件也是.class，都要转换为字节码，然后运行在JVM虚拟机之上。
2、Scala和Java相互调用
在Scala中可以直接调用Java的代码，同时在Java中也可以直接调用Scala的代码
3、Java 8 VS Scala
1）Java 8（lambda）没有出来之前，Java只是面向对象的一门语言，但是Java 8出来以后，Java就是一个面向对象和面向函数的混合语言了。
2）首先我们要对Scala进行精确定位，从某种程度上讲，Scala并不是一个纯粹的面向函数的编程语言，有人认为 Scala是一个带有闭包的静态面向对象语言），更准确地说，Scala是面向函数与面向对象的混合。
3）Scala设计的初衷是面向函数FP，而Java起家是面向对象OO，现在两者都是OO和FP的混合语言，是否可以这么认为：Scala = FP + OO，而Java = OO+ FP？
由于面向对象OO和面向函数FP两种范式是类似横坐标和纵坐标的两者不同坐标方向的思考方式，类似数据库和对象之间的不匹配阻抗关系，两者如果结合得不好恐怕就不会产生1+1>2的效果。
面向对象是最接近人类思维的方式，而面向函数是最接近计算机的思维方式。如果你想让计算机为人的业务建模服务，那么以OO为主；如果你希望让计算机能自己通过算法从大数据中自动建模，那么以FP为主。所以，Java可能还会在企业工程类软件中占主要市场，而Scala则会在科学计算大数据分析等领域抢占Java市场，比如Scala的Spark大有替代Java的Hadoop之趋势。
2. Scala解释器
Scala解释器读到一个表达式，对它进行求值，将它打印出来，接着再继续读下一个表达式。这个过程被称做读取read–求值eval–打印print–循环loop，即：REPL。
从技术上讲，scala程序并不是一个解释器。实际发生的是，你输入的内容被快速地编译成字节码，然后这段字节码交由Java虚拟机执行。正因为如此，大多数scala程序员更倾向于将它称做“REPL”
二：基础语法
1. scala变量的定义
scala的变量定义分为两种方式，分别需要使用关键字val和var。
-
val
val a = 3
-
var
var a = 3
val和var都可以用来定义变量，唯一的区别就在于，val定义的变量是不可变，而var定义的变量是可变的。不可变的量确实类似常量（被final修饰的变量），但不叫常量，只能叫不可变量的量。
在今后的开发过程中，能使用val就使用val，var尽量不用，因为scala编程的特点，是在创建变量的时候可以省略数据类型，val有助于进行类型的推断。var在操作过程中不利于变量的类型。
scala> val c = 4 c: Int = 4 scala> c = 5:12: error: reassignment to val c = 5 一个完整的变量的定义如下：
val a:Int = 3
其中val为变量修饰符，a为变量名，Int为a的数据类型，其中需要将变量名和数据类型使用:连接，=右侧为变量的值。
2. scala的数据类型
说明：scala拥有和java一样的数据类型，和java的数据类型的内存布局完全一致，精度也完全一致。需要说明一点的是Any和AnyRef，其中Any是对象的超类，AnyRef是类的超类，实例/对象是类的具体化。
3. scala的流程控制结构
3.1 if表达式
scala中的if表达式，基本和java中的if表达式一模一样，唯一的区别就是scala中的if、if-else、if-elseif-else有返回值！
scala> val ret = if(x < 4) 1 else -1
ret: Int = -1
scala> val ret = if(x < 4) 1 else "afff"
ret: Any = afff
记住：scala中任意的表达式，都有返回值。
如果else丢失了
if（x>0） 1
那么有可能if语句没有输出值，但是在Scala中，每个表达式都有值，这个问题的解决方案是引入一个Unit类，写作(),不带else语句的if语句等同于if(x>0) 1 else ()
表达式的最后一句话，最为表达式的返回值返回。
var f = 3
var n = 10
var m = 1
val d = if(n < 18){f = f + n ; m = m +n ; f+m}
==>d = 24
3.2 while表达式
/*
while --->
1 + .... + 10
java:
int sum = 0;
int n = 1;
while(n <= 10) {
sum += n;
n++;
}
sop();
*/
object _1WhileDemo {
def main(args:Array[String]): Unit = {
var sum = 0
var n = 1
while(n <= 10) {
sum += n
n += 1
}
println("sum= " + sum)
}
}
注意：error: value ++/-- is not a member of Int
scala中不能直接对一个变量执行自增/减，++/–是scala集合的一个函数。
3.3 do while 表达式
object _2DoWhileDemo {
def main(args:Array[String]): Unit = {
var sum = 0
var n = 1
do {
sum += n
n += 1
}while(n <= 10)
println("sum= " + sum)
}
}
循环练习
登录用户名密码的游戏：三次机会，从控制台输入输入用户名密码，如果成功登录，返回登录成功，失败，则反馈错误信息！
object _3DoWhileTest {
def main(args:Array[String]): Unit = {
val dbUserName = "pgone"
val dbPassword = "lxl"
var count = 3
do {
var inputUser = readLine("请输入您的姓名：")
var inputPwd = readLine("请输入您的密码：")
if(dbUserName == inputUser && dbPassword == inputPwd) {
//println("欢迎光临：" + inputUser)
println(s"欢迎光临：${inputUser}")
count = -1
} else {
println(s"用户名密码有误，还有${count}次机会，请重输入：")
count -= 1
}
} while(count >= 0)
}
}
####3.4 循环的终止
在java中终止循环有关键字，continue,break,return,但是在scala中没有前两者continue和break。该如何终止循环呢？
有三种方式来结束循环：
1. 使用一个boolean变量来控制循环的结束
-
使用循环结束的条件来进行控制，比如上例中的count >= 0
-
还可以使用breakable函数体来进行控制
import scala.util.control.Breaks._ object _4BreakableDemo { def main(args:Array[String]): Unit = { var sum = 0 var n = 1 breakable { do { sum += n n += 1 if(n > 6) break }while(n <= 10) } println("sum= " + sum) } }
3.5 for循环
在java中有2中写法，普通的for循环for(变量;条件;自增或自减){循环体} or for(类型 变量 : 集合) {}。
scala中的for循环该如何定义呢？
scala中并没有像java中普通for循环的语法结构，更像是高级for循环。
for (变量 <- 集合) {
}
将上述的while循环使用for循环改写
object _5ForDemo {
def main(args:Array[String]): Unit = {
var sum = 0
for(n <- 1 to 10 reverse) {
println(n)
}
//println("sum= " + sum)
}
}
说明：添加reverse主要就是向进行循环的反转
####3.6 循环的嵌套
object _6ForDemo {
def main(args:Array[String]): Unit = {
for(y <- 1 until 5) {
for(x <- 1 to 5) {
print("*")
}
println
}
println("-----------^~^----------")
for(y <- 1 until 5; x <- 1 to 5) {
print("*")
if(x == 5)
println
}
/*
*
**
***
****
*/
println("-----------^~^----------")
for(x <- 1 to 5; y <- 1 to 5) {
if(y <= x)
print("*")
if(x == y)
println
}
println("-----------^_^----------")
for(x <- 1 to 5; y <- 1 to 5 if y <= x) {
print("*")
if(x == y)
println
}
}
}
练习题：9*9乘法口诀表。
for(x <- 1 to 9; y <- 1 to 9 if y <= x) {
print(y+"*"+x+"="+(x*y)+"\t")
if(x == y)
println
}
4 异常控制
scala的异常体系，在很大程度上沿用java的异常体系的，只不过在书写结构上略有差异。
val i = 1 / 0
println("i= " + i)
上述代码，在执行过程中出现异常：
java.lang.ArithmeticException: / by zero
在java中学习了两种异常的处理方式：throws和try-catch。throws和java中的一模一样，将异常转交给调用者进行处理。try-catch则意味着自己要进行处理，但是编写的方式和java不一样。
import scala.io._
object _7ExceptionDemo {
def main(args:Array[String]): Unit = {
try {
lazy val line = Source.fromFile("E:/data/hello1.txt").mkString
println(line)
val ii = Integer.valueOf("abc")
val i = 1 / 0
println("i= " + i)
} catch {// 模式匹配
case e: ArithmeticException => {
println("ArithmeticException==>" + e.getMessage)
}
case e: NumberFormatException => {
println("NumberFormatException===>" + e.getMessage)
}
case e:RuntimeException => {
println("RuntimeException===>" + e.getMessage)
}
case _ => {
println("通用的处理~")
}
}
}
}
说明：上面的案例中，更进一步的学习了一个关键字lazy(懒加载)，被lazy所修饰的变量，只有当第一次被使用的时候才会进行初始化，没有使用之前只是记录了存在，检查语法结构是否正确。可以节省一定的资源空间。