swift4.03 學習筆記（2）

對象和類

使用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

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 1、范型范型所解決的問題 函數、方法、類型：類，結構體，枚舉，元組類型，協議參數，返回值，成員函數參數，成員屬性類...
    我是小胡胡123閱讀 863評論 0贊 1
  • 常量與變量使用let來聲明常量，使用var來聲明變量。聲明的同時賦值的話，編譯器會自動推斷類型。值永遠不會被隱式轉...
    莫_名閱讀 467評論 0贊 1
  • Hello Word 在屏幕上打印“Hello, world”，可以用一行代碼實現： 你不需要為了輸入輸出或者字符...
    restkuan閱讀 3,236評論 0贊 6
  • 132.轉換錯誤成可選值 通過轉換錯誤成一個可選值,你可以使用 try? 來處理錯誤。當執行try?表達式時,如果...
    無灃閱讀 1,293評論 0贊 3
  • 今天的梗要從昨天的主角兒“沉香”說起。由于《寶蓮燈》的故事流傳的實在太廣，就和86版西游記電視劇一樣，不少讀...
    瓦鋼閱讀 1,100評論 0贊 3