关闭

Scala学习笔记(3): 面向对象与容器

114人阅读 评论(0) 收藏 举报

面向对象编程

这个通过一个例子来解释Scala面向对象编程的基本概念,这里我们需要为MongoDB(一种NoSQL数据库,详见我的另一篇博客)编写一个简单的API。MongoDB官方提供了Java API,而我们要做的是使用Scala对其进行简单的封装。

Class

先来搭建一个叫MongoClient的类作为建立数据库连接的入口,定义一个MongoClient类,并指定主构造函数的两个参数(val host: String, val port: Int)。

class MongoClient(val host: String, val port: Int)

构造函数参数的格式可以是[val/var] param : type,区别在于:val参数是只读的(相当于只有get方法),var参数是可写的(有get和set方法),如果没有前缀则是私有的(没有get和set方法)

构造函数

可以在类中定义多个构造函数(包括默认构造函数),例如下面是MongoClient的一个完整定义:

class MongoClient(val host: String, val port: Int) {
  
  require(host != null, "You have to provide a host name")
  private val underlying = new Mongo(host, port)

  def this() = this("127.0.0.1", 27017)
  def version = underlying.getVersion()
  def dropDB(name: String) = underlying.dropDatabase(name)
  def createDB(name: String) = DB(underlying.getDB(name))
  def db(name: String) = DB(underlying.getDB(name))
}

def this() 定义了一个默认构造函数。

Case class

case class是一种特殊的Class,编译器会为其自动生成一些样板代码(equals, hashCode, toString, apply等)。

case class Person(firstName:String, lastName:String)

Object

Scala中不存在静态变量和静态方法,所有的变量和方法必须定义在类或者定义在object中,所谓的object就是一个单例对象。

object可以用来定义一个可执行类:

object HelloWrold extends App {
    println("Hello World")
}

object可以定义

object的另一种常见的用法是作为一个类的伴随对象,用来定义一些“静态”的工厂函数。例如下面这段程序中,我们首先定义了DB类,然后定义了一个同样叫DB的伴随对象,伴随对象可以可以访问伴随类的私有成员。

class DB private (val underlying: MongoDB){ //注意private关键词,DB的构造函数是私有的
  def collectionNames = for(name <- new JSetWrapper(underlying.getCollectionNames())) yield name
  
  private def collection(name: String) = underlying.getCollection(name)
  
  def readOnlyCollection(name: String) = new DBCollection(collection(name))
  def administrableCollection(name: String) = new DBCollection(collection(name)) with Administrable
  def updatableCollection(name: String) = new DBCollection(collection(name)) with Updatable 
}

object DB {
  def apply(underlying: MongoDB) = new DB(underlying)
}

包与引入

Scala中包也是一种特殊的对象,在包内部可以看定义其他类与对象,如果要在包里面定义函数或者变量的话,请使用包对象:

//package.scala
package object bar {
  val minimumAge = 18
  def verifyAge = {}
}

//other.scala
package bar
class BarTender {
  def serveDrinks = { verifyAge; ... }
}

包的定义可以是嵌套式的(C#中常见),或者是平板式的(Java中常见)。引用包的常见写法有:

import com.mongodb.DBObject
import com.mongodb._  //_与Java中的×(星号)是一个意思
import com.mongodb.{DBCollection => MongoDBCollection} //引入包后更改其名称

Scala的继承模型

scala.Any是任何类的父类;Scala.AnyRef相当于Java中的Object类,即任何引用类的父类;AnyVal是任何值类的父类。

在图中实线表示继承关系,虚线表示view关系,view的意思是类型间存在隐式转换。

scala class.png

在类层级的最底下是Scala.Null和Scala.Nothing,Scala.Null类型只有一个实例化对象null, Scala.Nothing则不能实例化。

特质

Trait可以翻译成特质,你可以认为特质是一种增强版的接口,但我认为把它理解为一种部分实现的类更为合适。为什么这么说?因为使用特质构造程序,允许我们把一个大的类打散成多个特质,相当于把机器拆成零件,然后再自由组装。

特性 Interface (Java) Abstract class (Java + Scala) Trait
实例化 No No No
构造参数 No Yes No
方法定义 Yes Yes Yes
方法实现 No Yes Yes
成员变量 No Yes Yes
多重组合(继承) Yes No Yes

例如下面这个例子中,我们把mongodb java API的功能打散成几个不同的特质,所以特质都从ReadOnly特质继承而来。

trait ReadOnly {
  val underlying : MongoDBCollection
  
  def name = underlying getName
  def fullName = underlying getFullName
  def find(doc: DBObject) = underlying find doc
  def findOne(doc: DBObject) = underlying findOne doc
  def findONe = underlying findOne
  def getCount(doc: DBObject) = underlying getCount doc
  
  def find(query: Query): DBCursor = {
    def applyOptions(cursor:DBCursor, option: QueryOption): DBCursor = {
    option match {
      case Skip(skip, next) => applyOptions(cursor.skip(skip), next)
      case Sort(sorting, next)=> applyOptions(cursor.sort(sorting), next)
      case Limit(limit, next) => applyOptions(cursor.limit(limit), next)
      case NoOption => cursor
    }
    }
    applyOptions(find(query.q), query.option)
  }
}

trait Administrable extends ReadOnly {
  
  def drop: Unit = underlying drop
  def dropIndexes : Unit = underlying dropIndexes
  
}

trait Updatable extends ReadOnly {
  def -=(doc: DBObject): Unit = underlying remove doc
  def +=(doc: DBObject): Unit = underlying save doc
}

trait LocaleAware extends ReadOnly {
  override def findOne(doc: DBObject) = {
    doc.put("locale", java.util.Locale.getDefault.getLanguage)
    super.findOne(doc)
  }
  override def find(doc: DBObject) = {
    doc.put("locale", java.util.Locale.getDefault.getLanguage)
    super.find(doc)
  }
}

class DBCollection(override val underlying: MongoDBCollection) extends ReadOnly

//用法
new DBCollection(mongoDBCollection) with Updatable with Administrable

Scala容器

Scala中容器被划分为两类:immutable和mutable,分别属于包 scala.collection.immutable和 scala.collection.mutable。Java程序员可以用String和StringBuffer的来理解它们的区别,即immutable容器上的增删操作会返回一个新的immutable容器,而mutable容器上的增删操作是in place(会产生副作用)。

所有immutable和mutable容器都继承自scala.collection里定义的抽象类,它的类结构如下:

scala-collection.png

  • IndexedSeq的实现是Vector, LinearSeq的实现是list
  • 通过使用隐式转换,Java中的String和Array类型在Scala中“继承”了IndexedSeq接口

常见的collection操作

  • map 使用函数f(T=>T)将collection中的元素映射到一个新的collection
  • flatMap 函数映射f(T=>List[T]),但会把collection扁平化
  • filter
  • foldLeft
  • foldRight

并发容器

Scala 2.9引入了并发容器,使得很多容器操作可以安全的并发执行。例如,在普通容器类后加.par后缀即可转换为并发容器。

myCollection.par.foldLeft(0)((a,b) => a+b)

Par容器的内部实现是基于类似于MergeSort的分割组合算法。


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:19657次
    • 积分:643
    • 等级:
    • 排名:千里之外
    • 原创:29篇
    • 转载:40篇
    • 译文:13篇
    • 评论:1条
    最新评论