Swift之属性

Swift 属性

属性可分为存储属性和计算属性

• 存储属性：
  1、存储常量或变量作为实例的一部分
  2、用于类和结构体
• 计算属性：
  1、计算（而不是存储）一个值
  2、用于类、结构体和枚举

存储属性和计算属性通常用于特定类型的实例。
属性也可以直接用于类型本身，这种属性称为类型属性。

存储属性

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

简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。
存储属性可以是变量存储属性（用关键字var定义），也可以是常量存储属性（用关键字let定义）。

• 可以在定义存储属性的时候指定默认值
• 也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值

计算属性

1. 计算属性不直接存储值
2. 访问时候调用get,赋值调用set,类似java里的封装
3. get里一定要有return
4. set中有一个内置的newValue变量,用于接收外界赋的新值
5. set里不能给当前的计算属性赋值，否则死循环
6. 只读计算属性：只提供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)