swift 系统类添加属性 swift 类型属性

值类型和引用类型中可以通过外部访问的成员（除了方法外）都叫做属性。

swift中到底存在多少种属性？

1.存储属性

类和结构体的成员变量或者成员常量都属于存储属性。

struct FixedLengthRange{
var firstValue:Int 
let length: Int
}
//创建结构体对象，并初始化结构体中属性
var rangeOfThreeItems = FixedLengthRange(firstValue:0,length:3)
rangeOfThreeItems.firstValue = 6
println(rangeOfThreeItems.firstValue)

let rangeOfThreeItems = FixedLengthRange(firstValue:0,length:3)
rangeOfThreeItems.firstValue = 6//this is wrong.
println(rangeOfThreeItems.firstValue) 

class NewProduct{
var name:String = ""
var price:Float = 120
}
var newProduct = NewProduct()
println(newProduct.name)

注意：所有值类型的常量，其内部所有的成员也同样不可修改。例如，前面代码中如果将var rangeOfThreeItems 写成 let rangeOfThreeItems ,即使FixedLengthRange中有变量，也不可以修改变量值。

2.惰性存储属性

只有在第一次访问该属性时才进行初始化。主要是在处理非常消耗资源的初始化工作时非常拥有，只有需要消耗这些资源时才消耗。

class DataImporter{
  var fileName= “data.txt”
  fun process() -> String{
      println("process")
      //本来这里应该读取data.txt文件
      return "data.txt"
    }
}

class DataManager{
lazy var  importer = DataImporter().process()//懒属性，只有在第一次使用此属性时才被初始化。
 var data = [String]()
}

let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
println(manager.data)
//现在DataImporter.process 方法还没有被调用
println(DataManager().importer)//此处用到DataManager().importer，实行了懒属性的懒加载

输出如下内容：

1.    [Some data,Some more data]
2.    process
3.    data.txt

而如果去掉lazy，输出如下内容：

1.    process
2.    [Some data,Some more data]
3.    process
4.    data.txt

3.可读写的计算属性 （get 、set）

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()
//Point 是center属性的数据类型，必须指定
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(myCenter){
   origin.x = myCenter.x - (size.width /2 )
   origin.y = myCenter.y - (size.height / 2)
 }
 }
}

4.只读计算属性

如果将计算属性中的set去掉，则该属性为只读计算属性，只能获取该属性的值，不能设置属性的值。（不可加get、set关键字，否则不为只读属性）

struct Cuboid{
var width = 0.0 , height = 0.0 , depth = 0.0
var volume:Double{
   return width * height * depth
}
}

5.属性观察器

当设置属性相关。当设置属性之前，会调用willSet观察器，并将新设置的属性值传入willSet观察器。设置完属性后，又会调用didSet观察器，并将就该属性旧的值传入didSet观察器。

class StepCounter{
   var totalSteps: Int = 0 
   {
        willSet(newTotalSteps){
              print("New value is \(newTotalSteps)")
         }
        didSet(myOldValue){
            print("Old value is \(myOldValue)")
       }
   }
}

let stepCounter = StepCounter()
 stepCounter.totalSteps = 200 
 stepCounter.totalSteps = 360
stepCounter.totalSteps = 896
 
New value is 200
Old value is 0
New value is 360
Old value is 200
New value is 896
Old value is 360

如果不在willSet 和didSet 后面的圆括号中指定参数名，则willSet 中默认的参数名是newValue,didSet中默认的参数名是oldValue。

class StepCounter{
     var totalSteps: Int = 0 {
    willSet{
          print("New value is \(newValue)")
    }
    didSet{
     print("Old value is \(oldValue)")
    }
  }
}

注意：willSet 和 didSet 不能和 set、get 一起使用，这一点使用时要注意。

全局变量也可以使用：

var totalSteps: Int = 0{
     willSet(newTotalSteps){
         print("New value is \(newTotalSteps)")
     }
    didSet(myOldValue){
       print("Old value is \(myOldValue)")
    }
}
totalSteps = 123
var origin = Point(x:200,y:200)
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(myCenter){
     origin.x = myCenter.x-(size.width/2)
     origin.y = myCenter.y-(size.height/2)
 }
}
print("x=\(center.x),y=\(center.y)")

输出内容如下：

New value is 123
Old value is 0
x=200.0,y=200.0

5.静态属性

静态计算属性不需要创建对象，可以直接从类、结构体和枚举类型中引用。用该类型创建的对象共享一个表态属性。结构体和杖举类型使用static声明表态属性，而类需要使用class声明表态属性。

struct MyStructure{
//静态计算属性
   static var computedTypeProperty:String{
      return "Hello world"
      }
    static var typeProperty:Int = 20
}

enum MyEnumeration{
      static var storedTypeProperty = "Some value."
//静态计算属性
   static var computedTypeProperty:Int{
   get{
       return 200
     }
}
}

class MyClass{
  //静态计算属性
  class var computedTypeProperty:Int{
    return 123
   }
}
}

class MyClass{
   //静态计算属性
  class var computedTypeProperty:Int{
      return 123
}
}
print(MyClass.computedTypeProperty)
print(MyEnumeration.computedTypeProperty)
print(MyStructure.typeProperty)

结果：

123
200
20