Swift学习笔记二

浏览数：23 / 时间：2015年06月08日

Swift是苹果公司开发的一门新语言，它当然具备面向对象的许多特性，现在开始介绍Swift中类和对象的语法。

对象和类

用"class"加上类名字来创建一个类，属性声明和声明常量或者变量是一样的，只是它是在类里边声明的而已。方法和函数声明也是一样的：

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

创建类对象也很简单，注意这里没有用new关键字，类对象的属性和方法的访问方式是通过.实现的

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

类的声明里边，通常都会有初始化方法init，

class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

注意这里用self来指代当前类对象，这样就区分了属性name和传入init方法的参数name。

每个属性都需要被赋值，要么在声明它的时候，或者在初始化方法中。

用deinit方法来创建解构函数，在类对象被释放之前做一些清理工作。

类的继承语法也很简单，用冒号加上父类名称就可以了。没有约定子类必须要继承自哪些根类，因此继承不是必须的。子类通过override标识覆盖父类方法。如果子类中有与父类同名的方法而没有override，则编译器会报错。编译器也会探测标识了override但是父类中又没有同名的方法。

class Square: NamedShape {
    var sideLength: Double
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }
    
    func area() ->  Double {
        return sideLength * sideLength
    }
    
    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)."
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

简单属性可以直接保存，属性也可以有存取器：

class EquilateralTriangle: NamedShape {
    var sideLength: Double = 0.0
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    
    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)."
    }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
println(triangle.perimeter)
triangle.perimeter = 9.9
println(triangle.sideLength)

在setter中，新值的名称隐式地是newValue，也可以在set后显示地指明别的名称。

如果你的属性不需要计算，但是在设定值之前或者之后仍然需要写一些逻辑，可以用willSet和didSet，比如，下边的类就确保它的三角形的边长和正方形的边长始终相等：

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
println(triangleAndSquare.square.sideLength)
println(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
println(triangleAndSquare.triangle.sideLength)

类的方法和一般函数有一个很重要的区别。一般函数的参数名只在函数内部被用到，但是类方法的参数名在你调用方法的时候也被用到了(第一个参数除外)。默认情况下，当你调用某个方法的时候，该方法与其内部都有相同的参数名。你可以指定另外的名称，这个名称将在方法内部使用：

class Counter {
    var count: Int = 0
    func incrementBy(amount: Int, numberOfTimes times: Int) {
        count += amount * times
    }
}
var counter = Counter()
counter.incrementBy(2, numberOfTimes: 7)

当处理可省略变量的时候，可以在运算比如属性、方法、下标操作之前加上问号。如果问号之前的值是nil，问号之后的所有表达式被忽略掉，整个表达式的值也是nil。否则，可省略值被展开，问号之后的所有表达式都基于展开的可省略值。无论如何，整个表达式的值都是可省略值。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

枚举类型和结构体

用enum来创建枚举类型变量。像类和其他类型一样，枚举类型也可以有与之相应的方法：

enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
        case .Queen:
            return "queen"
        case .King:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
}
let ace = Rank.Ace //Enum Value

let aceRawValue = ace.rawValue //1

在上边的例子里，枚举类型变量Rank的原始类型(raw-type)是Int类型，因此只需要给第一个值赋值，剩下的值会一次自动赋予。也可以把枚举变量的原始类型设定为字符串或者浮点数，用rawValue来获取枚举变量的原始值。用init?(rawValue:)初始化器从一个原始值创建一个枚举类型的实例。

if let convertedRank = Rank(rawValue: 3) {
    let threeDescription = convertedRank.simpleDescription()
}

枚举类型的成员值就是实际的值，并不是原始值(raw value)的另一种书写方式，事实上，并没有所谓的真正意义上的原始值，并不需要为每个枚举类型成员赋原始值

enum Suit {
    case Spades, Hearts, Diamonds, Clubs
    func simpleDescription() -> String {
        switch self {
        case .Spades:
            return "spades"
        case .Hearts:
            return "hearts"
        case .Diamonds:
            return "diamonds"
        case .Clubs:
            return "clubs"
        }
    }
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()

注意这里用了两种引用枚举类型实例的成员值的方式：当把它作为值复制给常量hearts时，是用的显示地指明全称Suit.Hearts，因为常量没有隐式地指明类型；而在switch内部，枚举类型的成员值是用简写方式.Hearts被引用的，这是因为self的类型已经是已知合适的类型了。在任何变量类型已知并且合适的时候，都可以使用这种简写方式。

结构体

用struct关键字来创建结构体，结构体支持很多类的行为，包括方法和初始化器。结构体和类最大的区别在于当在代码里传递的时候，结构体永远是被拷贝的，而类只传递了引用。

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())" //在字符串中直接引用表达式或者变量
    }
}
let threeOfSpades = Card(rank: .Three, suit: .Spades) //注意这种简写形式，是因为rank和suit的变量类型都已经确定了
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

枚举类型成员的实例可以拥有和实例关联的值(associated value)，枚举类型成员的不同实例可以有不同的值和它们相关联，这些关联值是在创建实例的时候提供的。

关联值(associated value)和原始值(raw value)是不同的：枚举类型成员的原始值对所有实例而言是相同的，在定义该枚举类型的时候就需要给出原始值。

举个栗子，在向一个服务器请求日出和日落时间的数据，服务器的返回分为两种情况：返回相应的时间或者返回一个错误

enum ServerResponse {
    case Result(String, String)
    case Error(String)
}
 
let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")
 
switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
    let serverResponse = "Failure...  \(error)"
}