Swift－计算属性

计算属性

/*
 5、计算属性
（1）Swift中计算属性不直接存储值，跟存储属性不同，没有任何的“后端存储与其对应”
（2）计算属性用于计算，可以实现setter和getter两种计算方法
（3）枚举不可以有存储属性，但是允许有计算属性
 
 对象.属性 ＝ 值           setter
 let value = 对象.属性    getter
 */
print("5、计算属性")
struct MyRect {
    var origion:(x:Double,y:Double) = (0,0){
        willSet{
            print("will set:\(newValue.x),\(newValue.y)")
        }
        didSet{
            print("did set:\(oldValue.x),\(oldValue.y)")
        }
    }
    var size:(w:Double,h:Double) = (0,0)
    //计算属性无论是只读还是读写，都要使用var关键字声明
    var center:(x:Double,y:Double){
        get {
            return (origion.x + size.w/2,origion.y + size.h/2)
        }
        set {
            //origion是存储属性，可以被赋值
            //center ＝ n,center是一个计算属性，不可以被赋值
            origion.x = newValue.x - size.w/2
            origion.y = newValue.y - size.h/2
        }
    }
}
var rect = MyRect()
//rect.size = (100,100)//setter
rect.origion = (10,10)
//print("x=\(rect.center.x),y=\(rect.center.y)")//getter
//rect.center = (60,100)//setter
//print("x=\(rect.origion.x),y=\(rect.origion.y)")


/*
 6、只读计算属性
 */
print("\n6、只读计算属性")
struct MyStudent {
    var name:String
    var chinese:Double
    var math:Double
    func showStudent(){
        print("姓名：\(name),语文：\(chinese),数学：\(math)")
    }
}

class MyClass{
    var members:[MyStudent] = []
    //班级学生总成绩  lazy关键字延迟存储属性
    lazy var score:Double = self.getSorce()
    var average:Double{
        get{
            var sum :Double = 0
            for i in members {
                sum += i.chinese
                sum += i.math
            }
            if members.count > 0 {
                return sum / Double(members.count)
            }else{
                return 0
            }
        }
    }
    func getSorce() -> Double {
        print("lazy property")
        var sum :Double = 0
        for i in members {
            sum += i.chinese
            sum += i.math
        }
        if members.count > 0 {
            return sum / Double(members.count)
        }else{
            return 0
        }
    }
    func show(){
        for i in members {
            i.showStudent()
        }
    }
}
let s0 = MyStudent(name:"zhang",chinese:100,math:100)
let s1 = MyStudent(name:"wang",chinese:90,math:90)

let c0 = MyClass()
c0.members.append(s0)
c0.members.append(s1)
//print(c0.getSorce())
print("======")
print(c0.score)
//c0.average = 90
print("只读计算属性不可修改值\(c0.average)")

/*
 7、属性观察器
 属性被修改时可以调用我们视线写好的代码去额外执行一些操作（类似OC中KVO）
 两种属性观察器
 （1）willSet    在设置新值时调用
 （2）didSet     在新值设置之后调用
 可以直接为除lazy属性之外的存储属性添加属性观察器，也可以在继承类中为父类的计算属性提供观察器
 */
print("\n7、属性观察器")

/*
 8、类型属性
 （1）为“类”本身定义属性，这样的属性不隶属于某一个“对象”，可以认为所有的对象功用这个属性
 （2）结构体或者枚举可以定义存储或者计算型“类属性”，而类只能定义计算型类型属性
 对象.属性
 类名称.属性
 */
print("\n8、类型属性")
struct TypeProperty {
    var property:Int = 0
    static var staticProperty:Int = 0
    func test() {
        print("property=\(property),staticProperty=\(TypeProperty.staticProperty)")
    }
}
var type = TypeProperty()
var type1 = TypeProperty()
type.property = 10//属于某个对象，对象.调用
type1.property = 20
TypeProperty.staticProperty = 10//属于某个类，使用类调用
type.test()
type1.test()