Scala实践5

一、Scala的层级

1.1类层级

Scala中，Any是所其他类的超类，在底端定义了一些有趣的类NULL和Nothing，是所有其他类的子类。

根类Any有两个子类：AnyVal和AnyRef。其中AnyVal是Scala里每个内建值类的父类

scala> new Int

<console>:12: error: class Int is abstract; cannot be instantiated

       new Int

1.2底层类型

在Scala类层级中，可看到scala.Null和scala.Nothing。它们是用统一的方式处理Scala面对对象类型的某些“边界情况”的特殊类型。

Null类是null引用对象的类型，它是每个引用类的子类，Null不兼容值类型，例如，不能把null值赋给整数变量：

scala> val i: Int = null

<console>:11: error: an expression of type Null is ineligible for implicit conversion

       val i: Int = null

                    ^

　　Nothing类型在Scala的类层级的最底层，它是任何其他类型的的子类型。Nothing的一个用处是它标明了不正常的终止。例如Scala的标准库中的Predef对象有一个error方法，如下定义：

def error(message:Sring):Nothing=

  throw new RuntimeException(message)

error 的返回类型是Nothing，告诉用户方法不是正常返回（是抛出异常）。因为Nothing是任何类的子类，所有可以灵活使用向error这样的方法，例如：

scala> def error(message:String):Nothing =

     |  throw new RuntimeException(message)

error: (message: String)Nothing

scala> def divide(x:Int,y:Int):Int=

     | if(y!=0)  x/y  else error("can't divide by zero")

divide: (x: Int, y: Int)Int

scala> divide(7,2)

res5: Int = 3

scala> divide(7,0)

java.lang.RuntimeException: can't divide by zero

  at .error(<console>:12)

  at .divide(<console>:13)

  ... 28 elided

scala>

二、函数和闭包

2.1方法

定义函数最通用是方法是作为某个对象的成员。这种函数被称为方法，作为例子：

 import scala.io.Source

  object LongLines{

     def processFile(filename:String,width:Int){

     val source = Source.fromFile(filename)

 for(line<-source.getLines)

  processFile(filename,width,line)

  }

 private def processFile(filename:String,width:Int,line:String){

  if(line.length>width)

    println(filename+":"+line.trim)

  }

  }

  object FileLongLines{

     def main(args:Array[String]){

   val width=args(0).toInt

   for(arg<-args.drop(1))

    LongLines.processFile(arg,width)

  }

}

2.2本地函数

上节processFile方法的建立演示了函数式编程的设计原则，问题是这些帮助函数的名称可能污染程序的命名空间。

Scala中的解决方法：一种是私有方法。

另一种是把函数定义在别的函数内。就好像本地变量那样，这种本地函数仅在包含它的代码块中可见。举例：

 def processFile(filename:String,width:Int){

        def processLine(filename:String,width:Int,line:String){

  if(line.length>width)

    println(filename+":"+line.trim)

  }

     val source = Source.fromFile(filename)

 for(line<-source.getLines)

  processFile(filename,width,line)

  }

例子中通过私有方法转化为局部方法，processLine的定义放在processFile定义里，作为本地函数，processLine的范围局限在processFile之内，外部无法访问。

带局部processLine方法的LongLines

 def processFile(filename:String,width:Int){

        def processLine(line:String){

  if(line.length>width)

    println(filename+":"+line.trim)

  }

     val source = Source.fromFile(filename)

 for(line<-source.getLines)

  processFile(line)

  }

这种对外层函数入参的直接使用是Scala里通用的嵌套思想的平常但也很有用

2.3头等函数

Scala的函数是头等函数，不仅可以定义和调用函数，还可以把它们写成匿名的字面量，并把他们作为值传递，

函数字面量被编译进类，并在运行期间实例化为函数值。因此函数字面量和值的区别在于函数字面量存在于原代码，而函数值作为对象存在于运行期。这个区别很像类（源代码）和对象（运行期）之间的关系。

=>指明这个函数把左边的东西（任何整数x）转化为右边的东西。所有，这个函数可以把任何整数x映射为x+1。

函数值是对象，所有如果你愿意，可以将其存入变量。它们也是函数，所有你可以使用通常的括号函数调用它们。

scala> var increase=(x:Int)=>x+1

increase: Int => Int = $$Lambda$1149/268616862@62eb918

scala> increase(4)

res7: Int = 5

2.4部分应用函数

scala> val someNumbers=List(-11,-10,-5,0,5,10)

someNumbers: List[Int] = List(-11, -10, -5, 0, 5, 10)

scala> someNumbers.foreach(x:Int)

<console>:13: error: not found: value x

       someNumbers.foreach(x:Int)

                           ^

<console>:13: error: type mismatch;

 found   : Int

 required: Int => ?

       someNumbers.foreach(x:Int)

                            ^

scala> someNumbers.foreach(x:Int)=>println(x)

<console>:1: error: ';' expected but '=>' found.

       someNumbers.foreach(x:Int)=>println(x)

                                 ^

scala> someNumbers.foreach((x:Int)=>println(x))

-11

-10

-5

0

5

10

scala> someNumbers.filter((x:Int)=>x>0)

res10: List[Int] = List(5, 10)

scala> someNumbers.filter((x)=>x>0)

res11: List[Int] = List(5, 10)

scala> someNumbers.filter(x=>x>0)

res12: List[Int] = List(5, 10)

scala> someNumbers.filter(_>0)

res13: List[Int] = List(5, 10)

scala> val f=_+_

<console>:11: error: missing parameter type for expanded function ((x$1: <error>, x$2) => x$1.$plus(x$2))

       val f=_+_

             ^

<console>:11: error: missing parameter type for expanded function ((x$1: <error>, x$2: <error>) => x$1.$plus(x$2))

       val f=_+_

               ^

scala> val f=(_:Int)+(_:Int)

f: (Int, Int) => Int = $$Lambda$1180/712034517@6d0ef6dc

scala> f(2,6)

res14: Int = 8

部分应用函数是一种表达式，不需要提供需要的所有参数。代之以提供部分，或者不提供所需参数。

闭包

scala> (x:Int)=>x+more

<console>:12: error: not found: value more

       (x:Int)=>x+more

                  ^

//声明more

scala> val more=1

more: Int = 1

scala> val addMore=(x:Int)=>x+more

addMore: Int => Int = $$Lambda$1206/2005145495@773eb14c

scala> addMore(5)

res21: Int = 6

依照这个函数字面量在运行时创建的函数值（对象）被称为闭包

重复函数

Scala中，可以指明函数的最后一个参数是重复的，从而允许客户向函数传入可变长度参数列表。想要标注一个重复参数，可在参数类型之后放一个星号。如：

scala> def echo(args:String*)=

     |   for (arg<-args) println(arg)

echo: (args: String*)Unit

scala> echo()

scala> echo("one")

one

scala> echo("one","hello!")

one

hello!

函数内部，重复函数的类型是声明参数类型的数组。因此，echo函数被声明为类型“String*”的args的类型实际上是Array[String]。然而，如果你有一个合适的数组，并尝试把它当作重复参数传入，将得到编译器错误：

scala> val arr=Array("What's","up","doc?")

arr: Array[String] = Array(What's, up, doc?)

scala> echo(arr)

<console>:14: error: type mismatch;

 found   : Array[String]

 required: String

       echo(arr)

            ^

要实现这个做法，需要在数组参数后添加一个冒号和一个_*,如下：

scala> echo(arr:_*)

What's

up

doc?

巴特西