计算属性
/*
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()