属性
- Swift中跟实例相关的属性可以分为2大类
- 存储属性（Stored Property）：
- 类似于成员变量的概念，
- 存储在实例的内存中
- 结构体、类可以定义存储属性
- 枚举不可以定义存储属性
enum Season : Int {
case spring(Int),summer = 5
}
var s = Season.spring
// 枚举要么存储关联值，要么存储case值(原始值)
- 计算属性（Computed Property）
- 本质就是方法（函数）
- 不占用实例的内存
- 枚举、结构体、类都可以定义计算属性
- 计算属性不能声明为let，计算属性的值是可能变化的（即使是只读计算属性）
struct Point {
var x:Int
var y:Int {
// 可以只有get方法，但是计算属性有了set，必须要有get
get {
}
}
}
枚举的rawValue（原始值）原理
rawValue 本质是一个只读的计算属性
enum Season:Int {
case spring = 1,summer,autumn,winter
var rawValue:Int {
switch self {
case .spring:return 1
case .spring:return 2
case .spring:return 3
case .spring:return 4
}
}
}
var s = Season.summer // 2
print(s.rawValue)
延迟存储属性（Lazy Stored Property）
- 使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化。
lazy属性必须是var，不能是let，let必须在实例的初始化方法完成之前就拥有值。
class Car {
init(){
print("Car init")
}
func run(){
print("Car is running!")
}
}
class Person {
lazy var car = Car()
init(){
print("Person init")
}
func goOut(){
car.run()
}
}
当结构体包含一个延迟存储属性时，只有var才能访问延迟存储属性， 因为延迟存储属性初始化时需要改变结构体的内存
struct Point {
var x = 0
var y = 0
lazy var z = 0
}
let p = Point()
print(p.z)// z 为延迟属性，在使用时才初始化，就会改变内存结构，而p 声明的是let 常量，不可修改
属性观察器（Property Observer）
可以为非lazy的var存储属性设置属性观察器
struct Circle {
var radius:Double {
willSet {
print("willSet",newValue)
}
didSet {
print("didSet",oldValue,radius)
}
}
init(){
self.radius = 1.0
print("Circle init!")
}
}
inout本质总结
如果实参有物理内存地址，且没有设置属性观察器
直接将实参的内存地址传入函数（实参进行引用传递）
如果实参是计算属性或者设置了属性观察器
- 采取了Copy In Copy Out的做法
- 调用该函数时，先复制实参的值，产生副本【get】
- 将副本的内存地址传入函数（副本进行引用传递），在函数内部可以修改副本的值
- 函数返回后，再将副本的值覆盖实参的值【set】
struct Shape {
var width:Int
var side :Int {
// 取出side值，把值赋值给局部变量，局部变量的内存地址传递给inout的参数，修改之后局部变量的值，然后调用set方法，完成了值的修改
willSet {
print("willSetSide",newValue)
}
didSet {
print("didSetSide",oldValue,side)
}
}
var girth:Int {
set {
width = newValue /side
}
get {
print("getGirth")
return width * side
}
}
func test(_ num: inout Int){
num = 20
}
}
var s = Shape(width:10,side:4)
test(&s.width)
s.show()
print("------------")
test(&s.side)
s.show()
print("------------")
test(&s.girth)
s.show()
类型属性（Type Property）
严格来说，属性可以分为
- 实例属性：只能通过实例访问
- 存储实例属性：存储在实例的内存中，每个实例都有1份
- 计算实例属性（本质是方法）
- 类型属性：只能通过类型去访问，可以通过static定义类型属性，如果是类，也可以用关键字class
- 存储类型属性，整个程序运行过程中，就只有1份内存（类似于全局变量）
- 计算类型属性
- 我们可以通过static定义类型属性，如果是类的话，可以通过class关键字
struct Car {
static var count: Int = 0
init() {
Car.count += 1
}
}
let c1 = Car()
let c2 = Car()
let c3 = Car()
print(Car.count) // 3
类型属性细节
- 不同于存储实例属性，你必须给存储类型属性设定呢初始值
- 因为没有初始化的过程存储属性
- 存储类型属性，默认是lazy，会在第一次使用的时候才初始化
- 就算被多个线程同时访问，保证只会初始化一次
- 存储类型可以是let
struct Shape {
static var width:Int = 0
// static lazy var width:Int = 0 默认加了lazy
}
- 枚举类型也可以定义类型属性（存储类型属性、计算类型属性）
- 它的类型属性地址不在枚举内，是个全局变量，定义在哪里都没问题
单列模式
public class FileManager {
public static let shared = FileManager()
private init(){}
}
方法
mutating
- 结构体和枚举是值类型，默认情况下，值类型的属性不能被自身的实例方法修改
- 在func关键字前加mutating可以允许这种修改行为
struct Point {
var x = 0.0 y = 0.0
mutating func moveBy(deltaX:Double,deltaY:Double){
x += deltaX
y += deltaY
}
}
@discardableResult
- 在func前面加个@discardableResult，可以消除：函数调用后返回值未被使用的警告⚠️
@discardableResult
func get() -> Int {
return 10
}
get()
下标（subscript）
- 使用subscript可以给任意类型（枚举、结构体、类）增加下标功能，有些地方也翻译为：下标脚本
- subscript的语法类似于实例方法、计算属性、本质就是方法（函数）
class Point {
var x=0.0,y = 0.0
subscript(index:Int) -> Double {
/*
subscript中定义的返回值类型决定了，
get方法的返回值类型
set方法中newValue的类型
*/
set {
if index == 0 {
x = newValue
} else if index == 1 {
y = newValue
}
}
get {
if index == 0 {
return x
}else if index == 1 {
return y
}
return 0
}
}
}
下标的细节
- subscript可以没有set方法，但必须要有get方法
class Point {
var x=0.0,y = 0.0
subscript(index:Int) -> Double {
get {
if index == 0 {
return x
}else if index == 1 {
return y
}
return 0
}
}
}
- 如果只有get方法，可以省略get
class Point {
var x=0.0,y = 0.0
subscript(index:Int) -> Double {
if index == 0 {
return x
}else if index == 1 {
return y
}
return 0
}
}
- 下标的标签
class Point {
var x=0.0,y = 0.0
subscript(index i:Int) -> Double {
if index == 0 {
return x
}else if index == 1 {
return y
}
return 0
}
}
var p = Point()
p.y = 22.2
print(p[index:1]) // 22.2
- 结构体、类作为返回值对比
class Point {
var x =0,y = 0
}
class PointManage {
var point = Point()
subscript(index:Int) ->Point {
get {point}
}
}
var pm = PointManage()
pm[0].x = 11
pm[0].y = 22
print(pm[0].x,pm[0].y) // 11,22
struct Point {
var x =0,y = 0
}
class PointManage {
var point = Point()
subscript(index:Int) ->Point {
get {point}
}
}
var pm = PointManage()
pm[0].x = 11
/*
等价于 pm[0] = Point(x:11,y:pm[0].y)
pm[0]是get方法，因为是struct， 所以拷贝一份临时point，不能改变原有值
*/
pm[0].y = 22
print(pm[0].x,pm[0].y)
struct Point {
var x =0,y = 0
}
class PointManage {
var point = Point()
subscript(index:Int) ->Point {
set {point = newValue}
get {point}
}
}
var pm = PointManage()
pm[0].x = 11
/*
等价于 pm[0] = Point(x:11,y:pm[0].y)
pm[0]是调用set方法。
*/
pm[0].y = 22
print(pm[0].x,pm[0].y)
- subscript可以接受多个参数，并且类型任意
class Grid {
var data = {
[0,1,2],
[3,4,5],
[6,7,8]
}
subscript(row:Int,column:Int) -> Int {
set {
guard row >= 0 && row < 3 && column >= 0 && column < 3 else {
return
}
data[row][column] = newValue
}
get {
guard row >= 0 && row < 3 && column >= 0 && colunm < 3 else {
return 0
}
return data[row][column]
}
}
}
var grid = Grid()
grid[0,1] = 77
grid[1,2] = 88
grid[2,0] = 99
print(grid.data)
