对象和类

使用class关键字，加类名

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

创建对象的引用，并调用类的参数和方法。

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

带init()的类，self.name表示类自身的属性。

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

实例化是必须要为参数赋值。

var nameShape = NamedShape(name:"zhang")
print(nameShape.name)

实现子类，用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")
print(test.area())
print(test.simpleDescription())

定义参数的getter和setter方法，setter时的newValue为隐式参数。

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")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

willSet执行setter前调用 ，didSet执行setter后调用，oldValue为setter之前的值。

class TriangleAndSquare {
    
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
        
        didSet{
            print("\(oldValue.sideLength);\( triangle.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")
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")

可选值类，如果？前面是nil，后面的就不执行

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

枚举和数据结构

使用enum定义枚举,rawValue默认从0开始，然后依次加1.但是在这里第一个枚举的rawValue被指定为1，因此从1开始依次加1.

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
let aceRawValue = ace.rawValue
print(aceRawValue)
print(Rank.two.simpleDescription())

使用 init?(rawValue:) 初始化枚举

Rank(rawValue: 3)?.simpleDescription()

可自定义value的枚举

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

数据结构

用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)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

协议和扩展

协议

使用protocol关键字声明一个协议

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
} 

类，枚举，数据结构都可以适配协议

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
print(aDescription)
struct SimpleStructure: ExampleProtocol {
     var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
print(bDescription)

enum cDescription:ExampleProtocol{
    case First(String),Second(String)
    
    var simpleDescription: String{
        set{
            switch self {
            case let .First(text):
                self = .First(newValue)
            case let .Second(text):
                self = .Second(newValue)
           
            }
        }
        get{
            switch self {
            case let .First(text):
                return text
            case let .Second(text):
                return text
           
            }
        }
    }
    mutating func adjust() {
        switch self {
        case let .First(text):
            self = .First(text+" enum (adjust)")
        case let .Second(text):
            self = .Second(text+" enum (adjust)")
            
        }
    
    }
}

var c = cDescription.First("zhang")
c.adjust()
print(c)

注意：mutating关键字，让方法可以修改数据结构和枚举自身。类不需要声明mutating，是因为类的方法可以修改类。

扩展

使用extension关键字，可以给已有的类型加上函数

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
print(7.simpleDescription)

错误处理

继承Error协议的任何类型

enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

用throw抛出异常，throws 让函数可以抛出异常

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

错误处理

使用do-catch 抛出异常。在代码前用try抛出代码的异常

do{
print(try send(job:1, toPrinter:"Never Has Toner"))
}catch{
    print(error)
}

多个catch块

do {
    let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
    print(printerResponse)
} catch PrinterError.onFire {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: \(printerError).")
} catch {
    print(error)
}

使用try? 把结果转换为Optional。如果抛出异常就返回nil

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

defer

在函数中使用defer代码块，当函数的其他代码执行完后再执行。defer可以用来做每次代码执行的清理或设置

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]

func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }
    
    let result = fridgeContent.contains(food)
    return result
}
fridgeContains("banana")
print(fridgeIsOpen)

范型

定义一个范型函数

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

可以用相同的形式定义一个枚举，类，数据结构。

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

在函数体的右边使用where，指定一个需求列表。如指定实现协议的类型，两个枚举的类型是相同的，或有指定的父类。

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element {
        for lhsItem in lhs {
            for rhsItem in rhs {
                if lhsItem == rhsItem {
                    return true
                }
            }
        }
        return false
}
anyCommonElements([1, 2, 3], [3])

无戒365挑战营 49