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()
    }
  }