Swift－计算属性

忘是亡心i 2023-10-17 09:39 8阅读 0赞

计算属性

/*
     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()

![Center][]

[Center]: https://img-blog.csdn.net/20161204220528660?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center