Swift 系统学习 21 存储型属性和计算型属性 下标语法

//: Playground - noun: a place where people can play

import UIKit

/*
 * 本节主要内容:
 * 1.两种属性: 存储型属性和计算型属性
 * 2.下标语法
 */

struct Point2D {
    // 存储属性(只能存值, 没有get和set)
    var x = 0.0 // Double
    var y = 0.0 // Double
}
struct Size {
    // 存储属性
    var width = 0.0 // Double
    var height = 0.0 // Double
}
// 声明描述二维坐标系矩形的结构体
struct Rectangle {
    // 存储属性(只能存值, 没有get和set)
    // 左上顶点位置
    var origin = Point2D()
    // 大小
    var size = Size()
    
    func getRectangeCenter() -> Point2D {
        let centerX = origin.x + size.width / 2
        let centerY = origin.y + size.height / 2
        return Point2D(x: centerX, y: centerY)
    }
    // 计算型属性: 只写get方法(只读); get和set(读写)
    var center: Point2D {
        get {
            print("----get 方法------")
            // 根据左上顶点和大小计算中心点
            let centerX = origin.x + size.width / 2
            let centerY = origin.y + size.height / 2
            return Point2D(x: centerX, y: centerY)
        }
        set {
            // 根据中心点和大小, 计算左上顶点坐标
            print("---set 方法")
            // 获取要赋值的新值是什么? 关键词newValue
            origin.x = newValue.x - size.width / 2
            origin.y = newValue.y - size.height / 2
        }
    }
    
    // 计算型属性: 只有get方法, 可以省略get以及大括号
    var area: Double {
        // 推荐方式:
        return size.width * size.height
//        get {
//            return size.width * size.height
//        }
    }
}
// 实例化
var rectangle = Rectangle(origin: Point2D(), size: Size(width: 10, height: 20))
rectangle.area
rectangle.center
rectangle.center
rectangle.center
rectangle.center = Point2D(x: 20, y: 20)
rectangle.center = Point2D(x: 20, y: 20)


/*
 * 下标语法: 访问枚举/结构体/类自定义类型的简单形式, 类似于访问集合类(数组/字典/集合)元素的形式.
 * 例如: array[0], dictionary[key]
 * 优势:
 * 对象: 枚举/结构体/类
 * 语法: 将函数和计算性属性结合的方式
    subscript(index: Int) -> Int {
       get {
          return statement;
       }
       set {
       }
    }
 */

// 基本用法
// 描述给定整型数的倍数结构体
struct TimesTable {
    // 倍数
    let multiplier: Int
    
    subscript(index: Int) -> Int {
        return multiplier * index
    }
}
// 结果
let threeTimes = TimesTable(multiplier: 3)
// 访问结构体属性(像获取数组元素的方式)
threeTimes[6]
threeTimes[10]


// 声明描述三维坐标系的结构体
struct Vector3D {
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0
    
    // 两个下标语法
    subscript(axis: String) -> Double? {
        get {
            switch axis {
            case "x", "X": return x
            case "y", "Y": return y
            case "z", "Z": return z
            default: return nil
            }
        }
        set {
            // 对newValue解包(newValue是Double?)
            guard let newValue = newValue else { return }
            // newValue关键词
            switch axis {
            case "x", "X": x = newValue
            case "y", "Y": y = newValue
            case "z", "Z": z = newValue
            default: return
            }
        }
    }
    
    // 方式二:
    subscript(index: Int) -> Double? {
        get {
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: return nil
            }
        }
        // customVar自定义变量替代了newValue
        set(customVar) {
            guard let customVar = customVar else {
                return
            }
            switch index {
            case 0: x = customVar
            case 1: y = customVar
            case 2: z = customVar
            default: return
            }
        }
    }
}

// 结果: 方式一:
var vector = Vector3D(x: 10.5, y: 21.6, z: 49.2)
vector["x"] = 1000.4
vector["y"]
vector["z"]
// 方式二:
vector[0]
vector[1]
vector[2]


// 为什么: Array结构体
var array: Array<Int> = [1, 2, 3, 4]
array[0]
array[1]
array[2]
var dictionary: Dictionary<String, String> = ["北京": "Beijing", "纽约": "New York", "巴黎": "Paris"]
dictionary["北京"]
dictionary["巴黎"]

/*
 * 课堂练习: 
 * 需求: 声明一个描述二维数组的结构体Matric, 使用下标语法, 通过两个下标(行,列)访问一维数组的元素
 * 要求: init构造方法(初始化一维数组), init方法的参数两个(行数和列数); 处理越界情况
 * 结果: matric[1, 5] -> 获取二维数组的第1行第5列元素
 */