Scala Language Programing Guide(章节二)

Scala Language Programing Guide

作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育

变量

Scala语言中没有原始数据类型，这一点和Java语言不同，在Scala中一切且对象。以下是Scala语言中常见类型和类型间的继承关系。

在Java中常见的基本类型在Scala中都被剔除了,Scala将值类型和引用类型分离。所有的数值变量类型都是 AnyVal的子类，这些变量的值都有字面值。对于一些对象类型的变量都是 AnyRef的子类。对于 AnyRef类下的变量（除String类型），一般不允许直接赋值字面量，都需要借助 new关键创建。

变量声明

Scala语言是一种可以做类型自动推断的强类型的编程语言。变量的类型可通过编译器在编译的时候推断出最终类型。因此Scala中声明一个变量主需要告知编译器该变量的值是常量还是变量，例如：例如声明一个变量使用var即可，如果声明的是一个常量使用val关键字。因此Scala中变量声明的语法如下：

var|val 变量名[:类型] = 变量值[:类型]

例如：

scala> var i:Int=1:Int
i: Int = 1

scala> var j=1:Byte
j: Byte = 1

scala> var k=1
k: Int = 1

可以看出Scala在解释的代码的时候，可以根据字面量的值自动识别类型，这一点和Java是非常类似的,例如

scala> var b = true
b: Boolean = true

scala> var name = "zhangsan"
name: String = zhangsan

scala> var c='中'
c: Char = 中

scala> c = 97
c: Char = a

scala> print(c)
a

因此可以看出在使用Scala编程过程中，编译器是可以自动推断出AnyVal类型的变量，因此用户在声明AnyVal类型的变量的时候，无需指定变量类型。

数值转换

scala> var i=1
i: Int = 1

scala> var b:Byte=i.asInstanceOf[Byte]
b: Byte = 1

scala> var b:Byte=i.toByte()
<console>:12: error: Byte does not take parameters
       var b:Byte=i.toByte()
                          ^

scala> var b:Byte=i.toByte
b: Byte = 1

用户可以使用asInstanceOf[类型]这种方式在数值间转换。该方式只适合类型兼容的时候使用，如果类型不兼容可以使用toInt、toChar、…等可以将常规参数自动转换为数值类型。

scala> var sex="true"
sex: String = true

scala> sex.toBoolean
res2: Boolean = true

scala> sex.asInstanceOf[Boolean]
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Boolean
  at scala.runtime.BoxesRunTime.unboxToBoolean(BoxesRunTime.java:85)
  ... 32 elided

数组

Scala提供了简便的声明和使用方式，例如声明一个Int类型的数组，则使用如下：

scala> val array:Array[Int] = Array(1,2,3)

scala> array(0)
res10: Int = 1

可以通过length和size方法获取数组长度。

元组

元组是在Scala编程语言中的一种特殊变量，该变量可以组合任意几种类型的变量，构建一个只读的变量类型。访问元组的成员可以使用_元素下标访问。

scala> var t:(String,Int)=("zhangsan",10)
t: (String, Int) = (zhangsan,10)

scala> print(t)
(zhangsan,10)
scala> t._1
res11: String = zhangsan

scala> t._1="wangwu"
<console>:12: error: reassignment to val
       t._1="wangwu"
           ^

scala> var t=("zhangsan",18,true)
t: (String, Int, Boolean) = (zhangsan,18,true)

scala>

Scala所有的变量在声明时可以省略类型，并不意味之Scala是一种弱类型的编程语言，程序一旦编译后，类型固定，不可以更改。

分支循环

条件分支

if分支语法和Java语言中的语法基本保持一致，语法如下：

if(条件1){ 
}else if(条件2){   
}else{   
}

根据age参数计算msg的取值，可以看出在Scala语法中if分支可以作为变量的赋值语句。可以将分支中返回的结果作为返回值，在利用分支做赋值的时候，不可以给return关键字，系统会自动将代码块最后一行的结果作为返回值。

scala> var age=18
age: Int = 18

scala>    var msg=if(age<18){
     |     "青少年"
     |    }else if(age > 30){
     |     "青年"
     |    }else{
     |     "你老了"
     |   }
msg: String = 你老了

while/do-while

while/do-while循环控制和Java语言中的语法基本保持一致，语法如下：

while(条件){
}

例如按照循环变量i,打印变量i的值

scala> var i=5
i: Int = 5

scala>    while (i!=0){
     |       println("i:\t"+i)
     |       i -= 1
     |    }
i:      5
i:      4
i:      3
i:      2
i:      1

使用do-while实现类似

scala> var i=5
i: Int = 5

scala>    do{
     |      println("i:\t"+i)
     |      i -= 1;
     |    }while(i!=0)
i:      5
i:      4
i:      3
i:      2
i:      1

使用for循环打印9*9乘法表

scala> var i=1
i: Int = 1

scala>     while (i <= 9){
     |       var j=1;
     |       while (j<=i){
     |         if(j<i){
     |           print(s"$i*$j="+(i*j)+"\t")
     |         }else{
     |           println(s"$i*$j="+(i*j)+"\t")
     |         }
     |         j +=1
     |       }
     |       i +=1
     |     }
1*1=1
2*1=2   2*2=4
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12  4*4=16
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

Break

Scala 语言中默认是没有 break 语句，但是在 Scala 2.8 版本后可以使用另外一种方式来实现 break 语句。当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。Scala 中 break 的语法有点不大一样，格式如下：

scala> var array= Array(1,2,3,4,5,6,7)
array: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7)

scala>     var loop=new Breaks
loop: scala.util.control.Breaks = scala.util.control.Breaks@7902b006

scala>     var i=0
i: Int = 0

scala>     loop.breakable(while (i < array.length){
     |       print(array(i)+"\t")
     |       i += 1
     |       if(i==3) loop.break()
     |     })
1       2       3

for循环

数组遍历

for循环在Scala中的使用最为丰富，除去正常的循环控制，还可以做一些简单集合的运算。

scala> val array:Array[Int] = Array(1,2,3)
array: Array[Int] = Array(1, 2, 3)

scala>     for(i <- array){
     |       println(i)
     |     }
1
2
3

使用变量i和j打印9*9乘法表

scala> for(i<- 1 to 9 ; j <- 1 to i){
     |     print(s"$i*$j="+(i*j)+"\t")
     |     if(i==j) println()
     | }
1*1=1
2*1=2   2*2=4
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12  4*4=16
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

数组计算

scala> var a1=Array(1,2,3,4,5)
a1: Array[Int] = Array(1, 2, 3, 4, 5)

scala>     var a2= for(i <- a1) yield i*3
a2: Array[Int] = Array(3, 6, 9, 12, 15)

scala>     var a3= for(i <- a1;if(i%2==0)) yield i
a3: Array[Int] = Array(2, 4)

模式匹配

模式匹配是检查某个值（value）是否匹配某一个模式的机制，一个成功的匹配同时会将匹配值解构为其组成部分。它是Java中的switch语句的升级版，同样可以用于替代一系列的 if/else 语句。

数值匹配

根据参数值做匹配，如果匹配到对应的值，则返回对应的值，其中_表示默认匹配。

scala> import scala.util.Random
import scala.util.Random

scala> val x: Int = Random.nextInt(10)
x: Int = 4

scala>     var result=x match {
     |       case 0 => "zero"
     |       case 1 => "one"
     |       case 2 => "two"
     |       case _ => "many"
     |     }
result: String = many

类型匹配

使用match-case可以根据类型做匹配，这一点在后续的使用非常常见。

val array = Array(1,"zhangsan",true,1000.0)
val x:Int= Random.nextInt(array.length)
var result=array(x) match {
    case id:Int => id
    case name:String => name
    case sex:Boolean => sex
    case salary:Double => salary
}

函数

函数声明

def functionName ([参数列表]) : [return type]

标准函数

def sum(x:Int,y:Int):Int={
  return x+y
}
//可以尝试省略返回值类型
def multi(x:Int,y:Int)={
  x*y
}
def sayHi(name:String):Unit={
  println("hi~ "+name)
}

可变长参数

def sum(args:Int*):Int={
    var sum:Int=0
    for(agr <- args){
        sum+=agr
    }
    return sum
}

参数默认值

def main(args: Array[String]) {
        sayHi("ww")
        sayHi()
 }
def sayHi(name:String="zhangsan"):Unit={
      println("hi~ "+name)
}

参数命名

def main(args: Array[String]) {
  saySomething(name="zhangsan",welcome="你好")
}
def saySomething(welcome:String,name:String){
  println(welcome+" ! "+ name)
}

内嵌函数

object Test {
    def main(args: Array[String]) {
        var res = factorial(5)
        println(res)
    }
    //计算阶乘
    def factorial(x:Int)={
        def mulit(i:Int):Int={ //该函数存在递归，必须申明返回值类型
            if(i > 0){
                i*mulit(i-1)
            }else{
                1
            }
        }
        mulit(x)
    }
}

柯里化(Currying)

在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数的函数，并且返回接受余下的参数且返回结果的新函数的技术。

def main(args: Array[String]) {
 println(sum1(1)(2))
}
def sum(x:Int,y:Int):Int={
 return x+y
}
def sum1(x:Int)(y:Int):Int={
 return x+y
}
def sum2(x:Int)=(y:Int)=>{
   x+y
}

匿名函数

Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。使用匿名函数后，我们的代码变得更简洁了。

(x:Int,y:Int) => {x+y}

更多精彩内容关注