Scala的面向对象
来源:互联网 发布:网络电视机电盒 编辑:程序博客网 时间:2024/06/06 07:14
a、类和构造函数
在Scala中通过class关键字声明一个类,如下:
<scala> class MongoClient(val host:String, val port:Int)
这看起来和java有些不同,Scala的类名后带有参数,表示在声明类的同时,也创建了主构造函数。当在创建MongoClient实例时,需要直接或间接从重载的构造函数中调用主构造函数。
在Scala中声明主构造函数是嵌入在定义类的代码中的。构造函数中定义的参数,可以看做类的属性,并且无需像JavaBean那样为类的属性创建相应的set/get方法。参数的前缀可以为val或var,当为val时,将创建一个不可以变的实例,当为var时,将创建一个可变的实例。如果val和var都没有,将创建一个私有的实例,该实例对其它的类是不可访问的,如下:
scala> class MongoClient(host:String, port:Int)defined class MongoClientscala> val client = new MongoClient("localhost", 123)client: MongoClient = MongoClient@4089f3e5scala> client.host<console>:7: error: value host is not a member of MongoClientclient.host有时需要使用默认的值,这是就没必要在另创建一个不带参数的构造函数了,这种情况可以使用this关键字重载,如下:
class MongoClient(val host:String, val port:Int) {def this() = this("127.0.0.1", 27017)}b、包
在Scala中,packing(包)也是一个对象,作为类和对象的集合,用于对编写的代码进行逻辑分组或命名空间,避免相互冲突。它混合采用了java和C#的包声明方式,当然可以根据自己的喜好,采用java的方式来定义包。如下的几种定义包的方式:
java风格:
package com.scalainaction.mongoimport com.mongodb.Mongoclass 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)}或者
<pre name="code" class="html">package com.scalainaction.mongo {import com.mongodb.Mongoclass 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)}}
或者
<pre name="code" class="html">package com {package scalainaction {package mongo {import com.mongodb.Mongoclass 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)}}}}后一种定义包的方式,如果在一个文件中定义多个包,很容易造成混淆,使用最广泛的定义包方式为在Scala文件的顶部定义包。需要注意的是,Scala包的路径不必和文件系统的目录结构对应。另外,还可以在同一个文件定义多个包,称作包对象。
包对象
package com.persistence {package mongo {class MongoClient}package riak {class RiakClient}package hadoop {class HadoopClient}}将上述代码保存为Packages.scala文件,当用scalac Packages.scala命令编译这个文件时,会看到Scala编译器在相应的文件目录中创建了class文件来匹配包的声明,这保证了创建的类符合JVM要求,即包的声明必须和文件目录结构对应。
包对象的一个用处是可以在包中定义一些辅助方法,这样在包中的所有成员都可以使用。如下:
package.scala文件:
package object bar {val minimumAge = 18def verifyAge = {}}
<pre name="code" class="html">BarTender.scala文件:
package barclass BarTender {def serveDrinks = { verifyAge; ... }}
c、导入
Scala的导入和java的导入很像,都是通过import关键字来导入引用的类,但又有些不同,例如:
导入某包下的所有类是用“_”:import com.mongodb._
看下面的例子:
package monads { class IOMonad }package io {package monads {class Console { val m = new monads.IOMonad }}}如果试着编译上面的例子,将会得到一个错误:“IOMonad isn’t available”,这是因为编译器是在io.monads包中找IOMonad类,而不是在顶层的monads包中找。如果要引用顶层的包,可以使用"_root_":
val m = new _root_.monads.IOMonad
另外,如果创建的类或对象没有包的声明,那么它们就属于empty package包,而empty package包是不能导入的,但是empty package包中的成员是可以相互看的见的。
有时,会导入不同包中的同名的类,很容易造成混淆,这时可以通过指定别名的方式来加以区分,如下:import java.util.Dateimport java.sql.{Date => SqlDate}import RichConsole._val now = new Datep(now)val sqlDate = new SqlDate(now.getTime)p(sqlDate)
d、对象和伴生对象(Objects and companion objects)
Scala是一种纯面向对象的语言,每个值都是对象,每个操作都是方法调用,每个变量都是某些对象的成员。Scala中没有static修饰符,因为这不符合它纯面向对象的设计目标,并且在代码中使用static修饰符可能会有副作用。相反,Scala通过single object(单例对象)来替代static。Scala创建single object是挺简单的,如下:
object RichConsole {def p(x: Any) = println(x)}调用p方法,可以通过对象名来调用,如:RichConsole.p("xx")
伴生对象
在Scala中,当一个对象和一个类同名时,这个对象叫做companion object(伴生对象),这个类叫做companion class(伴生类)。如下:
package com.scalainaction.mongoimport com.mongodb.{DB => MongoDB}class DB private(val underlying: MongoDB) {}object DB {def apply(underlying: MongoDB) = new DB(underlying)}
首先,DB类的主构造函数声明为private,意味着其他的类或对象都不能使用它,除了companion object(伴生对象)。在Scala中,只有伴生对象可以访问伴生类中的私有成员,其它的外部类都不可以访问。
Scala的特质(trait)可以起到代码复用的作用,它和抽象类很相似,可以定义成员变量、抽象方法和具体方法,不同的是抽象类可以有构造参数,而trait不可以带有任何参数。另外,与类的继承不同(每一个类只能继承一个类),一个类可以混入任意多的trait,这又和java的接口很相似。
通常,trait以混入(mixin)的方式混入到类中,可以使用extends或with关键字把trait 混入(mixin)到类中,这里的混入和其它语言的多重继承有重要的差别。使用extend关键字混入trait,这种情况下隐式地继承了trait的超类。使用with关键字混入trait,此时的类还可以继承其他的类。
混入的顺序很重要,越靠近右侧的特质越先起作用。当你调用带混入的类的方法时,最右侧特质的方法首先被调用,如果那个方法调用了super,它调用其左侧特质的方法,以此类推。
另外,特质还可以作为类型,在定义变量时可以指定变量的类型为trait类型。
特质主要有两种常用的使用方式,一种是把瘦接口(接口中定义的方法较少)转变为胖接口(接口中定义的方法较多)。另一种是为类提供可堆叠的改变。这两种使用方式下面会做详细介绍。
1、类线性化
先看个问题:UpdatableCollection 类继承了DBCollection类,同时又混入Updatable特质,而DBCollection类和Updatable特质都继承了ReadOnly特质,ReadOnly中有一具体的实现方法find(),那么在UpdatableCollection类中调用find()方法,将产生歧义,因为有两条路径可以到达ReadOnly特质。看具体的示例:
class UpdatableCollection extends DBCollection(collection(name)) with UpdatableUpdatableCollection类的继承关系图如下:
Scala通过使用类的线性化类处理这种问题,类线性化指定了类到达祖先类(Any类)的一条路径,其中包括普通的超类和特质。通常采用先从最右侧(为类声明语句的最右侧),深度优先搜索,去掉除在层次结构中最后一个匹配的类,来确定类线性化的路径。
Scala中所有类的超类为Any(相当于Java中的Object类)。从上图可以判断每个对象的线性化路径为:
特质ReadOnly :ReadOnly -> AnyRef -> Any
特质Updatable :Updatable -> ReadOnly -> AnyRef -> Any
类DBCollection : DBCollection -> ReadOny -> AnyRef -> Any
类UpdatableCollection :UpdatableCollection -> Updatable -> DBCollection -> ReadOnly -> AnyRef -> Any
---------------------------------------------------------------
另一个例子:假设你有一个类 Cat,继承自超类 Animal 以及两个特质 Furry 和 FourLegged, FourLegged 又扩展了另一个特质 HasLegs。
class Animaltrait Furry extends Animaltrait HasLegs extends Animaltrait FourLegged extends HasLegsclass Cat extends Animal with Furry with FourLegged类 Cat 的继承层级和线性化次序展示在下图。继承次序使用传统的 UML 标注指明:白色箭头表明继承,箭头指向超类型。黑色箭头说明线性化次序,箭头指向 super 调用解决的方向。
当这些类和特质中的任何一个通过super调用了方法,那么被调用的实现将是它线性化的右侧的第一个实现。
2、堆叠
Scala特质的堆叠特性,可以在不修改现有组件的前提下,添加或修改组件的行为。
f、Case Class(样本类)
Scala中,Case Class是一种特殊的类,通过使用case修饰符创建样本类,当编译器在编译时遇到case class时,会自动生成一些样本代码,如下:
1、构造函数的参数默认为val修饰符,意味着这些参数为public成员。
2、自动生成hashCode、equals、toString方法。
3、自动生成的copy()方法,可以较简便的创建类实例的完整或部分变更副本。
4、每个Case类默认都实现了scala.Product特质和scala.Serializable特质。
5、每个Case类都带有apply()和unapply()方法,这样在创建类实例时,就不用通过new 关键字,可以直接使用类名加参数来创建。
像其它的类一样,Case类也可以继承其它类,包括特质和Case类,但是,当Case类定义为abstract case class时,编译器将不会再为其自动生成apply()方法,因为抽象类不可以被实例化。另外,还可以创建case object,这样该object就为单例对象和序列化的了,这种情况通常用于在网络上传送消息,并发编程时比较常用。
Case Class 常用于模式匹配,如下例子:
scala> case class Person(firstName:String, lastName: String)defined class Personscala> val p = Person("Matt", "vanvleet")p: Person = Person(Matt,vanvleet)scala> p match { case Person(first, last) => println(">>>> " + first + ", " + last) }>>>> Matt, vanvleet上如代码让人感兴趣的是,通过模式匹配,first和last的值是怎么从p对象中抽取出来的?其实,在后台,Scala通过unapply()方法来处理这种问题的。如果手动写Person类的伴生对象,应该像下面例子代码:
object Person {def apply(firstName:String, lastName:String) = {new Person(firstName, lastName)}def unapply(p:Person): Option[(String, String)] =Some((p.firstName, p.lastName))}对于apply()方法,在创建case Person类实例的时候,他将会被调用,并返回一个case Person类的一个实例。而unapply()方法是在case实例进行模式匹配是被调用的,通常unapply()方法会进行拆解case实例,并返回case类的元素(本例中为firstName和lastName)。
g、命名参数、默认参数、复制构造函数(copy constructor)
命名参数
通常,在调用函数时,参数传入是按定义时的参数顺序来传递的,从Scala2.8开始,Scala提供了一种可以通过参数名来传递值,这样就可以按任意顺序来出入参数了。这样做可以避免传入同类型的参数时混淆参数的含义,同时也增强了可读性。如下例:
按顺序传入参数:
scala> case class Person(firstName:String, lastName:String)defined class Personscala> val p = Person("lastname", "firstname")p: Person = Person(lastname,firstname)按名称传入参数:
scala> val p = Person(lastName = "lastname", firstName = "firstname")p: Person = Person(firstname,lastname)默认参数
默认参数的定义形式为arg: Type = expression,如:def methodA(name: String = "xxx"),当调用methodA()时,“name”就会使用默认值“xxx”
复制构造函数
命名参数和默认参数一个非常有用的运用是编译器自动为case类生成copy方法。这个方法采取一种轻量级的语法来创建一个原始实例的修改拷贝。copy方法具有和被拷贝的case类的基本构造方法同样类型和参数,并且每个参数都使用基本构造方法中相应值作为默认值。
case class A[T](a: T, b: Int) {// def copy[T'](a: T' = this.a, b: Int = this.b): A[T'] = new A[T'](a, b)}val a1: A[Int] = A(1, 2)val a2: A[String] = a1.copy(a = "someString")h、修饰符
Java中的访问修饰符有四种private(私有的)、protected(受保护的)、public(公共的)、包级别(默认没有任何修饰符),而在Scala中同样也有这几种修饰符,不同的是
Scala中包、类或对象的访问修饰符默认为public,并且在某种程度上,基本废除了包级别的访问限制。
private修饰符仅可以对类内部成员、伴生对象或伴生类可见。见下例:
class Outer { class Inner { private def f() { println("f") } class InnerMost { f() // OK } } (new Inner).f() // Error: f is not accessible}另外,还可以对类和包限定修饰符,如下:
package outerpkg.innerpkg class Outer { class Inner { private[Outer] def f() = "This is f" private[innerpkg] def g() = "This is g" private[outerpkg] def h() = "This is h" } }这里可以在Outer类内部的任何地方访问f()方法,但在其外部却不可以。g()方法仅可以在包outer.innerpkg内部访问。h()方法仅可以在outerpkg及其子包内部访问。
另外还可以对this对象限定修饰符,这样,this就为私有对象,表示仅可以被同一对象调用。
protected修饰符仅可以被定义他的类及其子类,还有伴生对象及伴生对象的所有子类访问。protected同样也可以作用于包、类、this。
同Java一样,Scala也提供了override修饰符,用于重写父类成员,不同的是Scala中的override修饰符是强制的。另外,override还可以和abstract修饰符组合,这种情况只适用于特质(trait),并且混入此特质的类或特质必须要有一个具体的实现。如下:
trait DogMood { def greet }trait AngryMood extends DogMood { override def greet = { println("bark") super.greet // Error }}此处不能这样调用super.greet,因为它是抽象的,如果非要这么调用,可以加上abstract修饰符,来堆叠该特质,混入到具有具体greet方法实现的类。如下:
trait AngryMood extends DogMood { abstract override def greet = { println("bark") super.greet }}
另外,Scala还提供了一个新的修饰符:sealed(密封),该修饰符主要有2个作用:
1、其修饰的trait,class只能在当前文件里面被继承。
2、用sealed修饰这样做的目的是告诉scala编译器在检查模式匹配的时候,让scala知道这些case的所有情况,scala就能够在编译的时候进行检查,看你写的代码是否漏掉什么没case项,减少编程的错误。
i、值类(value class)
详见http://blog.csdn.net/qiruiduni/article/details/46763759
j、隐式类
k、继承体系
- Scala的面向对象
- Scala的面向对象
- 6.Scala的面向对象
- Scala-面向对象的函数编程
- Scala 的面向对象编程基础
- Scala 的面向对象编程实践(一)
- Scala 的面向对象编程实践(二)
- Scala 的面向对象编程实践(三)
- Scala面向对象的一部分内容
- Scala面向对象
- Scala面向对象学习
- Scala面向对象
- Scala面向对象
- scala面向对象
- Scala 面向对象编程
- 5.Scala面向对象
- scala面向对象编程
- Scala面向对象编程
- 詩經甲骨文解讀:山有樞
- 浏览网页背后的心理学:你是否也这么想?
- 社説 20150624 首相沖縄訪問 現実的な基地負担軽減を図れ
- [Leetcode]Two Sum
- 【我们都爱Paul Hegarty】斯坦福IOS8公开课个人笔记35 UITextField文本框
- Scala的面向对象
- 多校对抗赛 2015年6月22
- Nova 扩展支持ipsan API源代码解析
- 异常java.lang.NoSuchMethodError: javax.persistence.Table.indexes()[Ljavax/persistence/Index;处理办法
- 业界资讯:Flash Professional CC 2015
- 社説 20150624 骨太方針素案 財政再建への踏み込みが甘い
- add-apt-repository:command not found 问题
- Linux服务器安装redis
- Android消息推送完美方案