Swift类

Swift中类以关键字class开头

1.最基本例子

class Shape {  //类名
    var numberOfSides = 0  //类属性(全局变量)
    func simpleDescription() -> String {  //类方法
        return "A shape with \(numberOfSides) sides." }
}

2.重写init方法

class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    init(name: String) { //重写默认的init方法
        //name在init时就赋值，这样设置的属性一般不会在后续代码中修改其值
        self.name = name
    }
    func simpleDescription() -> String {
        return "A shape name :\(name) with \(numberOfSides) sides."
    }
    
    deinit{  //重写默认的销毁方法(相当于delloc)
        
    }
}

var nameShape = NamedShape(name: "Test Shape")
nameShape.numberOfSides = 5
nameShape.simpleDescription()

3.继承

/*
重写init方法，注意Swift和OC不同。Swift的super.init是确保所有子类的属性都初始化完成后书写的，不像OC基本都是写在最前面。原因是，编辑器在执行子类init的init时会优先判断子类自己能不能被成功创建。如果不行，也就没必要去init父类，这样更加节省资源。
所以在Swift中子类的初始化顺序是：
1.设置子类声明属性的值
2.调用父类的初始化器
3.更改父类中定义的属性值。任何额外的设置工作,如使用方法、getter 或 setter 也可以在这里完成（可选操作）
*/
class Square: NamedShape {
    var sideLength: Double
    //重写init方法
    init(sideLength: Double , name: String) {
        self.sideLength = sideLength  //先实例化子类变量
        super.init(name: name)  //父类init
        numberOfSides = 4  //父类属性值更改
    }
    
    func area() -> Double {  //子类方法
        return sideLength * sideLength
    }
    //override 关键字  代表重写
    override func simpleDescription() -> String {
        return "A square with name: \(name) , numberOfSides:\(numberOfSides) , sides of length \(sideLength)."
    }
}

var test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

4.属性关联，get 和 set 的用法
get/set被称为"计算属性"，它们不直接存储值,但是可用来操作其他属性值的变化

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 {  //重写perimeter的get方法
            return 3.0 * sideLength
        }
        set { //重写perimeter的set方法
            sideLength = newValue / 3.0
        }
    }
    override func simpleDescription() -> String {
        return "An equilateral triagle with sides of length \(sideLength) , perimeter is \(perimeter) ."
    }
}

5.属性监视器（willSet/didSet）
如果方法本身不需要计算某个属性,但方法中的属性仍然需要提供在运行之前和设置新值后的代码,可以使用 willSet 和 didSet (属性监视器)。

//TriangleAndSquare类要确保其三角的边长和正方形的边长一样。
class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        //这个类本身不需要对sideLength进行计算，但它里面的属性需要根据sideLength变化而变化
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
    square = Square(sideLength: size, name: name)
    triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}

let triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
triangleAndSquare.square.sideLength   //输出10
triangleAndSquare.triangle.sideLength  //输出10
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
triangleAndSquare.triangle.sideLength  //输出50

6.函数、方法、实例方法、类方法
在其他语言中，可能函数和方法是分开来的，相互不包括的，但是在Swift中。方法就是函数的一种。一切使用"func"关键字的为都是函数，在外面的是函数，在类中的就是称他为方法，方法中又分"实例方法"和"类方法"

class Counter {
    var count: Int = 0
    //对于incrementBy1来说numberOfTimes是外部参数名，times是内部参数名
    func incrementBy1(amount: Int, numberOfTimes times: Int) {
        count = amount * times
    }
    //"_"关键字代表可以外部调用时可以省略参数名
    func incrementBy2(amount: Int,_ times: Int) {
        count = amount * times
    }
    //类方法加上关键字class，类方法不能使用类中的属性
    
}

func incrementBy4(var a1: Int,a2: Int) {
    a1 = a1 + a2
}

var counter = Counter()
counter.incrementBy1(2, numberOfTimes: 7) //实例方法
counter.incrementBy2(2,7)  //实例方法
incrementBy4(1, a2: 2)  //函数

7.类属性和类方法

class TestCount {
    var testInt:Int = 10 //实例属性
    //类属性 类属性中只允许使用计算属性（get\set）
    class var baseInt:Int{
        return 10  //这个是简写的get，这个属性是只读属性
    }
    class func incrementBy3(times: Int) ->Int {
        return baseInt * times
        //return testInt * times  //类方法不能调用实例属性
    }
}

TestCount.baseInt  //调用类属性，类不需要实例化
TestCount.incrementBy3(2) //调用类方法，类不需要实例化

8.下标, 或者叫附属脚本(subscript)。
可以定义在 类/结构体/枚举中，进行快速访问。

/*
//格式：也可以设定set/get(和类方法很相似)
subscript(index:Int) -> Int{
    get{

    }
    set{

    }
}
*/
struct Person12{   //定义一个结构体
    let baseLength:Int
    //结构体在这里可以不写初始化方法，会自动生成
    subscript(index:Int) -> Int{ //下标方法，无方法名
        return baseLength * index
    }
}

var p12 = Person12(baseLength: 10)
p12[3]     //直接像访问数组一样访问.

9.可选值
当与可选值一起工作时,你可以在操作前写“?”,类似于方法、属性和下标。如果在“?”之前该值已经是 nil,所有“?”之后的东西都会自动忽略,整个表达式的值就是 nil。否则,可选值是未包装的,所有“?” 之后的均视为未包装值。在这两种情况下,整个表达式的值是一个可选值。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

10.lazy关键字
使用lazy(延迟)关键字存储属性: 当使用该属性时才进行初始化, 好处是避免空间浪费

class Person1{
    var name = "jack"
    //    class var height:Int = 10   //错误! 类中不能有全局存储属性的, 只能是计算属性. 见下文说明
}

class Person3{
    var name:String = "xuneng"  //需要手动初始化
    var age:Int = 10
    let height = 175
    lazy var p1:Person1 = Person1() //延迟关键字, 必须是var
}

var p3 = Person3()
p3.name   //通过点语法来访问
p3.age = 11   //设置
print(p3.p1)   //这句调用时, p1才进行初始化