属性

1.例子如下

    struct some{
            var firstValue :  Int
            let length : Int
    }
    var rangeOfThreeItems = FixedLengthRange(firstValue:0,length:3) //0,1,2
    rangeOfThreeItems,firstValue = 6      //6,7,8

但是 如果是这样

    let rangeOfThreeItems = FixedLengthRange(firstValue:0,length:3) //0,1,2
    rangeOfThreeItems,firstValue = 6      //报错

为什么会报错呢？
因为rangeOfThreeItems被声明成常量，即使firstValue是变量，也没办法修改值，结构体是值类型。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。但是如果是类则可修改实例的变量属性，因为类是引用类型。

2.延迟存储属性

    当第一次调用时才会计算初始值的属性。用`lazy`标示。

注意：只有变量var能被标示延迟存储，因为属性的初始值可能在实例构造完成之后才得到。
如果一个呗标记为lazy的属性在没有被初始化就同时被多个线程访问，则无法保证该属性会被初始化一次。

3.储存属性和实例变量

• 计算属性

    struct Point{
        var x = 0.0 , y = 0.0
    }
  
    struct Size{
        var widrh = 0.0 , height = 0.0
    }
  
    struct Rect{
        var origin = Point()
        var size = Size()
        var center:Point {
            get{
                  let centerX = origin.x + (size.width/ 2)
                  let centerY = origin.y + (size.width/ 2)
                  return Point(x:centerX,y:centerY)
            }
            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 squareCenter = square.center
    square.center = Point(x:15.0,y:15.0)
  

其中set如果没有自定义表示新值的参数名，可使用默认名称newValue

如果是只读属性，则可以省略get关键字和花括号

    struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
    return width * height * depth
  }
}
  let fourByFiveByTwo = Cuboid(width: 4.0, height:5.0, depth: 2.0)
  print("the volume of fourByFiveByTwo is \    (fourByFiveByTwo.volume)")
  // 输出 "the volume of fourByFiveByTwo is 40.0"

4.属性观察器

当对某个属性进行操作之前或之后需要进行某个操作，可以用到属性观察器。

• willSet在新的值被设置之前调用
• didSet在新的值被设置之后立即调用

willSet观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名newValue；
didSet观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名oldValue；如果在didSet方法中再次对该属性赋值，新值会覆盖旧值。

注意：父类的属性在子类的构造器中被赋值时，它在父类中的willSet和didSet 观察器会被调用，随后才会调用子类的观察器。在父类初始化方法调用之前，子类给属性赋值时，观察器不会被调用.

5.全局变量不需要标记lazy修饰符

6.类型属性

• 类型属性分为储存型类型属性和计算型类型属性

• 存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算型属性一样只能定义成变量属性。

• 无论创建多少个该类型的实例，这些属性都只有唯一一份。

• 用于定义某个类型所有实例共享的数据。

• ，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。使用关键字 static 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 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 var     overrideableComputedTypeProperty: Int {
            return 107
        }
    }
  

• 类型属性是通过类型本身通过点语法来访问，而不是通过实例

方法

1.实例方法

• 实例方法是属于某个特定类、结构体或者枚举类实例的方法。与函数的语法完全一致。

• 用点语法调用实例方法。

• 实例方法的参数跟函数参数一样，可以同时有一个内部参数名和外部参数名

• 默认给第一个参数名称一个局部参数名，默认给第二个和后续参数局部参数名和外部参数名。

• 可以为第一个参数添加一个显式的外部名称。

• 如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线_作为该参数的显式外部名称，这样做将覆盖默认行为。

• self 的使用,self代表当前。可以用来区分参数名称和属性名称。

    struct Point {
        var x = 0.0, y = 0.0
        func isToTheRightOfX(x: Double) -> Bool {
            return self.x > x
        }
    }
  

• 在实例方法中修改值类型
  结构体和枚举是值类型，正常情况下是不能在实例方法中修改值的，如果需要修改，可以给这个方法标记为mutating，就可以从内部改变属性值

    struct Point {
        var x = 0.0, y = 0.0
        mutating func moveByX(deltaX: Double, y deltaY: Double) {
            x = deltaX + x
            y += deltaY + x
        }
    }
    var somePoint = Point(x: 1.0, y: 1.0)
    somePoint.moveByX(2.0, y: 3.0)
  

注意：创建Point实例的时候不能用常量let,只能用变量var,否则会报错。

• 在可变方法中给self 赋值

    struct Point {
        var x = 0.0, y = 0.0
        mutating func moveByX(deltaX: Double, y deltaY: Double) {
              self = Point(x: x + deltaX, y: y + deltaY)
        }
    }
  

2.类型方法

• 实例方法是被某个类型的实例调用的方法。类型方法是在类型本身上调用的方法。 在func前加上static来指定方法类型。

• 类型方法和实例方法一样用点语法调用。而且必须在类型上调用而不是实例上。

    class SomeClass {
            class func someTypeMethod() {
                      
             }
    }
  
    SomeClass.someTypeMethod()