代码改变世界

F#探险之旅(四):面向对象编程(中)

2008-10-07 22:58 Anders Cui 阅读(...) 评论(...) 编辑 收藏

F#系列随笔索引

对象表达式(Object Expressions)

F#中的OOP语法很简洁,而对象表达式则正是这种简洁性的核心所在。通过对象表达式,我们可以创建抽象类或接口的轻量级实现,也可以对一个具体的类进行继承。换言之,可以在实现抽象类或接口,或者继承具体类的同时创建新类型的一个实例。下面来看如何对泛型接口IComparer<’T>应用对象表达式。

F# Code
#light
open System
open System.Collections.Generic

let revStringComparer =
{
new IComparer<string>
with
Compare(s1, s2) =
let rev (s : string) =
new string(Array.rev(s.ToCharArray()))
let reversed = rev s1
reversed.CompareTo(rev s2)
}

let winners = [| "Sandie Shaw"; "Bucks Fizz"; "Dana International"; "Abba" |]

print_any winners
print_newline()
Array.Sort(winners, revStringComparer)
print_any winners


运行结果为

Output
[|"Sandie Shaw"; "Bucks Fizz"; "Dana International"; "Abba"|]
[|"Abba"; "Dana International"; "Sandie Shaw"; "Bucks Fizz"|]


这里演示了实现IComparer的过程,该接口有一个方法Compare,它接受两个参数并通过返回值来表示参数比较的结果。它是泛型接口,这里的类型参数为string,可以在标识符revStringComparer定义的第二行看到。从标识符的名字也可以了解到,它是将参数颠倒后进行比较,运行结果的第二行印证了这一点。可以看到“在实现接口的同时返回一个实例”。

看看多重继承的情况。在C#中,一个类不能继承多个类,却可以同时实现多个接口,F#也是一样的。要注意的是,如果同时继承类并实现接口,须将类的部分房子最前面;而且必须在第一个类/接口定义完毕之后才能开始第二个接口的实现。

多重继承的例子


在对象表达式makeNumberControl中,它继承了Control类,同时也实现了IComparable接口。这里可以看到,在CompareTo方法中根据控件的Tag值进行比较,在调用Sort方法(ResizeArray即泛型类List<’T>)时会根据Compare方法对控件进行排序。排序完成后,依次呈现这些控件,如下图:


对象表达式是一种强大的机制,可以帮助我们快速而简洁地将非F#库中的对象引入F#代码。它的缺点则是没法添加额外的属性或方法。这也是在前面的例子中为何使用Tag属性来存放n的值。

定义接口

接口仅包含抽象的方法和属性。它为所有实现它的类定义了一份“契约”。F#中接口的概念与C#中的相同,在此不再赘述。如:

F# Code
type MyInterface = interface
abstract ChangeState : int -> unit
end


实现接口

实现接口的语法也很简单。仍以上面的接口为例:

F# Code - 实现接口


运行结果为:

Output
1
2


不知你有没有注意到,在调用ChangeState方法前,我们先将impl转换为了MyInterface类型,否则不能调用。这是因为接口在F#中是显式实现的,如果希望不经转换就可以直接调用接口的方法,只能在类中在显式地添加这个方法:-(

类、字段和显式的构造函数

前面我们主要还是使用非F#库中的类,现在来看看如何定义自己的类。

F# Code
#light
type EmptyClass = class
end

let emptyItem = new EmptyClass()


嗯,很明显,这里试图定义一个类,然后创建它的一个实例。不过编译器不允许你这么做,它会告诉你:“error FS0191: No constructors are available for the type 'EmptyClass'”。没有构造函数?如果你是C#程序员就会觉得奇怪了。事实上,F#没有提供默认的构造函数这种机制,我们必须得手工添加一个,构造函数的名字总是为new

F# Code
type EmptyClass = class
new() = {}
end


另外,默认的构造函数容易使得字段不能正确地初始化,会给程序带来隐患,而在F#中的构造函数必须初始化所有字段。使用val关键字定义字段,在下面的类MyFile中,它拥有两个字段,path和innerFile,两个字段在构造函数内进行初始化。

F# Code
#light
open System.IO

type MyFile = class
val path : string
val innerFile : FileInfo
new() = new MyFile("default.txt")
new(p) =
{ path = p;
innerFile =
new FileInfo(p) }
end


我们还可以看到,这个类有两个构造函数,也就是说构造函数可以重载。观察构造函数new(p),它有一部分在{}内,这个代码块称为构造函数的初始化块,在这里唯一能做的事情就是初始化字段。如果想做更多的事情,就要在后面加then添加其它代码:

F# Code
type MyFile2 = class
val path : string
val innerFile : FileInfo
new(p) as x =
{ path = p;
innerFile =
new FileInfo(p) }
then
if not x.innerFile.Exists then
let textFile = x.innerFile.CreateText()
textFile.Dispose()
end


new(p)后面加了as x,这样就可以在后面的代码中引用当前的对象了。then后面的代码首先检查文件是否存在,如果不存在就创建一个新文件。

注意:上面两个类MyFile和MyFile2中的字段都是只读的,如果需要修改它们,可以在字段名字前面添加关键字mutable,如val mutable innerFile;同时它们的访问修饰符都是public,在下一篇文章将介绍如何在类中定义属性。

思考:在函数式编程(下)中,曾介绍过自定义的记录类型,比如

F# Code
type couple = { him : string; her : string }


那么这里的couple类和上面的MyFile类主要有哪些区别呢?请出我们的老朋友.NET Reflector来吧。在Reflector中打开编译过的F#程序集可以看到,couple的类型定义为:

Type Infomation
public sealed class couple : IStructuralHash, IComparable


这是一个sealed类,这意味着无法继承它,其中的her和him都是只读属性。
而MyFile的定义则是:

Type Infomation
public class MyFile


这个就跟C#中常规类的定义一致了,其中的path和innerFile都是只读属性。

隐式的类构造(Implicit Class Construction)

除了上面的显式构造函数,F#还支持隐式的类构造语法这样的语法更为紧凑。它允许在定义类的成员前执行一系列的let值绑定语句,这些绑定属于类的私有部分

F# Code - 隐式的类构造
#light
open System.IO

type MyOtherFile(path) = class
let innerFile = new FileInfo(path)
member x.InnerFile = innerFile
end


我觉得对于前面的(显式的类构造)MyFile类定义,这里的MyOtherFile类当然更为紧凑,看起来在定义类的同时就定义了构造函数,随后马上初始化了字段,不过这里的innerFile已经是私有的了,所以再添加一个属性InnerFile来公开innerFile字段。

隐式的类构造要比等价的显式类构造代码少很多,但是有时必须要用显式的类构造,比如编写拥有多个构造函数的类的时候。

小结

本文首先介绍了强大的对象表达式机制,通过它,我们可以快速地创建抽象类或接口的轻量级实现;接下来是定义和实现接口;最后介绍了如何创建和实例化一个类,在创建类实例的时候,我们既可以采用显式的构造函数,也可以采用更为紧凑的“隐式的类构造”机制。

F#系列随笔索引

注意:本文中的代码均在F# 1.9.4.17版本下编写,在F# CTP 1.9.6.0版本下可能不能通过编译。

参考:
《Foundations of F#》 by Robert Pickering
《Expert F#》 by Don Syme , Adam Granicz , Antonio Cisternino
F# Specs