Scala基础(二)

这个章节的内容包括

apply方法

当一个类或者对象有一个主要的用途的时候,apply方法可以提供一种很好的语法糖(syntactic sugar)。

scala> class Foo {}
defined class Foo

scala> object FooMaker {
     |   def apply() = new Foo
     | }
defined module FooMaker

scala> val newFoo = FooMaker()
newFoo: Foo = Foo@5b83f762

或者

scala> class Bar {
     |   def apply() = 0
     | }
defined class Bar

scala> val bar = new Bar
bar: Bar = Bar@47711479

scala> bar()
res8: Int = 0

这样来看实例对象,好像我们是在调用一个方法。后面会详细介绍这个!

对象

对象都是用来保持一个类的单个实例。经常在工厂里用到。

object Timer {
  var count = 0

  def currentCount(): Long = {
    count += 1
    count
  }
}

怎么去使用

scala> Timer.currentCount()
res0: Long = 1

类和对象可以重名。这样的对象被称为“伴随对象(Companion Object)”。我们一般在工厂里使用伴随对象。

这里有个简单的示例,它的作用是使得创建对象实例的时候不需要用‘new’。

class Bar(foo: String)

object Bar {
  def apply(foo: String) = new Bar(foo)
}

函数即对象

在Scala里,我们经常讨论对象-函数编程。它表示什么呢?函数究竟是什么?

函数是一系列的trait。确切地说,有一个参数的函数是Function1 trait的一个实例。这个trait定义了我们之前学到的apply()的语法糖,它允许你像调用函数一样调用对象。

scala> object addOne extends Function1[Int, Int] {
     |   def apply(m: Int): Int = m + 1
     | }
defined module addOne

scala> addOne(1)
res2: Int = 2

在Scala里有Function1到22。为什么是22?这是一个任意的魔数。我从来没有遇到需要22个参数的函数,所以这个数字还是很有效的。

apply的语法糖使得对象和函数的编程能够组合在一起。你可以把对象作为参数进行传递,同时也可以把它们当作函数使用,而实际上函数也只不过是类的实例。

那这样是不是意味着每次你在类里定义一个方法,那么你就会得到Function的一个实例呢?不,类里的方法仅仅是普通的方法。在repl里单独定义的方法才是Function的实例。

类也可以继承函数,然后这些类的实例就可以通过()来调用。

scala> class AddOne extends Function1[Int, Int] {
     |   def apply(m: Int): Int = m + 1
     | }
defined class AddOne

scala> val plusOne = new AddOne()
plusOne: AddOne = 

scala> plusOne(1)
res0: Int = 2

extends Function1[Int,Int]的一种比较好的简写是extends (Int => Int)

class AddOne extends (Int => Int) {
  def apply(m: Int): Int = m + 1
}

你可以通过包来组织你的代码。

package com.twitter.example

在一个文件的顶部声明包,那么这个文件里的所有的东西都是在这个包里。

值和函数不能在类和对象外面。对象对于组织静态函数是很有用的。

package com.twitter.example

object colorHolder {
  val BLUE = "Blue"
  val RED = "Red"
}

现在你可以直接访问里面的成员

println("the color is: " + com.twitter.example.colorHolder.BLUE)

当你在scala repl里定义这个对象时,它会提示什么:

scala> object colorHolder {
     |   val Blue = "Blue"
     |   val Red = "Red"
     | }
defined module colorHolder

上面的信息暗示你scala的设计者把对象设计成为Scala的模块系统的一部分。

模式匹配

Scala中最有用的一个功能。

对值进行匹配

val times = 1

times match {
  case 1 => "one"
  case 2 => "two"
  case _ => "some other number"
}

受保护的匹配

times match {
  case i if i == 1 => "one"
  case i if i == 2 => "two"
  case _ => "some other number"
}

注意我们如何捕获变量’i'里的值。

最后的一条语句中的_是一个通配符;它保证我们能够处理任何输入。否则的话,如果我们传入一个不匹配的值,将会出现runtime error。我们后面会继续讨论这个。

参考 《Effective Scala》中有关于什么时候使用模式匹配</>和模式匹配格式的讨论。《A Tour of Scala》中讲解了模式匹配

针对类型进行匹配

你可以使用match来对不同的类型的值进行不同的处理。

def bigger(o: Any): Any = {
  o match {
    case i: Int if i < 0 => i - 1
    case i: Int => i + 1
    case d: Double if d < 0.0 => d - 0.1
    case d: Double => d + 0.1
    case text: String => text + "s"
  }
}

对类的成员进行匹配

回想一下我们之前的caculator的示例。

我们通过它们的类型来进行归类。

def calcType(calc: Calculator) = calc match {
  case calc.brand == "hp" && calc.model == "20B" => "financial"
  case calc.brand == "hp" && calc.model == "48G" => "scientific"
  case calc.brand == "hp" && calc.model == "30B" => "business"
  case _ => "unknown"
}

噢,这样写太麻烦了。幸运的是Scala提供了一些有用的工具来处理这种场景。

Case Classes

case class可以用来方便地存储和匹配类的内容。你不需要用new来构造它们。

scala> case class Calculator(brand: String, model: String)
defined class Calculator

scala> val hp20b = Calculator("hp", "20b")
hp20b: Calculator = Calculator(hp,20b)

case class会自动根据传入的参数生成equlity和toString方法。

scala> val hp20b = Calculator("hp", "20b")
hp20b: Calculator = Calculator(hp,20b)

scala> val hp20B = Calculator("hp", "20b")
hp20B: Calculator = Calculator(hp,20b)

scala> hp20b == hp20B
res6: Boolean = true

case class可以像正常类一样拥有方法。

通过Case Class来进行模式匹配

case class的设计就是为了进行模式匹配。我们来通过它简化之前的calculator 归类程序。

val hp20b = Calculator("hp", "20B")
val hp30b = Calculator("hp", "30B")

def calcType(calc: Calculator) = calc match {
  case Calculator("hp", "20B") => "financial"
  case Calculator("hp", "48G") => "scientific"
  case Calculator("hp", "30B") => "business"
  case Calculator(ourBrand, ourModel) => "Calculator: %s %s is of unknown type".format(ourBrand, ourModel)
}

最后一行的另外一种写法

  case Calculator(_, _) => "Calculator of unknown type"

或者我们不用把它当作Calculator来处理。

  case _ => "Calculator of unknown type"

也或者,我们可以用另外的名字来绑定这个匹配。

  case c@Calculator(_, _) => "Calculator: %s of unknown type".format(c)

异常

在Scala里,异常的处理是通过一个使用模式匹配的try-catch-finally语法进行处理的。

try {
  remoteCalculatorService.add(1, 2)
} catch {
  case e: ServerIsDownException => log.error(e, "the remote calculator service is unavailble. should have kept your trustry HP.")
} finally {
  remoteCalculatorService.close()
}

try也是面向表达式的

val result: Int = try {
  remoteCalculatorService.add(1, 2)
} catch {
  case e: ServerIsDownException => {
    log.error(e, "the remote calculator service is unavailble. should have kept your trustry HP.")
    0
  }
} finally {
  remoteCalculatorService.close()
}

这个并不是一种很好的编码方式,而只是try-catch-finally返回表达式的一个示例,正如Scala里其他的一样。

Finally里的语句会在异常处理完之后执行,并且它不是表达式的一部分。

 

英文原文: Scala School,翻译:ImportNew - 朱伟杰

本文地址:http://www.importnew.com/3578.html

【如需转载,请在正文中标注并保留原文链接、译文链接和译者等信息,谢谢合作!】

 

关于作者: 朱伟杰

Java开发工程师,业余翻译

查看朱伟杰的更多文章 >>



相关文章

发表评论

Comment form

(*) 表示必填项

还没有评论。

跳到底部
返回顶部