Swift学习-Property

可以在类、结构体、协议中定义属性，属性可以是变量，也可以是常量。 ###1.在结构体中声明属性:

struct RectStore{
    var length : Int
    var breadth : Int
}
var r = RectStore(length:5,breadth:5)//length = 5
r.length = 6//length = 6

但因为结构体是值引用类型，所以当我们把结构体声明为常量时，是不可以改变结构体内部属性值的。如下：

let r1 = RectStore(length: 5, breadth: 5)
r1.length = 6 //报错：Cannot assign to property: 'r1' is a 'let' constant

###2.懒加载 定义为懒加载的属性

struct Rect{
    
    var length : Int
    let breadth : Int
    
    init(length : Int, breadth: Int) {
        print("Rect struct is initialised now from the lazy var property")
        self.length = length
        self.breadth = breadth
    }
    
}

struct Square{
    
    var sidesEqual : Bool
    
    lazy var r = Rect(length: 6, breadth: 6)
    
    init(sidesEqual : Bool) {
        self.sidesEqual = sidesEqual
    }
}
var s = Square(sidesEqual: false)

if s.sidesEqual
{
    print(s.r.length)
}
else{
    print("Rect struct hasn't been initialised using the lazy var")  //this gets printed
}
//打印结果：Rect struct hasn't been initialised using the lazy var
var s1 = Square(sidesEqual: true)

if s1.sidesEqual
{
    print(s1.r.length)
}
else{
    print("Rect struct hasn't been initialised using the lazy var") //not printed
}
//打印结果：Rect struct is initialised now from the lazy var property   
 6

从上面的例子可以看出，懒加载会在调用之前在初始化。 ####2.1懒加载定义闭包

class Name{
    var name : String?
    lazy var greet : String = {[weak self] in//为了防止循环引用，我们使用weak self
        guard let s = self else {
            return "Unable to unwrap self"
        }//防止循环引用
        guard let n = s.name else {
            return "No name found"
        }
        return "Hi, (n)"
    }()
    init(name : String){
        self.name = name
    }
}
var n = Name(name: "Anupam")
print(n.greet)//打印结果：Hi, Anupam

此时，我们把name置空，看看效果

n.name = nil
print(n.greet)//打印结果：Hi, Anupam

发现打印结果没有改变，上述例子表明，懒加载只初始化一次；所以不论变量如何变化，闭包的结果是不变的. 再看个例子:

//在举个例子
var nn = Name(name : "Bobby")
nn.name = nil
print(nn.greet)//打印结果：No name found

nn.name = "Bobby"
print(nn.greet)//打印结果：No name found

###声明属性,在属性内部实现get、set方法；实现属性的读写

struct Rectengle{
    var length : Double
    let breadth : Double
    var area : Double{
        get{//根据长框，算出面积；当外部直接调用area时，调用
            return length * breadth
        }
        set(newArea){//根据给定的面积、宽，计算出长；当外部给area赋值时调用
            length = newArea / breadth
        }
    }
}

var rs = Rectengle(length:6,breadth:5)
print(rs.area)//打印结果：30.0 调用的是get方法

rs.area = 40
print(r.length)//打印结果：8.0 调用的是set方法
//如果set方法中参数名不明确说明，Swift默认属性名为newValue,可以简化为下面方式
struct RectangleSimply{
    
    var length : Double
    let breadth : Double
    
    var area : Double {
        
        get{
            return length*breadth
        }
        set
        {
            length = newValue/breadth
        }
    }
}

但是需要注意的是： 1、将实现了get、set方法的属性，定义为lazy var；也不能定义为常量。 2、定义了set方法的属性，必须定义get，不然会报错。 3、定义了get方法的属性，可以不定义set方法，此时，属性只支持读，不支持写。

struct readOnlyRect{
    var length : Double
    var breadth : Double
    var area : Double{
        get{
            return length * breadth
        }
    }
    //周长
    var perimeter : Double{
        get{
            return length * 2 + breadth * 2
        }
    }
}
var rr = readOnlyRect(length:6,breadth:5)
print(rr.area)//打印结果：30
rr.area = 40 //报错，因为未实现，set方法；声明变量默认是包含get和set方法，只是读取的是变量本身的值。

###3.属性观察者 对属性变化做出响应，包含两个方法: （1）willSet:在值存储之前触发，它允许我们在值更改之前读取旧值。我们可以使用关键字newValue访问新值。 （2）didSet:在值存储之后触发，它允许我们读取新值和旧值。我们可以使用关键字oldValue访问旧值。 给属性set值时，会触发属性观察者。

struct yardToInchesConversion{
    var yard : Double = 0{
        willSet{
            print("new value of yard (newValue)")
        }
        didSet{
            print("old value of yards (oldValue)")
            inches = yard * 36
            print("Updated value of inches (inches)")
        }
    }
    var inches : Double = 0
}

var yi = yardToInchesConversion()
yi.yard = 22
//打印结果：
//new value of yard 22.0
//old value of yards 0.0
//Updated value of inches 792.0

###4.全局变量和静态变量 静态变量在子类中不能重写

class A {
    var testNumner : Int = 10
    static var i : Int = 5
    static var name : String{
        return "Hello World"
    }
    class var multiplyByANumber: Int {
        return i * 5
    }
    static func printI(){
        print("Value of i is (i)")
    }
    class func appendClassName(){
        print("Class A Hello World")
    }
}

class SubClass : A{
    override class var multiplyByANumber : Int{
        return i * 5 * 5
    }
    override class func appendClassName(){
        print("Class SubClass Hello World")
    }
}

###5.subscript 下标是访问集合、列表、序列元素的捷径，我们是用array[index]、dictionary[key]等，相应的，我们可以定义一个任意类型的下标。我们可以为同一类型定义多个下标，并根据传递给下标的索引值的类型选择要使用的适当下标重载。

class M {
private var month = ["Jan", "Feb", "March", "April"]
subscript(index: Int) -> String {
    get {
        return month[index]
    }
    set(newValue) {
        self.month[index] = newValue
    }
}
}
var m = M()
m[3] //April
m[0] = "Dec"