Swift之属性

存储属性

• 存储常量或者变量的
• 要么给它默认值，要么在构造方法里初始化

计算属性

• 计算属性不直接存储值
• 访问时候调用get,赋值调用set,类似java里的封装
• get里一定要有return
• set中有一个内置的newValue变量,用于接收外界赋的新值
• set里不能给当前的计算属性赋值，否则死循环
• 只读计算属性：只提供get，没有set，在写的时候可以省略get{}

类属性

• 类属性用static修饰
• 类属性是和类关联的，而不是单独属于某个对象
• 只能通过类名来访问，这点和java不同

class Student{
    //存储属性
    var age:Int = 0
    var javaScore:Double = 0.0
    var htmlScore:Double = 0.0
    
    //计算属性
    var averageScore:Double {
        //获取值
        get{
            print("get被调用")
            return (javaScore+htmlScore)/2  //get中必须有return语句
        }
        //赋值
        set{
            print("set被调用,\(newValue)")
            //self.averageScore = newValue  不要再set里给计算属性赋值，否则死循环
        }
    }
    
    
    //只读计算属性
    var averageScore2:Double {
        //获取值
        get{
            print("get被调用")
            return (javaScore+htmlScore)/2  
        }
       
    }
    //只读计算属性-省略get{}
    var averageScore3:Double {
        //获取值
            print("get被调用")
            return (javaScore+htmlScore)/2  
    }
    
    //类属性
    static var courseCount:Int = 2
    
}
var stu = Student()
//使用存储属性
stu.age = 18
stu.javaScore = 90
stu.htmlScore = 60

//使用计算属性
print(stu.averageScore)
stu.averageScore = 100

//只读计算属性
print(stu.averageScore2)
print(stu.averageScore3)

//使用类属性
print(stu.courseCount)//不能通过对象访问
print(Student.courseCount)

懒加载属性(懒属性)

懒加载属性的引入

• 需求：需要对区间进行计算，假设该计算计算量很大，很耗时,把最终计算结果放到result变量中

class CloseRange{
    var start:Int = 0
    var end:Int = 1000
    //方案：result设计为计算属性
    var result:Int{
        get{
            print("开始计算...")
            var res = 0
            //此时采用求和操作来模拟进行大量计算。
            for i in self.start...self.end{
                res += i
            }
            return res
        }
    }

var range = CloseRange()
print(range.result)
print(range.result)
print(range.result)
print(range.result)

• 思考：把result属性定义为计算属性有没有什么缺陷？
• 缺陷：每访问一次，就计算一次，计算结果没法存储下来。
• 改进：用的时候，才会计算，计算1次，并且能把计算结果保存下来。--》引入懒加载属性来解决

懒加载的使用：

lazy var 变量：类型 = { 代码段}()

• 只会赋值一次
• 只有在第一次使用的时候，才会执行闭包，然后把闭包返回值赋值给属性
• 用的时候，才会计算，计算1次，并且能把计算结果保存下来

class CloseRange{
    var start:Int = 0
    var end:Int = 1000
     //方案：result设计为懒加载属性
    lazy var result:Int = {
            ()->Int  in 
             print("开始计算...")
            var res = 0
            //此时采用求和操作来模拟进行大量计算。
            for i in self.start...self.end{
                res += i
            }
            return res
    }()
}

var range = CloseRange()
print(range.result)//只有第一次调用的时候执行闭包，干活只干1次！
print(range.result)
print(range.result)
print(range.result)

属性观察器

• 监听和响应属性值的变化
• 针对存储属性和类属性的变化
• 怎么实现？为观察的属性添加观察器
  willSet 在赋新值之前调用，使用内置变量newValue
  didSet 赋新值之后调用,使用oldValue

class Student{
    //存储属性
    var age:Int = 0
    var javaScore:Double = 0.0
    var htmlScore:Double = 0.0
    
    //属性观察器
    var name:String = "test"{
        willSet{
            print("willSet被调用，newValue的值\(a)")
        }
        didSet{
             print("didSet被调用,oldValue的值\(b)")
        }
    }
    
}
var stu = Student()
stu.name = "miao"
stu.name = "123"

不同使用场景剖析

懒加载属性使用场景

场景一：位置的定位

class Location{
    let latitude:Double //经度
    let longitude:Double  //纬度
    init(latitude:Double,longitude:Double){
        self.latitude = latitude
        self.longitude = longitude
    }
    lazy var address:String = {
        //进行经纬度分析,复杂的计算
        return "xxxx"
    }()
}

场景二：阅读类APP
问题：书本的内容到底时候加载到内存里？
在访问列表页：书名、封面、简介，不需要加载书本的内容
在详情页，只有用户点击阅读，加载内容到内存里。

class Book{
    let name:String = ""
    
    lazy var content:String = {
         //从网络读取
         return "xx"
    }()
}

属性观察器使用场景

有一个设备，对通电的最大电流值有要求，最高30。
要求对current属性重新设计，满足如下：

1. < 30, 提示正常赋值
   2）= 30，提醒你已经到最大值
   3）>30 ,提醒用户，当前电流太高，此次赋值失败，回到原始值。

class Machine{
    let max = 30 //允许通过的最大电流
    var current = 10 {
        willSet{
            if newValue < max{
                print("正常赋值")
            }
            if newValue == max{
                print("注意！当前电流已经到达最大值")
            }
            
        }
        didSet{
            if current > max{
                print("注意！当前电流已经超过最大值30，回滚到原来的值")
                current = oldValue
            }
        }
    }
}
var m1 = Machine()
m1.current = 20
m1.current = 30
m1.current = 100
print(m1.current)