大数据学习之路----Scala语言学习（类、方法、对象、继承、特质）

1. 类、方法、对象、继承、特质
   Scala的类与Java、C++的类比起来更简洁，学完之后你会更爱Scala！！！
   1.1. 类
   1.1.1. 类的定义
   package cn.bw.class_demo

/**

• 在Scala中，类并不用声明为public类型的。

• Scala源文件中可以包含多个类，所有这些类都具有共有可见性。
  */
  class Person {
  //用val修饰的变量是可读属性，有getter但没有setter（相当与Java中用final修饰的变量）
  val id=“9527”

  //用var修饰的变量都既有getter，又有setter
  var age:Int=18

  //类私有字段，只能在类的内部使用或者伴生对象中访问
  private var name : String = “唐伯虎”

  //类私有字段，访问权限更加严格的，该字段在当前类中被访问
  //在伴生对象里面也不可以访问
  private[this] var pet = “小强”

}

//伴生对象（这个名字和类名相同，叫伴生对象）
object Person{
def main(args: Array[String]): Unit = {
val p=new Person

//如果是下面的修改，发现下面有红线，说明val类型的不支持重新赋值，但是可以获取到值
//p.id = "123"
println(p.id)
//打印age
println(p.age)
//打印name,伴生对象中可以在访问private变量
println(p.name)
//由于pet字段用private[this]修饰，伴生对象中访问不到pet变量
//p.pet(访问不到)

}
}

伴生类和伴生对象的关系是1.两者都在同一个类源中。2.类名是一样的

1.1.2. 方法的定义
1.基本语法

//基本语法
def eat(food:String): Unit ={
println(s"吃${food}很爽啊----------")
}

Def :定义方法的关键字
eat :方法名
Unit :返回值类型 可以使用return 也可以不使用 ,scala中尽量不使用

方法的调用
object Person{
def main(args: Array[String]): Unit = {
val person = new Person
person.eat(“红薯”)
}
}

1.1.3. 构造器
Scala中的每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起。
注意：主构造器会执行类定义中的所有语句。
package cn.bw.class_demo

/**
*每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
*/
class Student(val name:String,var age:Int) {
println(“执行主构造器”)
private var gender=“male”
def this(name:String,age:Int,gender:String){
//每个辅助构造器执行必须以主构造器或者其他辅助构造器的调用开始
this(name,age)
println(“执行辅助构造器”)
this.gender=gender
}
}

object Student {
def main(args: Array[String]): Unit = {
val s1=new Student(“zhangsan”,20)

val s2=new Student("zhangsan",20,"female")

}
}

1.2. Scala面向对象编程之对象
1.2.1. Scala中的object
object 相当于 class 的单个实例，通常在里面放一些静态的 field 或者 method；
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的。
object作用：
1.存放工具方法和常量
2.高效共享单个不可变的实例
3.单例模式
举例说明：

Java 单例对象
public class ImageLoader {
//创建一个对象
private static ImageLoader instance = new ImageLoader();
//私有化构造
private ImageLoader(){}
//提供一个静态的方法,返回实例化的对象
public static ImageLoader getInstance(){
return instance;
}
}
测试
public class JavaTest {
public static void main(String[] args) {
ImageLoader instance = ImageLoader.getInstance();
//打印实例对象1
System.out.println(instance);
ImageLoader instance01 = ImageLoader.getInstance();
//打印实例对象2
System.out.println(instance01);
}
}

package cn.bw.object_demo
import scala.collection.mutable.ArrayBuffer

class Session{}
object SessionFactory{
//该部分相当于java中的静态块
val session=new Session
//在object中的方法相当于java中的静态方法
def getSession(): Session ={
session
}
}
object SingletonDemo {
def main(args: Array[String]) {
//单例对象，不需要new，用【单例对象名称.方法】调用对象中的方法
val session1 = SessionFactory.getSession()
println(session1)
//单例对象，不需要new，用【单例对象名称.变量】调用对象中成员变量
val session2=SessionFactory.session
println(session2)
}
}

1.2.2. Scala中的伴生对象
如果有一个class文件，还有一个与class同名的object文件，那么就称这个object是class的伴生对象，class是object的伴生类；
伴生类和伴生对象必须存放在一个.scala文件中；
伴生类和伴生对象的最大特点是，可以相互访问；
举例说明：
package cn.bw.object_demo

//伴生类
class Dog {
val id = 1
private var name = “bw”
def printName(): Unit ={
//在Dog类中可以访问伴生对象Dog的私有属性
println(Dog.CONSTANT + name )
}
}
//伴生对象
object Dog {
//伴生对象中的私有属性
private val CONSTANT = "汪汪汪 : "
def main(args: Array[String]) {
val p = new Dog
//访问私有的字段name
p.name = “123”
p.printName()
}
}
//执行结果 汪汪汪 : 123

1.2.3. Scala中的apply方法
object 中非常重要的一个特殊方法，就是apply方法；
apply方法通常是在伴生对象中实现的，其目的是，通过伴生类的构造函数功能，来实现伴生对象的构造函数功能；
通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,…参数n)时apply方法会被调用；
在创建伴生对象或伴生类的对象时，通常不会使用new class/class() 的方式，而是直接使用 class()，隐式的调用伴生对象的 apply 方法，这样会让对象创建的更加简洁；
举例说明：
1.简化创建对象
package com.bw.myclass
//伴生类
class Foo(name:String) {

}
//伴生对象
object Foo {
def apply(foo: String) : Foo = {
new Foo(foo)
}
}
//测试类
object Client {

def main(args: Array[String]): Unit = {
val foo = Foo(“Hello”)
}
}

2.工厂方法
package cn.bw.object_demo
/**

• Array 类的伴生对象中，就实现了可接收变长参数的 apply 方法，
• 并通过创建一个 Array 类的实例化对象，实现了伴生对象的构造函数功能
  /
  // 指定 T 泛型的数据类型，并使用变长参数 xs 接收传参，返回 Array[T] 数组
  // 通过 new 关键字创建 xs.length 长的 Array 数组
  // 其实就是调用Array伴生类的 constructor进行 Array对象的初始化
  // def apply[T: ClassTag](xs: T): Array[T] = {
  // val array = new ArrayT
  // var i = 0
  // for (x <- xs.iterator) { array(i) = x; i += 1 }
  // array
  // }

object ApplyDemo {
def main(args: Array[String]) {
//调用了Array伴生对象的apply方法
//def apply(x: Int, xs: Int*): Array[Int]
//arr1中只有一个元素5
val arr1 = Array(5)

//new了一个长度为5的array，数组里面包含5个null
var arr2 = new Array(5)
println(arr1.toBuffer)

}
}

1.2.4. Scala中的main方法
同Java一样，如果要运行一个程序，必须要编写一个包含 main 方法的类；
在 Scala 中，也必须要有一个 main 方法，作为入口；
Scala 中的 main 方法定义为 def main(args: Array[String])，而且必须定义在 object 中；
除了自己实现 main 方法之外，还可以继承 App Trait，然后，将需要写在 main 方法中运行的代码，直接作为 object 的 constructor 代码即可，而且还可以使用 args 接收传入的参数；
案例说明：

package cn.bw.object_demo

//1.在object中定义main方法
object Main_Demo1 {
def main(args: Array[String]) {
if(args.length > 0){
println("Hello, " + args(0))
}else{
println(“Hello World!”)
}
}
}
//2.使用继承App Trait ,将需要写在 main 方法中运行的代码
// 直接作为 object 的 constructor 代码即可，
// 而且还可以使用 args 接收传入的参数。

object Main_Demo2 extends App{
if(args.length > 0){
println("Hello, " + args(0))
}else{
println(“Hello World!”)
}
}

1.3. Scala面向对象编程之继承
1.3.1. Scala中继承(extends)的概念
Scala 中，让子类继承父类，与 Java 一样，也是使用 extends 关键字；
继承就代表，子类可继承父类的 field 和 method ，然后子类还可以在自己的内部实现父类没有的，子类特有的 field 和method，使用继承可以有效复用代码；
子类可以覆盖父类的 field 和 method，但是如果父类用 final 修饰，或者 field 和 method 用 final 修饰，则该类是无法被继承的，或者 field 和 method 是无法被覆盖的。
private 修饰的 field 和 method 不可以被子类继承，只能在类的内部使用；
field 必须要被定义成 val 的形式才能被继承，并且还要使用 override 关键字。 因为 var 修饰的 field 是可变的，在子类中可直接引用被赋值，不需要被继承；即 val 修饰的才允许被继承，var 修饰的只允许被引用。继承就是改变、覆盖的意思。
Java 中的访问控制权限，同样适用于 Scala
类内部 本包 子类 外部包

public √ √ √ √

protected √ × √ ×

private √ × × ×

举例说明：
package cn.bw.extends_demo

class Person1 {
val name=“super”
def getName=this.name
}
class Student1 extends Person1{
//继承加上关键字
override
val name=“sub”
//子类可以定义自己的field和method
val score=“A”
def getScore=this.score
}

1.3.2. Scala中override 和 super 关键字
Scala中，如果子类要覆盖父类中的一个非抽象方法，必须要使用 override 关键字；子类可以覆盖父类的 val 修饰的field，只要在子类中使用 override 关键字即可。
override 关键字可以帮助开发者尽早的发现代码中的错误，比如， override 修饰的父类方法的方法名拼写错误。
此外，在子类覆盖父类方法后，如果在子类中要调用父类中被覆盖的方法，则必须要使用 super 关键字，显示的指出要调用的父类方法。
举例说明：
package cn.bw.extends_demo

class Person2 {
private val name = “leo”
val age=50
def getName = this.name
}
class Student2 extends Person2{
private val score = “A”
//子类可以覆盖父类的 val field,使用override关键字
override
val age=30
def getScore = this.score
//覆盖父类非抽象方法，必须要使用 override 关键字
//同时调用父类的方法，使用super关键字
override def getName = "your name is " + super.getName
}

1.3.3. Scala中isInstanceOf 和 asInstanceOf
如果实例化了子类的对象，但是将其赋予了父类类型的变量，在后续的过程中，又需要将父类类型的变量转换为子类类型的变量，应该如何做？
Class A extends class B
B b=new A

首先，需要使用 isInstanceOf 判断对象是否为指定类的对象，如果是的话，则可以使用 asInstanceOf 将对象转换为指定类型；
注意： p.isInstanceOf[XX] 判断 p 是否为 XX 对象的实例；p.asInstanceOf[XX] 把 p 转换成 XX 对象的实例
注意：如果没有用 isInstanceOf 先判断对象是否为指定类的实例，就直接用 asInstanceOf 转换，则可能会抛出异常；
注意：如果对象是 null，则 isInstanceOf 一定返回 false， asInstanceOf 一定返回 null；
Scala与Java类型检查和转换

Scala Java
obj.isInstanceOf[C] obj instanceof C
obj.asInstanceOf[C] ©obj
classOf[C] C.class

举例说明：

package cn.bw.extends_demo

class Person3 {}
class Student3 extends Person3
object Student3{
def main (args: Array[String] ) {
val p: Person3 = new Student3
var s: Student3 = null
//如果对象是 null，则 isInstanceOf 一定返回 false
println (s.isInstanceOf[Student3])
// 判断 p 是否为 Student3 对象的实例
if (p.isInstanceOf[Student3] ) {
//把 p 转换成 Student3 对象的实例
s = p.asInstanceOf[Student3]
}
println (s.isInstanceOf[Student3] )
}
}

1.3.4. Scala中getClass 和 classOf
Class A extends class B
B b=new A b.getClass ==classOf[A]
B b=new B b.getClass ==classOf[B]

isInstanceOf 只能判断出对象是否为指定类以及其子类的对象，而不能精确的判断出，对象就是指定类的对象；
如果要求精确地判断出对象就是指定类的对象，那么就只能使用 getClass 和 classOf 了；
p.getClass 可以精确地获取对象的类，classOf[XX] 可以精确的获取类，然后使用 == 操作符即可判断；
举例说明：
package cn.bw.extends_demo

class Person4 {}
class Student4 extends Person4
object Student4{
def main(args: Array[String]) {
val p:Person4=new Student4
//判断p是否为Person4类的实例
println(p.isInstanceOf[Person4])//true
//判断p的类型是否为Person4类
println(p.getClass == classOf[Person4])//false
//判断p的类型是否为Student4类
println(p.getClass == classOf[Student4])//true
}
}

1.3.5. Scala中抽象类
如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现不同的方法。此时，可以将父类中的这些方法编写成只含有方法签名，不含方法体的形式，这种形式就叫做抽象方法;
一个类中，如果含有一个抽象方法或抽象field，就必须使用abstract将类声明为抽象类，该类是不可以被实例化的;
在子类中覆盖抽象类的抽象方法时，可以不加override关键字;
举例说明：
package cn.bw.extends_demo

abstract class Person9(val name:String) {
//必须指出返回类型，不然默认返回为Unit
def sayHello:String
def sayBye:String
}
class Student9(name:String) extends Person9(name){
//必须指出返回类型，不然默认
def sayHello: String = “Hello,”+name
def sayBye: String =“Bye,”+name
}
object Student9{
def main(args: Array[String]) {
val s = new Student9(“tom”)
println(s.sayHello)
println(s.sayBye)
}
}

注意:
2.在scala中覆盖一个抽象类中字段时，可以不写override
3.使用var定义的抽象字段只能使用var覆盖
4.使用val定义的抽象字段只能使用val覆盖
5.抽象类不一定有抽象字段或抽象方法，只需要添加abstract关键字
6.有抽象字段一定是抽象类
7.重写字段的实质是在重写字段的setter、getter方法
抽象类中可以有非抽象的方法

1.3.6. Scala中抽象field
如果在父类中，定义了field，但是没有给出初始值，则此field为抽象field；
举例说明：
package cn.bw.extends_demo

abstract class Person10 (val name:String){
//抽象fields
val age:Int
}
class Student10(name: String) extends Person10(name) {
val age: Int = 50
}

1.4.Scala中面向对象编程之trait
1.4.1. 将trait作为接口使用
Scala中的trait是一种特殊的概念；
首先先将trait作为接口使用，此时的trait就与Java中的接口 (interface)非常类似；
在trait中可以定义抽象方法，就像抽象类中的抽象方法一样，只要不给出方法的方法体即可；
类可以使用extends关键字继承trait，注意，这里不是 implement，而是extends ，在Scala中没有 implement 的概念，无论继承类还是trait，统一都是 extends；
类继承后，必须实现其中的抽象方法，实现时，不需要使用 override 关键字；
Scala不支持对类进行多继承，但是支持多重继承 trait，使用 with 关键字即可。
trait中未被实现的方法默认是抽象方法,因此不需要在方法前加abstract
a.有父类
class extends 特质1 with 特质2 with 特质3
b.没有父类
class extends 父类 with 特质1 with 特质2 with 特质3
举例说明：
package cn.bw.triat

trait HelloTrait {
def sayHello(): Unit
}
trait MakeFriendsTrait {
def makeFriends(c: Children): Unit
}
//多重继承 trait
class Children(val name: String) extends HelloTrait with MakeFriendsTrait with Serializable{
def sayHello() =println("Hello, " + this.name)
def makeFriends(c: Children) = println("Hello, my name is " + this.name + ", your name is " + c.name)
}
object Children{
def main(args: Array[String]) {
val c1=new Children(“tom”)
val c2=new Children(“jim”)
c1.sayHello()//Hello, tom
c1.makeFriends(c2)//Hello, my name is tom, your name is jim
}
}

1.4.2. 在trait中定义具体的方法
Scala中的trait不仅可以定义抽象方法，还可以定义具体的方法，此时 trait 更像是包含了通用方法的工具，可以认为trait还包含了类的功能。
举例说明：
package cn.bw.triat
/**

• 比如 trait 中可以包含很多子类都通用的方法，例如打印日志或其他工具方法等等。
• spark就使用trait定义了通用的日志打印方法；
  */
  trait Logger {
  def log(message: String): Unit = println(message)
  }
  class PersonForLog(val name: String) extends Logger {
  def makeFriends(other: PersonForLog) = {
  println("Hello, " + other.name + "! My name is " + this.name + “, I miss you!!”)
  this.log("makeFriends method is invoked with parameter PersonForLog[name = " + other.name + “]”)
  }
  }
  object PersonForLog{
  def main(args: Array[String]) {
  val p1=new PersonForLog(“jack”)
  val p2=new PersonForLog(“rose”)
  p1.makeFriends(p2)
  //Hello, rose! My name is jack, I miss you!!
  //makeFriens method is invoked with parameter PersonForLog[name = rose]
  }
  }
  1.4.3. 在trait中定义具体field
  Scala 中的 trait 可以定义具体的 field，此时继承 trait 的子类就自动获得了 trait 中定义的 field；
  但是这种获取 field 的方式与继承 class 的是不同的。 如果是继承 class 获取的 field ，实际上还是定义在父类中的；而继承 trait获取的 field，就直接被添加到子类中了。
  举例说明：

package cn.bw.triat

trait PersonForField {
val age:Int=50
}

//继承 trait 获取的field直接被添加到子类中
class StudentForField(val name: String) extends PersonForField {
def sayHello = println("Hi, I’m " + this.name + ", my age is "+ age)
}

object StudentForField{
def main(args: Array[String]) {
val s=new StudentForField(“tom”)
s.sayHello
}
}

1.4.4. 在trait中定义抽象field
Scala中的trait也能定义抽象field， 而trait中的具体方法也能基于抽象field编写；
继承trait的类，则必须覆盖抽象field，提供具体的值；
举例说明：
package cn.bw.triat

trait SayHelloTrait {
val msg:String
def sayHello(name: String) = println(msg + ", " + name)
}

class PersonForAbstractField(val name: String) extends SayHelloTrait {
//必须覆盖抽象 field
val msg = “Hello”
def makeFriends(other: PersonForAbstractField) = {
this.sayHello(other.name)
println("I’m " + this.name + “, I want to make friends with you!!”)
}
}
object PersonForAbstractField{
def main(args: Array[String]) {
val p1=new PersonForAbstractField(“Tom”)
val p2=new PersonForAbstractField(“Rose”)
p1.makeFriends(p2)
}
}

1.4.5. 在实例对象指定混入某个trait
可在创建类的对象时，为该对象指定混入某个trait，且只有混入了trait的对象才具有trait中的方法，而其他该类的对象则没有；
在创建对象时，使用 with 关键字指定混入某个 trait；
举例说明：
package cn.bw.triat

trait LoggedTrait {
// 该方法为实现的具体方法
def log(msg: String) = {}
}
trait MyLogger extends LoggedTrait{
// 覆盖 log() 方法
override def log(msg: String) = println("log: " + msg)
}

class PersonForMixTraitMethod(val name: String) extends LoggedTrait {
def sayHello = {
println("Hi, I’m " + this.name)
log(“sayHello method is invoked!”)
}
}
object PersonForMixTraitMethod{
def main(args: Array[String]) {
val tom= new PersonForMixTraitMethod(“Tom”).sayHello //结果为：Hi, I’m Tom
// 使用 with 关键字，指定混入MyLogger trait
val rose = new PersonForMixTraitMethod(“Rose”) with MyLogger
rose.sayHello
// 结果为： Hi, I’m Rose
// 结果为： log: sayHello method is invoked!
}
}
1.4.6. trait 调用链
Scala中支持让类继承多个trait后，可依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法，在最后都依次执行 super 关键字即可；
类中调用多个trait中都有的这个方法时，首先会从最右边的trait的方法开始执行，然后依次往左执行，形成一个调用链条；
这种特性非常强大，其实就是设计模式中责任链模式的一种具体实现；
案例说明：
package cn.bw.triat

trait HandlerTrait {
def handle(data: String) = {println(“last one”)}
}
trait DataValidHandlerTrait extends HandlerTrait {
override def handle(data: String) = {
println("check data: " + data)
super.handle(data)
}
}
trait SignatureValidHandlerTrait extends HandlerTrait {
override def handle(data: String) = {
println("check signature: " + data)
super.handle(data)
}
}
class PersonForRespLine(val name: String) extends SignatureValidHandlerTrait with DataValidHandlerTrait {
def sayHello = {
println("Hello, " + this.name)
this.handle(this.name)
}
}
object PersonForRespLine{
def main(args: Array[String]) {
val p=new PersonForRespLine(“tom”)
p.sayHello
//执行结果：
// Hello, tom
// check data: tom
// check signature: tom
// last one
}
}

1.4.7. trait 继承 class
在Scala中trait 也可以继承 class，此时这个 class 就会成为所有继承该 trait 的子类的超级父类。
Class A
Trait B extends A
Class C extends B
Trait D extends B
举例说明：
package cn.bw.triat

class MyUtil {
def printMsg(msg: String) = println(msg)
}
trait Logger_Two extends MyUtil {
def log(msg: String) = this.printMsg("log: " + msg)
}
class Person_Three(val name: String) extends Logger_Two {
def sayHello {
this.log("Hi, I’m " + this.name)
this.printMsg("Hello, I’m " + this.name)
}
}
object Person_Three{
def main(args: Array[String]) {
val p=new Person_Three(“Tom”)
p.sayHello
//执行结果：
// log: Hi, I’m Tom
// Hello, I’m Tom
}
}

2. 模式匹配和样例类
   Scala有一个十分强大的模式匹配机制，可以应用到很多场合：如switch语句、类型检查等。并且Scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配。
   2.1. 匹配字符串
   package cn.bw.cases
   import scala.util.Random

object CaseDemo01 extends App{
val arr = Array(“hadoop”, “zookeeper”, “spark”)
val name = arr(Random.nextInt(arr.length))
name match {
case “hadoop” => println(“大数据分布式存储和计算框架…”)
case “zookeeper” => println(“大数据分布式协调服务框架…”)
case “spark” => println(“大数据分布式内存计算框架…”)
case _ => println(“我不认识你…”)
}
}

2.2. 匹配类型
package cn.bw.cases
import scala.util.Random

object CaseDemo01 extends App{
val arr = Array(“hello”, 1, 2.0, CaseDemo)
val v = arr(Random.nextInt(4))
println(v)
v match {
case x: Int => println("Int " + x)
case y: Double if(y >= 0) => println("Double "+ y)
case z: String => println("String " + z)
case _ => throw new Exception(“not match exception”)
}
}

注意：case y: Double if(y >= 0) => …
模式匹配的时候还可以添加守卫条件。如不符合守卫条件，将掉入case _中。
2.3. 匹配数组、元组、集合
package cn.bw.cases

object CaseDemo03 extends App{

val arr = Array(1, 3, 5)
arr match {
case Array(1, x, y) => println(x + " " + y)
case Array(0) => println(“only 0”)
case Array(0, _*) => println(“0 …”)
case _ => println(“something else”)
}

val lst = List(3, -1)
lst match {
case 0 :: Nil => println(“only 0”)
case x :: y :: Nil => println(s"x: $x y: $y")
case 0 :: tail => println(“0 …”)
case _ => println(“something else”)
}

val tup = (1, 3, 7)
tup match {
case (1, x, y) => println(s"1, $x , $y")
case (_, z, 5) => println(z)
case _ => println(“else”)
}
}

注意：在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
9 :: List(5, 2) :: 操作符是将给定的头和尾创建一个新的列表
注意：:: 操作符是右结合的，如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
2.4. 样例类
在Scala中样例类是一种特殊的类，可用于模式匹配。
定义形式：
case class 类型，是多例的，后面要跟构造参数。 case class Student(name:String)
case object 类型，是单例的。 case object Person

package cn.bw.cases
import scala.util.Random

case class SubmitTask(id: String, name: String)
case class HeartBeat(time: Long)
case object CheckTimeOutTask

object CaseDemo04 extends App{
val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask(“0001”, “task-0001”))

arr(Random.nextInt(arr.length)) match {
case SubmitTask(id, name) => {
println(s"$id, $name")
}
case HeartBeat(time) => {
println(time)
}
case CheckTimeOutTask => {
println(“check”)
}
}
}

2.5. Option类型
在Scala中Option类型用样例类来表示可能存在或者可能不存在的值(Option的子类有Some和None)。Some包装了某个值，None表示没有值

package cn.bw.cases

object OptionDemo {
def main(args: Array[String]) {
val map = Map(“a” -> 1, “b” -> 2)
val v = map.get(“b”) match {
case Some(i) => i
case None => 0
}
println(v)
//更好的方式
val v1 = map.getOrElse(“c”, 0)
println(v1)
}
}

2.6. 偏函数
被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例，A代表输入参数类型，B代表返回结果类型，常用作输入模式匹配，偏函数最大的特点就是它只接受和处理其参数定义域的一个子集。
package cn.bw.cases

object PartialFuncDemo {

val func1: PartialFunction[String, Int] = {
case “one” => 1
case “two” => 2
case _ => -1
}

def func2(num: String) : Int = num match {
case “one” => 1
case “two” => 2
case _ => -1
}

def main(args: Array[String]) {
println(func1(“one”))
println(func2(“one”))
}
}
3. Scala中的协变、逆变、非变
3.1. 协变、逆变、非变介绍
Array[String] Array[Object]
协变和逆变主要是用来解决参数化类型的泛化问题。Scala的协变与逆变是非常有特色的，完全解决了Java中泛型的一大缺憾；举例来说，Java中，如果有 A是 B的子类，但 Card[A] 却不是 Card[B] 的子类；而 Scala 中，只要灵活使用协变与逆变，就可以解决此类 Java 泛型问题；
由于参数化类型的参数（参数类型）是可变的，当两个参数化类型的参数是继承关系（可泛化），那被参数化的类型是否也可以泛化呢？Java中这种情况下是不可泛化的，然而Scala提供了三个选择，即协变(“+”)、逆变（“-”）和非变。
下面说一下三种情况的含义，首先假设有参数化特征Queue，那它可以有如下三种定义。
(1) trait Queue[T] {}
这是非变情况。这种情况下，当类型B是类型A的子类型，则Queue[B]与Queue[A]没有任何从属关系，这种情况是和Java一样的。
(2) trait Queue[+T] {} 
这是协变情况。这种情况下，当类型B是类型A的子类型，则Queue[B]也可以认为是Queue[A]的子类型，即Queue[B]可以泛化为Queue[A]。也就是被参数化类型的泛化方向与参数类型的方向是一致的，所以称为协变。
(3)  trait Queue[-T] {} 
这是逆变情况。这种情况下，当类型B是类型A的子类型，则Queue[A]反过来可以认为是Queue[B]的子类型。也就是被参数化类型的泛化方向与参数类型的方向是相反的，所以称为逆变。

3.2. 协变、逆变、非变总结
C[+T]：如果A是B的子类，那么C[A]是C[B]的子类。
C[-T]：如果A是B的子类，那么C[B]是C[A]的子类。
C[T]： 无论A和B是什么关系，C[A]和C[B]没有从属关系。

3.3. 案例
package cn.bw.scala.enhance.covariance

class Super
class Sub extends Super
//协变
class Temp1[+A](title: String)
//逆变
class Temp2[-A](title: String)
//非变
class Temp3[A](title: String)

object Covariance_demo{
def main(args: Array[String]) {
//支持协变 Temp1[Sub]还是Temp1[Super]的子类
val t1: Temp1[Super] = new Temp1[Sub](“hello scala!!!”)
//支持逆变 Temp1[Super]是Temp1[Sub]的子类
val t2: Temp2[Sub] = new Temp2[Super](“hello scala!!!”)
//支持非变 Temp3[Super]与Temp3[Sub]没有从属关系，如下代码会报错
//val t3: Temp3[Sub] = new Temp3[Super](“hello scala!!!”)
//val t4: Temp3[Super] = new Temp3[Sub](“hello scala!!!”)
println(t1.toString)
println(t2.toString)
}
}

4. Scala中的上下界
   4.1.上界、下界介绍
   ? extends T （这是java中的表示形式）
   ? super T
   在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型。比如，要求某个泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正常的使用与运行。此时，就可以使用上下边界Bounds的特性；
   Scala的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类；

(1) U >: T ? super T

这是类型下界的定义，也就是U必须是类型T的父类(或本身，自己也可以认为是自己的父类)。

(2) S <: T ? extends T

这是类型上界的定义，也就是S必须是类型T的子类（或本身，自己也可以认为是自己的子类)。