存储属性
1.存储常量或者变量的
2.要么给它默认值，要么在构造方法里初始化
计算属性
1.计算属性不直接存储值
2.访问时候调用get,赋值调用set,类似java里的封装
3.get里一定要有return
4.set中有一个内置的newValue变量,用于接收外界赋的新值
5.set里不能给当前的计算属性赋值，否则死循环
6.只读计算属性：只提供get，没有set，在写的时候可以省略get{}
类属性
1.类属性用static修饰
2.类属性是和类关联的，而不是单独属于某个对象
3.只能通过类名来访问，这点和java不同
//存储属性
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)
懒加载属性(懒属性)
懒加载属性的引入
1.需求：需要对区间进行计算，假设该计算计算量很大，很耗时,把最终计算结果放到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)
2.思考：把result属性定义为计算属性有没有什么缺陷？
3.缺陷：每访问一次，就计算一次，计算结果没法存储下来。
4.改进：用的时候，才会计算，计算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)
属性观察器
1.监听和响应属性值的变化
2.针对存储属性和类属性的变化
3.怎么实现？为观察的属性添加观察器
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 = "duan"
stu.name = "0820"
不同使用场景剖析
懒加载属性使用场景
场景一：位置的定位
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 "xxxx"
}()
}
属性观察器使用场景
有一个设备，对通电的最大电流值有要求，最高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 = 30
m1.current = 40
m1.current = 100
print(m1.current)