码迷，mamicode.com
首页 > 其他好文 > 详细

【转】Scala基础知识

时间：2016-09-13 01:27:41      阅读：303      评论：0      收藏：0      [点我收藏+]

标签：

原文地址、续

课程内容:

  • 关于这节课
  • 表达式
  • 值
  • 函数
  • 类
  • 继承
  • 特质
  • 类型
  • apply方法
  • 单例对象
  • 函数即对象
  • 包
  • 模式匹配
  • 样本类
  • try-catch-finally



关于这节课
最初的几个星期将涵盖基本语法和概念，然后我们将通过更多的练习展开这些内容。
有一些例子是以解释器交互的形式给出的，另一些则是以源文件的形式给出的。
安装一个解释器，可以使探索问题空间变得更容易。

为什么选择 Scala?
·表达能力
    ·函数是一等公民
    ·闭包
·简洁
    ·类型推断
    ·函数创建的文法支持
·Java互操作性
    ·可重用Java库
    ·可重用Java工具
    ·没有性能惩罚

Scala 如何工作?
·编译成Java字节码
·可在任何标准JVM上运行
    ·甚至是一些不规范的JVM上，如Dalvik
    ·Scala编译器是Java编译器的作者写的


用 Scala 思考
Scala不仅仅是更好的Java。你应该用全新的头脑来学习它，你会从这些课程中认识到这一点的。

启动解释器
使用自带的sbt console启动。
  1. $ sbt console

  3. [...]

  5. Welcome to Scala version 2.8.0.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_20).
  6. Type in expressions to have them evaluated.
  7. Type :help for more information.

  9. scala>
复制代码

表达式
  1. scala> 1 + 1
  2. res0: Int = 2
复制代码
res0是解释器自动创建的变量名称，用来指代表达式的计算结果。它是Int类型，值为2。
Scala中（几乎）一切都是表达式。

值
你可以给一个表达式的结果起个名字赋成一个不变量（val）。
  1. scala> val two = 1 + 1
  2. two: Int = 2
复制代码
你不能改变这个不变量的值.

变量
如果你需要修改这个名称和结果的绑定，可以选择使用var。
  1. scala> var name = "steve"
  2. name: java.lang.String = steve

  4. scala> name = "marius"
  5. name: java.lang.String = marius
复制代码


函数
你可以使用def创建函数.
  1. scala> def addOne(m: Int): Int = m + 1
  2. addOne: (m: Int)Int
复制代码
在Scala中，你需要为函数参数指定类型签名。
  1. scala> val three = addOne(2)
  2. three: Int = 3
复制代码
如果函数不带参数，你可以不写括号。
  1. scala> def three() = 1 + 2
  2. three: ()Int

  4. scala> three()
  5. res2: Int = 3

  7. scala> three
  8. res3: Int = 3
复制代码

匿名函数
你可以创建匿名函数。
  1. scala> (x: Int) => x + 1
  2. res2: (Int) => Int = <function1>
复制代码
这个函数为名为x的Int变量加1。
  1. scala> res2(1)
  2. res3: Int = 2
复制代码
你可以传递匿名函数，或将其保存成不变量。
  1. scala> val addOne = (x: Int) => x + 1
  2. addOne: (Int) => Int = <function1>

  4. scala> addOne(1)
  5. res4: Int = 2
复制代码
如果你的函数有很多表达式，可以使用{}来格式化代码，使之易读。
  1. def timesTwo(i: Int): Int = {
  2.   println("hello world")
  3.   i * 2
  4. }
复制代码
对匿名函数也是这样的。
  1. scala> { i: Int =>
  2.   println("hello world")
  3.   i * 2
  4. }
  5. res0: (Int) => Int = <function1>
复制代码
在将一个匿名函数作为参数进行传递时，这个语法会经常被用到。

部分应用（Partial application）
你可以使用下划线“_”部分应用一个函数，结果将得到另一个函数。Scala使用下划线表示不同上下文中的不同事物，你通常可以把它看作是一个没有命名的神奇通配符。在{ _ + 2 }的上下文中，它代表一个匿名参数。你可以这样使用它：
  1. scala> def adder(m: Int, n: Int) = m + n
  2. adder: (m: Int,n: Int)Int
复制代码
  1. scala> val add2 = adder(2, _:Int)
  2. add2: (Int) => Int = <function1>

  4. scala> add2(3)
  5. res50: Int = 5
复制代码
你可以部分应用参数列表中的任意参数，而不仅仅是最后一个。

柯里化函数
有时会有这样的需求：允许别人一会在你的函数上应用一些参数，然后又应用另外的一些参数。
例如一个乘法函数，在一个场景需要选择乘数，而另一个场景需要选择被乘数。
  1. scala> def multiply(m: Int)(n: Int): Int = m * n
  2. multiply: (m: Int)(n: Int)Int
复制代码
你可以直接传入两个参数。
  1. scala> multiply(2)(3)
  2. res0: Int = 6
复制代码
你可以填上第一个参数并且部分应用第二个参数。
  1. scala> val timesTwo = multiply(2) _
  2. timesTwo: (Int) => Int = <function1>

  4. scala> timesTwo(3)
  5. res1: Int = 6
复制代码
你可以对任何多参数函数执行柯里化。例如之前的adder函数
  1. scala> (adder _).curried
  2. res1: (Int) => (Int) => Int = <function1>
复制代码

可变长度参数
这是一个特殊的语法，可以向方法传入任意多个同类型的参数。例如要在多个字符串上执行String的capitalize函数，可以这样写：
  1. def capitalizeAll(args: String*) = {
  2.   args.map { arg =>
  3.     arg.capitalize
  4.   }
  5. }

  7. scala> capitalizeAll("rarity", "applejack")
  8. res2: Seq[String] = ArrayBuffer(Rarity, Applejack)
复制代码

类
  1. scala> class Calculator {
  2.      |   val brand: String = "HP"
  3.      |   def add(m: Int, n: Int): Int = m + n
  4.      | }
  5. defined class Calculator

  7. scala> val calc = new Calculator
  8. calc: Calculator = Calculator@e75a11

  10. scala> calc.add(1, 2)
  11. res1: Int = 3

  13. scala> calc.brand
  14. res2: String = "HP"
复制代码
上面的例子展示了如何在类中用def定义方法和用val定义字段值。方法就是可以访问类的状态的函数。

构造函数
构造函数不是特殊的方法，他们是除了类的方法定义之外的代码。让我们扩展计算器的例子，增加一个构造函数参数，并用它来初始化内部状态。
  1. class Calculator(brand: String) {
  2.   /**
  3.    * A constructor.
  4.    */
  5.   val color: String = if (brand == "TI") {
  6.     "blue"
  7.   } else if (brand == "HP") {
  8.     "black"
  9.   } else {
  10.     "white"
  11.   }

  13.   // An instance method.
  14.   def add(m: Int, n: Int): Int = m + n
  15. }
复制代码
注意两种不同风格的评论。
你可以使用构造函数来构造一个实例：
  1. scala> val calc = new Calculator("HP")
  2. calc: Calculator = Calculator@1e64cc4d

  4. scala> calc.color
  5. res0: String = black
复制代码

表达式
上文的Calculator例子说明了Scala是如何面向表达式的。颜色的值就是绑定在一个if/else表达式上的。Scala是高度面向表达式的：大多数东西都是表达式而非指令。

旁白: 函数 vs 方法
函数和方法在很大程度上是可以互换的。由于函数和方法是如此的相似，你可能都不知道你调用的东西是一个函数还是一个方法。而当真正碰到的方法和函数之间的差异的时候，你可能会感到困惑。
  1. scala> class C {
  2.      |   var acc = 0
  3.      |   def minc = { acc += 1 }
  4.      |   val finc = { () => acc += 1 }
  5.      | }
  6. defined class C

  8. scala> val c = new C
  9. c: C = C@1af1bd6

  11. scala> c.minc // calls c.minc()

  13. scala> c.finc // returns the function as a value:
  14. res2: () => Unit = <function0>
复制代码
当你可以调用一个不带括号的“函数”，但是对另一个却必须加上括号的时候，你可能会想哎呀，我还以为自己知道Scala是怎么工作的呢。也许他们有时需要括号？你可能以为自己用的是函数，但实际使用的是方法。
在实践中，即使不理解方法和函数上的区别，你也可以用Scala做伟大的事情。如果你是Scala新手，而且在读两者的差异解释，你可能会跟不上。不过这并不意味着你在使用Scala上有麻烦。它只是意味着函数和方法之间的差异是很微妙的，只有深入语言内部才能清楚理解它。

继承
  1. class ScientificCalculator(brand: String) extends Calculator(brand) {
  2.   def log(m: Double, base: Double) = math.log(m) / math.log(base)
  3. }
复制代码
参考 Effective Scala 指出如果子类与父类实际上没有区别，类型别名是优于继承的。A Tour of Scala 详细介绍了子类化。

重载方法
  1. class EvenMoreScientificCalculator(brand: String) extends ScientificCalculator(brand) {
  2.   def log(m: Int): Double = log(m, math.exp(1))
  3. }
复制代码

抽象类
你可以定义一个抽象类，它定义了一些方法但没有实现它们。取而代之是由扩展抽象类的子类定义这些方法。你不能创建抽象类的实例。
  1. scala> abstract class Shape {
  2.      |   def getArea():Int    // subclass should define this
  3.      | }
  4. defined class Shape

  6. scala> class Circle(r: Int) extends Shape {
  7.      |   def getArea():Int = { r * r * 3 }
  8.      | }
  9. defined class Circle

  11. scala> val s = new Shape
  12. <console>:8: error: class Shape is abstract; cannot be instantiated
  13.        val s = new Shape
  14.                ^

  16. scala> val c = new Circle(2)
  17. c: Circle = Circle@65c0035b
复制代码

特质（Traits）
特质是一些字段和行为的集合，可以扩展或混入（mixin）你的类中。
  1. trait Car {
  2.   val brand: String
  3. }

  5. trait Shiny {
  6.   val shineRefraction: Int
  7. }
复制代码
  1. class BMW extends Car {
  2.   val brand = "BMW"
  3. }
复制代码
通过with关键字，一个类可以扩展多个特质：
  1. class BMW extends Car with Shiny {
  2.   val brand = "BMW"
  3.   val shineRefraction = 12
  4. }
复制代码
参考 Effective Scala 对特质的观点。
什么时候应该使用特质而不是抽象类？ 如果你想定义一个类似接口的类型，你可能会在特质和抽象类之间难以取舍。这两种形式都可以让你定义一个类型的一些行为，并要求继承者定义一些其他行为。一些经验法则：
  • 优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
  • 如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行。例如，你不能说trait t(i: Int) {}，参数i是非法的。
你不是问这个问题的第一人。可以查看更全面的答案： stackoverflow: Scala特质 vs 抽象类 , 抽象类和特质的区别, andScala编程: 用特质，还是不用特质？


类型
此前，我们定义了一个函数的参数为Int，表示输入是一个数字类型。其实函数也可以是泛型的，来适用于所有类型。当这种情况发生时，你会看到用方括号语法引入的类型参数。下面的例子展示了一个使用泛型键和值的缓存。
  1. trait Cache[K, V] {
  2.   def get(key: K): V
  3.   def put(key: K, value: V)
  4.   def delete(key: K)
  5. }
复制代码
方法也可以引入类型参数。
  1. def remove[K](key: K)
复制代码

apply 方法
当类或对象有一个主要用途的时候，apply方法为你提供了一个很好的语法糖。
  1. scala> class Foo {}
  2. defined class Foo

  4. scala> object FooMaker {
  5.      |   def apply() = new Foo
  6.      | }
  7. defined module FooMaker

  9. scala> val newFoo = FooMaker()
  10. newFoo: Foo = Foo@5b83f762
复制代码
或
  1. scala> class Bar {
  2.      |   def apply() = 0
  3.      | }
  4. defined class Bar

  6. scala> val bar = new Bar
  7. bar: Bar = Bar@47711479

  9. scala> bar()
  10. res8: Int = 0
复制代码
在这里，我们实例化对象看起来像是在调用一个方法。以后会有更多介绍！

单例对象
单例对象用于持有一个类的唯一实例。通常用于工厂模式。
  1. object Timer {
  2.   var count = 0

  4.   def currentCount(): Long = {
  5.     count += 1
  6.     count
  7.   }
  8. }
复制代码
可以这样使用：
  1. scala> Timer.currentCount()
  2. res0: Long = 1
复制代码
单例对象可以和类具有相同的名称，此时该对象也被称为“伴生对象”。我们通常将伴生对象作为工厂使用。
下面是一个简单的例子，可以不需要使用’new’来创建一个实例了。
  1. class Bar(foo: String)

  3. object Bar {
  4.   def apply(foo: String) = new Bar(foo)
  5. }
复制代码

函数即对象
在Scala中，我们经常谈论对象的函数式编程。这是什么意思？到底什么是函数呢？
函数是一些特质的集合。具体来说，具有一个参数的函数是Function1特质的一个实例。这个特征定义了apply()语法糖，让你调用一个对象时就像你在调用一个函数。
  1. scala> object addOne extends Function1[Int, Int] {
  2.      |   def apply(m: Int): Int = m + 1
  3.      | }
  4. defined module addOne

  6. scala> addOne(1)
  7. res2: Int = 2
复制代码
这个Function特质集合下标从0开始一直到22。为什么是22？这是一个主观的魔幻数字(magic number)。我从来没有使用过多于22个参数的函数，所以这个数字似乎是合理的。
apply语法糖有助于统一对象和函数式编程的二重性。你可以传递类，并把它们当做函数使用，而函数本质上是类的实例。
这是否意味着，当你在类中定义一个方法时，得到的实际上是一个Function*的实例？不是的，在类中定义的方法是方法而不是函数。在repl中独立定义的方法是Function*的实例。
类也可以扩展Function，这些类的实例可以使用()调用。
  1. scala> class AddOne extends Function1[Int, Int] {
  2.      |   def apply(m: Int): Int = m + 1
  3.      | }
  4. defined class AddOne

  6. scala> val plusOne = new AddOne()
  7. plusOne: AddOne = <function1>

  9. scala> plusOne(1)
  10. res0: Int = 2
复制代码
可以使用更直观快捷的extends (Int => Int)代替extends Function1[Int, Int]
  1. class AddOne extends (Int => Int) {
  2.   def apply(m: Int): Int = m + 1
  3. }
复制代码

包
你可以将代码组织在包里。
  1. package com.twitter.example
复制代码
在文件头部定义包，会将文件中所有的代码声明在那个包中。
值和函数不能在类或单例对象之外定义。单例对象是组织静态函数(static function)的有效工具。
  1. package com.twitter.example

  3. object colorHolder {
  4.   val BLUE = "Blue"
  5.   val RED = "Red"
  6. }
复制代码
现在你可以直接访问这些成员
  1. println("the color is: " + com.twitter.example.colorHolder.BLUE)
复制代码
注意在你定义这个对象时Scala解释器的返回：
  1. scala> object colorHolder {
  2.      |   val Blue = "Blue"
  3.      |   val Red = "Red"
  4.      | }
  5. defined module colorHolder
复制代码
这暗示了Scala的设计者是把对象作为Scala的模块系统的一部分进行设计的。

模式匹配
这是Scala中最有用的部分之一。
匹配值
  1. val times = 1

  3. times match {
  4.   case 1 => "one"
  5.   case 2 => "two"
  6.   case _ => "some other number"
  7. }
复制代码
使用守卫进行匹配
  1. times match {
  2.   case i if i == 1 => "one"
  3.   case i if i == 2 => "two"
  4.   case _ => "some other number"
  5. }
复制代码
注意我们是怎样将值赋给变量’i’的。
在最后一行指令中的_是一个通配符；它保证了我们可以处理所有的情况。
否则当传进一个不能被匹配的数字的时候，你将获得一个运行时错误。我们以后会继续讨论这个话题的。

参考 Effective Scala 对什么时候使用模式匹配 和 模式匹配格式化的建议. A Tour of Scala 也描述了 模式匹配

匹配类型
你可以使用 match来分别处理不同类型的值。
  1. def bigger(o: Any): Any = {
  2.   o match {
  3.     case i: Int if i < 0 => i - 1
  4.     case i: Int => i + 1
  5.     case d: Double if d < 0.0 => d - 0.1
  6.     case d: Double => d + 0.1
  7.     case text: String => text + "s"
  8.   }
  9. }
复制代码

匹配类成员
还记得我们之前的计算器吗。
让我们通过类型对它们进行分类。
一开始会很痛苦。
  1. def calcType(calc: Calculator) = calc match {
  2.   case _ if calc.brand == "hp" && calc.model == "20B" => "financial"
  3.   case _ if calc.brand == "hp" && calc.model == "48G" => "scientific"
  4.   case _ if calc.brand == "hp" && calc.model == "30B" => "business"
  5.   case _ => "unknown"
  6. }
复制代码
(⊙o⊙)哦，太痛苦了。幸好Scala提供了一些应对这种情况的有效工具。

样本类 Case Classes
使用样本类可以方便得存储和匹配类的内容。你不用new关键字就可以创建它们。
  1. scala> case class Calculator(brand: String, model: String)
  2. defined class Calculator

  4. scala> val hp20b = Calculator("hp", "20b")
  5. hp20b: Calculator = Calculator(hp,20b)
复制代码
样本类基于构造函数的参数，自动地实现了相等性和易读的toString方法。
  1. scala> val hp20b = Calculator("hp", "20b")
  2. hp20b: Calculator = Calculator(hp,20b)

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

  7. scala> hp20b == hp20B
  8. res6: Boolean = true
复制代码
样本类也可以像普通类那样拥有方法。

使用样本类进行模式匹配
case classes are designed to be used with pattern matching. Let’s simplify our calculator classifier example from earlier.
样本类就是被设计用在模式匹配中的。让我们简化之前的计算器分类器的例子。
  1. val hp20b = Calculator("hp", "20B")
  2. val hp30b = Calculator("hp", "30B")

  4. def calcType(calc: Calculator) = calc match {
  5.   case Calculator("hp", "20B") => "financial"
  6.   case Calculator("hp", "48G") => "scientific"
  7.   case Calculator("hp", "30B") => "business"
  8.   case Calculator(ourBrand, ourModel) => "Calculator: %s %s is of unknown type".format(ourBrand, ourModel)
  9. }
复制代码
最后一句也可以这样写
  1. case Calculator(_, _) => "Calculator of unknown type"
复制代码
或者我们完全可以不将匹配对象指定为Calculator类型
  1. case _ => "Calculator of unknown type"
复制代码
或者我们也可以将匹配的值重新命名。
  1. case c@Calculator(_, _) => "Calculator: %s of unknown type".format(c)
复制代码

异常
Scala中的异常可以在try-catch-finally语法中通过模式匹配使用。
  1. try {
  2.   remoteCalculatorService.add(1, 2)
  3. } catch {
  4.   case e: ServerIsDownException => log.error(e, "the remote calculator service is unavailable. should have kept your trusty HP.")
  5. } finally {
  6.   remoteCalculatorService.close()
  7. }
复制代码
try也是面向表达式的
  1. val result: Int = try {
  2.   remoteCalculatorService.add(1, 2)
  3. } catch {
  4.   case e: ServerIsDownException => {
  5.     log.error(e, "the remote calculator service is unavailable. should have kept your trusty HP.")
  6.     0
  7.   }
  8. } finally {
  9.   remoteCalculatorService.close()
  10. }
复制代码
这并不是一个完美编程风格的展示，而只是一个例子，用来说明try-catch-finally和Scala中其他大部分事物一样是表达式。
当一个异常被捕获处理了，finally块将被调用；它不是表达式的一部分。

Built at @twitter by @stevej, @marius, and @lahosken with much help from @evanm, @sprsquish, @kevino, @zuercher, @timtrueman, @wickman, and @mccv; Russian translation by appigram; Chinese simple translation by jasonqu; Korean translation by enshahar;

Licensed under the Apache License v2.0.

【转】Scala基础知识

标签：

原文地址：http://www.cnblogs.com/focusonepoint/p/5867012.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！