swift类与结构

类与结构

swift的结构体增添了很多类的功能： 定义函数，定义下标，有构造函数,可以扩展，还可以遵循协议来提供某种标准化的功能。
并且结构有一个默认的逐一构造函数(每个属性都有的初始化函数).

结构和枚举是值类型 类是引用类型

在Swift中，很多基本数据类型，例如String、Array和Dictionary都是用结构实现的。也就意味着他们被赋值给一个常量或者变量、或者被传入一个方法时是通过复制的方式实现的。

一,属性

swift有两种属性。1 存储属性 2 计算属性
存储属性就是平时我们理解的属性，这个计算属性意思是可以通过存储属性计算出来的。上代码一看便知：

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()
//这个center是通过已知属性计算出来的(计算属性只能声明成var)
    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(newCenter) {
            //这里不能在调用setcenter ，会导致死循环
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

在上面代码中origin和size是存储属性，center是计算属性.他里面这个set方法是可以改变相关存储属性值得。当没有set方法的时候叫做 “只读计算属性”,这时候可以吧get{ }省略，只留get里面的东西就可以了如下。

struct Rect {
    var origin = Point();
    var size   = Size();
    var center:Point{
        let centerX = origin.x + (size.width / 2);
        let centerY = origin.y + (size.height / 2);
        return Point(x: centerX, y: centerY);
    }
}

懒惰属性

当属性第一次被使用的时候才被初始化,就是oc中经常用哪个懒加载.只不过不用我们在getter方法里面自己判断为空的时候再初始化，声明的时候前面加一个lazy就哦了

lazy var obj = SomeClass();

属性观察者

可以为每个属性添加一个willSet，didSet来监听属性值的变化.这个比较方便，不用像oc那样添加观察者.

    var age : Int {
        willSet{
        //此时age还没有改变，swift添加了默认参数newValue表示新值
       //这里如果再调用 set age 不会造成死循环
      // age = 10
        }
        
        didSet{
        //此时age已经改变，同样swift自动添加了参数oldValue表示之前的值
        }
    }

如果一个带有观察者的属性被被当做in-out参数使用的时，会引起观察者被调用.

类属性

类属性和其他语言一样是属于类的属性，可直接通过类名使用，swift中结构，枚举，类都可以定义类属性.语法是在前面加一个static关键字, 可以是var 和 let

在为类定义计算型类型属性时，可以改用关键字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来声明类属性，因为overrideableComputedTypeProperty是个计算属性，并且希望子类可以重写这个计算实现
    class var overrideableComputedTypeProperty: Int {
        return 107
    }

}

通过闭包设置默认属性

注意闭包结尾的大括号后面接了一对空的小括号。这用来告诉 Swift 立即执行此闭包。如果你忽略了这对括
号，相当于将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。

还有闭包中不能使用实例的其他属性，因为此时实例还没有初始化文成，也不能用self。

class SomeClass {
  let someProperty: SomeType = {
    // 在这个闭包中给 someProperty 创建一个默认值
    // someValue 必须和 SomeType 类型相同
    return someValue
  }()
}

二, 方法

swift的类，结构和枚举都可以定义实例方法和类方法，是的没错 枚举也可以定义方法.

特点

1, 结构和枚举都是值类型。默认情况下，值类型的属性在自己的实例方法内部是不能修改的。就是说枚举和结构中的方法在默认情况下不能修改自身的属性。如果想修改，要在方法前面添加mutating 关键字.
2, swift函数的参数有两个标签
外部标签是为了提高代码的可读性，swift和oc一样努力让方法调用看起来想一个句子般易读。

func someFunc(外部调用参数  函数局部变量名:Int){ 函数内容}

 func someFunc(outParam  inParam:Int){  }
//调用时候是这样的
someFunc(outParam: 5);
//这个outParam可以不加 那么默认用inParam
func someFunc( inParam:Int){  }
someFunc(inParam: 5)

//如果一个都不想用的话，函数这样声明
func someFunc(_ inParam:Int){}
someFunc(5)

*在方法内部甚至可以给self重新赋值

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}
var somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveBy(x: 2.0, y: 3.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")

//在方法内部甚至可以给self重新赋值
enum TriStateSwitch {
    case off, low, high
    mutating func next() {
        switch self {
        case .off:
            self = .low
        case .low:
            self = .high
        case .high:
            self = .off
        }
    }
}
var ovenLight = TriStateSwitch.low
ovenLight.next()

同样可以使用static来定义类方法，class类型可以使用class关键字，以允许子类重写父类的实现。注意swift的子类可以 重写父类的类方法。

三, 下标

下标语法是提供了一种方式让我们可以通过中括号的方式（ someObj[] ）去调用一段代码，有些时候更加方便的表示一种数据结构。
类，枚举，结构 都可以使用下标语法。

   struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]

    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeat: 0.0, count: rows * columns)
    }

    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }

    subscript(row: Int, column: Int) -> Double {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

//创建一个矩阵
var matrix = Matrix(rows: 2, columns: 2)
//使用下标语法设置矩阵的值(在表示矩阵这种数据结构的时候下标语法会更加清晰易读)
matrix[0, 1] = 1.5
matrix[1, 0] = 3.2

下标语法是这样的：通过 subscript 关键字
这个看起来和计算属性有点像。只不过他不是属性，倒是可以看做一种方法.

subscript(param)->resultType{
  get{

      }
 set{
//set时候会有个默认参数newValue  就是即将set的值
     }
}