类和结构体

定义语法

class SomeClass {
    // class deFinition goes here
}
struct SomeStructure {
    // structure deFinition goes here
}

结构体有有构造器方法，用于初始化结构体中的成员变量。而类没有默认的成员逐一构造器
结构体是值类型，类是引用类型

let vga = Resolution(width:640,height: 480)

属性

储存属性

延迟储存属性

延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 lazy 来标示一个延迟存储属性。

注意：

必须将延迟属性声明成变量（var），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值,因此无法声明成延迟属性。

class Dataimporter {
    /* Dataimporter 是一个将外部文件中的数据导入的类。这个类的初始化会消耗不少时间。 */
    var fileName = "data.txt"
    // 这是提供数据导入功能 
}
class DataManager {
    lazy var importer = Dataimporter() var data = [String]()
    // 这是提供数据管理功能
}

let manager = DataManager() manager.data.append("Some data") manager.data.append("Some more data")

定义属性时，如果不是可选类型？（optional type），那么必须给赋值，即在类初始化方法里赋值，或者在声明命变量的时候赋值

var a: String  // 不给初值或者未在初始化方法里初始化，抱错
var a: String? // 这样就不用担心啦

计算属性

除了储存属性外，类结构体和枚举可以定义计算属性。计算属性不直接储存值，而是提供一个getter和一个可选的setter，来间接获取和设置其他属性或者变量的值。

struct Point {
    var x = 0.0,y = 0.0
}
struct Size {
    var width = 0.0,height = 0.0
}
struct Rect {
    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(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
} }
var square = Rect(origin: Point(x: 0.0,y: 0.0),size: Size(width: 10.0,height: 10.0))
let initialSquareCenter = square.center
square.center = Point(x: 15.0,y: 15.0)
print("square.origin is Now at (\(square.origin.x),\(square.origin.y))") // 输出 "square.origin is Now at (10.0,10.0)”

属性观察器

属性观察器监控和响应属性值的变化,每次属性被设置值的时候都会调用属性观察器,甚至新的值和现在的值相同的时候也不例外。

可以为属性添加如下的一个或全部观察器:

willSet在新的值被设置之前调用
didSet在新的值被设置之后立即调用

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to \(newTotalSteps)")
}
didSet {
            if totalSteps > oldValue  {
                print("Added \(totalSteps - oldValue) steps")
} }
} }
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// About to set totalSteps to 200
// Added 200 steps
stepCounter.totalSteps = 360
// About to set totalSteps to 360
// Added 160 steps
stepCounter.totalSteps = 896
// About to set totalSteps to 896
// Added 536 steps

通过闭包和函数来设置属性的默认值

如果某个存储型属性的默认值需要特别的定制或准备,你就可以使用闭包或全局函数来为其属性提供定制的默认
值。每当某个属性所属的新类型实例创建时,对应的闭包或函数会被调用,而它们的返回值会当做默认值赋值给
这个属性。

class SomeClass {
    let someProperty: SomeType = {
}

struct Checkerboard {
    let boardColors: [Bool] = {
    var temporaryBoard = [Bool]()

    var isBlack = false
        for i in 1...10 {
            for j in 1...10 {
              temporaryBoard.append(isBlack)
                isBlack = !isBlack

                }
            isBlack = !isBlack
        }
        return temporaryBoard
        }()
    func squareIsBlackAtRow(row: Int,column: Int) -> Bool {
        return boardColors[(row * 10) + column]
    }
}

let board = Checkerboard() print(board.squareIsBlackAtRow(0,column: 1)) // 输出 "true" print(board.squareIsBlackAtRow(9,column: 9)) // 输出 "false"

方法

和OC差不太多

继承

和java差不太多

Swift学习之路05-类和结构体