1、什么是属性

属性是对象的性质与对象之间关系的统称。属性就是变量或者常量，附着到类的实例中。

2、存储属性

        /**
         存储属性
         */
        class Car {
            var  priceValue = 0
        }
        /* 获取实例 */
        let myCar = Car()
        print(myCar.priceValue)
        /**
         注释： priceValue 是存储在对象中的一个简单值，它称为存储属性。
         */

3、计算属性

1、什么是计算属性

要定义一个计算属性，可以像声明存储属性一样声明一个变量，但在后面增加大括号。在这些大括号内部，提供一个get部分，还可以提供一个set部分。

2、计算属性的创建

        class NetWorkRectangle  {
            var width:Double = 0.0
            var height = 0.0
            /* 面积*/
            var area:Double  {
                /* 计算面积*/
                get {
                  return width * height
                }
                /* 计算宽高 */
                set {
                    width = sqrt(newValue)
                    height = sqrt(newValue)
                }
            }
        }

3、计算属性的调用

        /* 创建实例*/
        let rect = NetWorkRectangle()
        rect.width = 100
        rect.height = 200
        print(rect.area)
        /* 输出：20000.0 */
        rect.area = 1000
        print(rect.width,rect.height)
        /* 输出： 31.6227766016838 31.6227766016838 */

4、属性观察器

1、什么是属性观察器

所谓的观察属性是指属性发生变化的时候，会执行某些代码。这个代码可以在即将发生变化之前或者刚刚发生变化之后运行。

2、如何定义一个属性观察器

要创建一个属性观察器，需要在属性后面添加大括号，并包含willSet 和didSet代码块。这些代码块分别获得一个参数---willSet 在属性值发生变化之前被调用，他将获得一个将要设定的值，而didSet 则获取一个旧值

3、属性观察器的例子

        class PropertyObserver {
            var number:Int = 0 {
                willSet(newValue) {
                   print("willSet  to  \(newValue)")
                }
                didSet(oldValue){
                  print("oldValue fo \(oldValue) to \(self.number)")
                }
            }
        }
        /**
         注释：关于你对属性的实际处理方式，属性观察器不会进行任何更改，它们只是在属性变化前后增加附加行为。
         */

4、属性观察器的使用

        /* 创建实例 */
        var observer = PropertyObserver()
        /* 给其属性赋值，查看其变化*/
        observer.number = 150
        /* 输出 ： 
         willSet  to  150
         oldValue fo 0 to 150
         */

5、懒惰性属性

1、什么是懒惰性属性

懒惰性就是直到首次访问时才会设定属性。设置懒惰性的方法：为了将一个属性定义为懒惰性，可以在它的前面放一个 lazy 的关键字

2、懒惰性属性的例子

        class Log{
            init(id :Int) {
                 print(" Example class \(id) created")
            }
        }
        
        class lazyExample {
            var number = Log(id:110)
            lazy var numberLazy = Log(id:220)
            init() {
                 print("init  lazyExample")
            }
        }

3、懒惰性的调用

        /* 创建实例对象*/
        var LazyObject = lazyExample()
        /*输出： Example class 110 created */
        var ob = LazyObject.number
        /*输出：无
         因为：number 对象已经创建
         */
        var ob1 = LazyObject.numberLazy
        /**
         输出：init  lazyExample
         Example class 220 created 
         */