Swift学习－属性（十）
//存储属性
//简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。
struct FixedLengthRange {
var firstValue:Int
let length:Int
}
//length在创建实例的时候被初始化，因为它是一个常量存储属性，所以之后无法修改它的值
var rangeOfThreeItems = FixedLengthRange(firstValue: 1, length: 3)
rangeOfThreeItems.firstValue = 6
/*常量结构体的存储属性
因为rangeOfFourItems被声明成了常量（用let关键字），即使firstValue是一个变量属性，也无法再修改它了。
这种行为是由于结构体（struct）属于值类型。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
属于引用类型的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。
*/
let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
//不能更改，报错
//rangeOfFourItems.firstValue = 5
print(rangeOfFourItems.firstValue) // 0
class DataImporter {
var fileName = "data.txt"
}
/*延迟存储属性
延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。
注意：必须将延迟存储属性声明成变量（使用var关键字），因为属性的初始值可能在实例构造完成之后才会得到。
而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
*/
class DataManager {
//声明延迟属性
lazy var importer = DataImporter()
var data = [String]()
}
let manager = DataManager()
manager.data.append("Some Data")
manager.data.append("Some Other Data")
print(manager.importer.fileName)
//这个时候DataManager实例的importer属性才被创建
//注意：如果一个被标记为lazy的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
/*计算属性
类、结构体和枚举可以定义计算属性。计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，
来间接获取和设置其他属性或变量的值。
计算属性必须声明为变量而不能声明为常量（包括只读属性）
*/
struct Point {
var x = 0.0, y = 0.0
}
struct Size {
var width = 0.0, height = 0.0
}
struct Rect {
var origin = Point()
var size = Size()
var center:Point {
// get方法
get {
let centerX = origin.x + size.width / 2
let centerY = origin.y + size.height / 2
return Point(x: centerX, y: centerY)
}
// set方法（newCenter:新值的参数名）
set(newCenter){
origin.x = newCenter.x - (size.width / 2)
origin.y = newCenter.y - (size.height / 2)
}
}
}
var square = Rect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
let initialSquareCenter = square.center
print(initialSquareCenter)
//Point(x: 5.0, y: 5.0)
square.center = Point(x: 15.0, y: 15.0)
print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
//square.origin is now at (10.0, 10.0)
/*便捷setter声明
如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称newValue。
*/
struct AlternativeRect {
var origin = Point()
var size = Size()
var center:Point {
get {
let centerX = origin.x + size.width / 2
let centerY = origin.y + size.height / 2
return Point(x: centerX, y: centerY)
}
set {
origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2)
}
}
}
//只读计算属性，可以省略get关键字和花括号
struct Cuboid {
var width = 0.0, height = 0.0, depth = 0.0
var volume:Double {
return width * height * depth
}
}
/*属性观察器
察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。
可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）
添加属性观察器。
注意：
不需要为非重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。
可以为属性添加如下的一个或全部观察器：
willSet在新的值被设置之前调用
didSet在新的值被设置之后立即调用
*/
class StepCounter {
var totalSteps:Int = 0 {
// 赋值前调用
willSet(newTotalSteps) {
print("About to set totalSteps:\(totalSteps) to \(newTotalSteps)")
}
// 赋值后调用
didSet {
if totalSteps > oldValue {
print("Added \(totalSteps - oldValue) steps")
print("totalSteps:\(totalSteps), oldValue:\(oldValue)")
}
}
}
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 10
//About to set totalSteps:0 to 10
//Added 10 steps
//totalSteps:10, oldValue:0
stepCounter.totalSteps = 120
//bout to set totalSteps:10 to 120
//Added 110 steps
//totalSteps:120, oldValue:10
/*全局变量和局部变量
全局变量：在函数、方法、闭包或任何类型之外定义的变量
局部变量：在函数、方法或闭包内部定义的变量
计算属性和属性观察器可用于全局变量局部变量
全局的常量或变量都是延迟计算的，跟延迟存储属性相似，不同的地方在于，
全局的常量或变量不需要标记lazy特性。
局部范围的常量或变量不会延迟计算。
*/
//定义全局willSet,didSet
var globalVar:Int = 0 {
willSet(newValue) {
print(newValue)
}
didSet{
print(globalVar)
}
}
globalVar = 1000
//1000
//1000
//定义全局get set
var gset:Int = 0
var globalVarGetSet:Int {
get {
return 5
}
set {
gset = newValue
print("gset:\(gset)")
}
}
globalVarGetSet = 10 //gset:10
print("globalVarGetSet:\(globalVarGetSet)") //globalVarGetSet:5
/*类型属性（属于类的属性，不属于类实例）
实例的属性属于一个特定类型实例，每次类型实例化后都拥有自己的一套属性值，实例之间的属性相互独立。
也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是类型属性。
使用关键字static来定义类型属性。在为类（class）定义计算型类型属性时，可以使用关键字class来支持子类对父类的实现进行重写。
值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样只能定义成变量属性。
注意：
跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。
*/
struct SomeStructure {
static var storedTypeProperty = "Some value."
static var computedTypeProperty:Int {
return 1
}
}
enum SomeEnumeration {
static var storedTypeProperty = "Some value."
static var computedTypeProperty:Int {
return 6
}
}
class SomeClass {
static var storedTypeProperty = "Some Value."
static var computedTypeProperty:Int {
return 27
}
//这里有class关键字 子类重写的时候不用加override
class var overrideableComputedTypeProperty: Int {
return 107
}
}
class SubClass: SomeClass {
// 重写父类属性（如果父类没有class关键字声明 这里要加上override）
var overrideableComputedTypeProperty:Int{
return 20
}
}
let subClass = SubClass()
print(subClass.overrideableComputedTypeProperty) // 20
//获取类属性值
print(SomeStructure.storedTypeProperty)//Some Value
//设置类属性值
SomeStructure.storedTypeProperty = "Another value"
print(SomeStructure.storedTypeProperty)//Another Value