swift课程 02 swift高级

类与结构体的区别：
1）结构体自带一个初始化所有属性的初始化方法，而类带有一个不含任何参数的构造函数
2）结构体是值类型，每次拷贝一份新的内容，修改原来的，不会影响新的
类是引用类型，赋值就像是oc中的指针指向，无论通过哪个变量名修改，都是在操作一个对象

1.类

类的写法

注意：声明类方法:可以在前面添加static关键字，或者添加class关键字
二者的区别：class修饰的方法，子类继承时可以被重写，static 修饰的不可以

// 类的写法
class Person {

    // 声明属性
    var name: String?
    var age: Int = 0

    // 声明类属性
    static var country: String? //子类可以继承


    // 声明方法
    func sayHi() {
        print("name: \(name) age: \(age)")
    }

    // 声明类方法:(可以在前面添加static关键字，或者添加class关键字)
    static func sayHello() { //子类可以继承，但是不可以重写 
        print("你好，我是: \(country) 国家的人")
    }
    class func sayHello2() {
        print("sayHello2")
    }

// 类拥有一个构造函数，但是不包含参数,重写构造函数
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

class Student: Person {
    // 重写父类的方法，需要添加 override 关键字
    override func sayHi() {
        print("Student SayHi: \(self.name)")
    }

    override class func sayHello2() {  //添加class 可以使得子类重写父类的类方法
        print("Student SayHello2")
    }

}

创建对象，并且调用方法

//let修饰，但是可以修改内部的属性值，只是不可以给person整体赋值，eg：不可以person = p
let person = Person(name: "da hua zi", age: 12)
person.name = "大华子"

计算属性

class Rect {
    var x: Int!
    var y: Int!
    var width: Int!
    var height: Int!

    // 计算属性
    var centerX: Int {  //注意没有‘=’
        get {
            return x + width / 2
        }
        set {
            print(newValue)
        }
    }
    var centerY: Int {
        get {
            return y + height / 2
        }
        set {
            print("newValue: \(newValue)")
        }
    }


    // 构造函数
    init(x: Int, y: Int, width: Int, height: Int) {
        self.x = x
        self.y = y
        self.width = width
        self.height = height
    }
}

计算属性的使用

let rect = Rect(x: 10, y: 20, width: 100, height: 100)
rect.centerX = 1000
print(rect.centerX)  //值是60，并非后面的赋的值

2.协议
注意：声明协议方法，默认必须实现

protocol MarryProtocol {

    //声明协议方法,默认必须实现
    func test1()
    func test2()
}

//声明可选的协议方法 @objc  
@objc protocol MarryProtocol2 {

    optional //只管一个，test4必须实现
    func test3()

    func test4()
}

定义一个类，并且遵守协议

class LaTiao: MarryProtocol, MarryProtocol2 {  //父类和协议都放在类名后，父类名只能写一个，协议可以多个,只有一个时，会自动识别是父类还是协议

    func test1() {

    }
    func test2() {

    }

    //如果实现可选协议方法，在没有父类的情况下，需要添加@objc关键字
    //如果实现可选协议方法，有父类，直接写就可以了
    @objc func test4() {

    }
}

3.extension
swift中没有类目，但是extension的作用类似类目
注意：既可以给结构体扩展方法，也可以给类扩展方法

//给类扩展方法
extension Person {
    func sayHello() {
        print("hello")
    }
}

//给结构体扩展方法
extension Int {
 test(a: Int) -> Int {
        var i = 1
        for _ in 1...a{
            i *= self
        }

        return i
    }
}
let res = 2.test(4)

4.闭包
闭包类似 block

声明闭包变量

var sumClosure: ((a: Int, b: Int) -> Int)? //可选

var sumClosure2: ((Int, Int) -> Int)? //可以省略参数名

给闭包赋值

sumClosure2 = { (a: Int,b: Int) -> Int in
    return a + b
}

sumClosure2 = { (a, b) ->Int in
    return a + b
}

sumClosure2 = { (a, b) in
    return a + b
}

sumClosure2 = { a, b in
    return a + b
}

sumClosure2 = { a, b in
    a + b
}

sumClosure2 = {
    $0 + $1  //表示参数1加参数2
}

调用

let resu = sumClosure2!(23, 54)

给闭包起别名

typealias Closure = (Int, Int) -> Int