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

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • swift 官方教程 学习笔记
    1、范型范型所解决的问题 函数、方法、类型：类，结构体，枚举，元组类型，协议参数，返回值，成员函数参数，成员属性类...
    我是小胡胡123阅读 868评论 0赞 1
  • Swift2.0笔记
    常量与变量使用let来声明常量，使用var来声明变量。声明的同时赋值的话，编译器会自动推断类型。值永远不会被隐式转...
    莫_名阅读 467评论 0赞 1
  • Swift 120 分钟入门教程
    Hello Word 在屏幕上打印“Hello, world”，可以用一行代码实现： 你不需要为了输入输出或者字符...
    restkuan阅读 3,236评论 0赞 6
  • Swift 4.0 编程语言（七）
    132.转换错误成可选值 通过转换错误成一个可选值,你可以使用 try? 来处理错误。当执行try?表达式时,如果...
    无沣阅读 1,299评论 0赞 3
  • 二郎神，你为啥和妹妹、外甥过不去？
    今天的梗要从昨天的主角儿“沉香”说起。由于《宝莲灯》的故事流传的实在太广，就和86版西游记电视剧一样，不少读...
    瓦钢阅读 1,102评论 0赞 3