Scala（二）——基础语法（与Java的区分）和函数式编程
Scala快速入门（二）
一、键盘输入
关于基本类型的运算，以及复制运算，条件运算，运算符等知识，均和Java语言一样，这里不过多叙述。
val name = StdIn.readLine()
StdIn是一个伴生对象，所以，可以直接进行使用点进行调用。
举例：
object VarDemo {
def main(args: Array[String]): Unit = {
Test.test()
}
}
object Test{
def test(): Unit ={
println("test")
}
}
在这个案例中，我们知道了object伴生对象中的方法，相当于静态方法，可以直接调用，在第一节中，我们依旧可以知道，这个反编译后就是一个静态方法。
我们在源码中，可以看到，这个StdIn集成了一个StdIn实际上用了trait修饰，trait相当于Java中的Interface。请看下个例子。
object main {
def main(args: Array[String]): Unit = {
VarDemo.inter()
VarDemo.another()
}
}
object VarDemo extends Test {
def another(): Unit ={
println("another")
}
}
trait Test{
def inter(): Unit ={
println("inter")
}
}
在这个案例中，我们知道了，trait修饰的类中的方法就类似接口，伴生类继承这个接口，也可以直接用点调用中间的方法
其他从键盘读入的方法
val a=StdIn.readLine()
val b=StdIn.readInt()
val c=StdIn.readDouble()
二、分支流程
if语句和Java完全一样
循环控制
1.for(变量<-start to end)
for(i<-1 to 3){
println(i)
}
i 从1到3，双闭区间
2.for循环的集合遍历（类似Java中的for each循环）
var list =List("1",2,3.0)
for(item<-list)
println(item)
3.for(变量<-start until end)
for(i<-1 until 3){
println(i)
}
i从1到3，左闭右开
4.for循环守卫，for循环可以加附加条件
for(i<-1 to 3 if i != 2)
println(i)
注：continue和break在scala不存在
5.for循环引入变量，通过分号可以隔开，在for循环内嵌入语句
for(i<-1 to 3 ; j=5-i)
println(j)
6.for循环返回值，将1-10保存在一个Vector并返回
val res=for(i<-1 to 10) yield i
println(res)
val res=for(i<-1 to 10) yield {
if(i % 2 == 0){
i
}else{
"不是偶数"
}
}
println(res)
7.使用Range(start,end,step)进行遍历
for(i<-Range(1,10,3)){
println(i)
}
While循环和do...while循环（不推荐使用）
语法和Java一样
科普：scala不存在break，如果我想break掉，应该怎么做？
Scala在语言设计上没有break，但是，在Break类中有一个Break.break()来进行异常退出，作者认为，break和continue不属于面向对象和函数式编程，所以在设计语法的时候，没有把这两个字加上去
举例：
var i=1
breakable(
while(true){
println(i)
i+=1
if(i==3) {
break()
}
}
)
println("break了")
三、函数式编程
什么是函数式编程，类似将一个函数本身传给一个变量。下面是函数式编程的一个小例子。
var fun=(a:Int,b:Int)=>a+b
println(fun(1,2))
1.函数的定义
def 函数名（参数名：参数类型，参数名：参数类型）{
return 返回值
}
object o{
def main(args: Array[String]): Unit = {
println(cacu(1,2,'-'))
}
def cacu(a:Int,b:Int,op:Char):Int={
if(op=='+') return a+b;//是否写return都ok
else if(op=='-') a-b;
else 0
}
}
我们如果不确定返回类型是什么，可以把：Int去掉，这样可以写成：
def cacu(a:Int,b:Int,op:Char)={
if(op=='+') a+b;//是否写return都ok
else if(op=='-') a-b;
else "op输入错误"
}
注意：在这种情况下，不能使用return
2.递归函数
递归函数，未执行之前无法推断出结果类型，所以必须明确返回值类型
3.可变参数
可变参数用*表示，加载类型的后面
案例：
def main(args: Array[String]): Unit = {
println(sum(10,20,30,40))
}
def sum(n:Int,args:Int*):Int ={
var s=n
for(item<-args){
s+=item
}
return s
}
查看下面代码是否正确
def f1="steve yu"
println(f1)
正确，定义一个函数f1，返回steve yu
4.过程函数书写
def f():Unit={
函数体
}
这个可以简写为
def f(){
函数体
}
5.惰性函数（懒加载）
函数在使用的时候进行加载
object Test {
def main(args: Array[String]): Unit = {
lazy val a=pr();//调用的时候不加载
println("-"*20);
println("."*20);
a.hashCode()//使用的时候加载
}
def pr(): Unit ={
println("lazy function")
}
}
该函数的执行结果：
--------------------
....................
lazy function
我们要注意的是，惰性函数在使用过程中，只能修饰val，不能修饰var
四、异常处理
scala的try catch和java一样
作业题：
1.函数可以没有返回值案例，编写一个函数，从终端输入一个数，打印一个金字塔。
object Test {
def main(args: Array[String]): Unit = {
val line=StdIn.readInt()
goldenTower(line)
}
def goldenTower(column:Int): Unit ={
for(value<-Range(0,column,1)){
println(" "*(20-(2*value+1)/2)+"*"*(2*value+1))
}
}
}
2.编写一个函数，从终端输入1-9，打印99乘法表
def main(args: Array[String]): Unit = {
val line=StdIn.readInt()
multiTable(line)
}
def multiTable(column:Int): Unit ={
for(i<- 1 to column){
for(j<-1 to i){
print(s"$j*$i="+j*i+" "*5)
}
println()
}
}
