Swift 2 学习笔记 13.属性和方法

课程来自慕课网liuyubobobo老师

属性和方法

• 计算属性

struct Point {
    var x = 0.0
    var y = 0.0
}

struct Size {
    var width = 0.0
    var height = 0.0
}

class Rectangle {
    var origin: Point
    var size: Size
    var center: Point {
        get{
            let centerX = origin.x + size.width/2
            let centerY = origin.y + size.height/2
            return Point(x: centerX, y: centerY)
        }
        set{
            origin.x = newValue.x - size.width/2
            origin.y = newValue.y - size.height/2
        }
    }

    init(origin:Point, size: Size) {
        self.origin = origin
        self.size = size
    }
}

var rect = Rectangle(origin: Point(), size: Size(width: 10, height: 5))
rect.center  // x 5 y 2.5

rect.origin = Point(x: 10, y: 10)
rect.center  // x 15 y 12.5

rect.center = Point()
rect.origin  // x -5 y -2.5

• 类型属性

class Player {
    var name: String
    var score = 0
    static var highestScore = 0
    
    init(name: String) {
        self.name = name
    }
    
    func play() {
        let score = Int(arc4random()%100)
        print("\(name) played and got \(score) scores.")
        self.score += score
        print("Total score of \(name) is \(self.score)")
        if self.score > Player.highestScore{
            Player.highestScore = self.score
        }
        print("Hightest score is \(Player.highestScore)")
    }
}

let player1 = Player(name: "player1")
let player2 = Player(name: "player2")

player1.play()  // Hightest score is 34
player1.play()  // Hightest score is 116

player2.play()  // Hightest score is 116

• 类型方法

struct Matrix {
    ...
    static func identityMatrix(n: Int) -> Matrix? {
        // 创建一个单位矩阵
        ...
        return Matrix(arr2d)
    }
}

if let im = Matrix.identityMatrix(6) {
    ...
}

• 属性观察器

class LightBulb {
    static let maxCurrent = 30
    var current = 0 {
        willSet{
            print(newValue)
        }
        didSet{
            if current > LightBulb.maxCurrent {
                print("Fallint back to previous setting")
                current = oldValue
            }
            print(current)
        }
    }
}

let bulb = LightBulb()
bulb.current = 20  // newValue:20 oldValue:0
bulb.current = 40  // newValue:40 oldValue:20
// didSet是对属性值已经发生变化的观察，是对oldValue的操作
// willSet是对属性值将要发生变化的观察，是对newValue的操作
// didSet willSet 不会在初始化阶段被调用

• 延迟属性

class ClosedRange {
    let start: Int
    let end: Int
    
    // 计算型属性不会储值，多次调用会多次计算
    var width: Int {
        return end - start + 1
    }
    
    // 延迟属性：只计算一次并存下来，只有调用不再计算
    // 赋值时相当于执行了一次闭包，闭包中属性使用内容捕获需要写明确
    lazy var sum: Int = {
        var res = 0
        for i in self.start...self.end{
            res += i
        }
        return res
    }()

    init?(start: Int, end: Int) {
        if start > end {
            return nil
        }
        self.start = start
        self.end = end
    }
}

if let range = ClosedRange(start: 0, end: 10000){
    range.width
    range.sum
    range.sum
    range.sum
    // 只计算一次
}

• 访问控制

// public 可以被模块外访问
// internal 可以被本模块访问
// private 可以被本文件访问

• 单例模式初探

public class GameManager {
    public var score = 0
    public static let defaultGameManager = GameManager()
    
    // 将初始化方法变为私有
    private init() {
    
    }
    
    public func addScore() {
        self.score += 10
    }
}

let gameManager = GameManger.defaultGameManager
gameManager.addScore()
gameManager.score  // 10

let gm = GameManger.defaultGameManager
gm.addScore()
gm.score  // 20