import Foundation //API，为了调用数学函数
//下标方法
var 数组1 = [1,2,3,4,5,6,7]
数组1[1] = 3
数组1
//数组是一个结构体，中括号是一个方法，叫下标方法。
//求指定半径的圆的面积 S = πr²
struct Square {
subscript(radius: Double) -> Double {
//M_PI 圆周率
//pow函数：2个参数a和b，求a的b次方
return M_PI * pow(radius,2)
}
}
let s1 = Square()
s1[3]

struct Matrix{
var rows,columns: Int
var grid: [Int]
init(rows: Int,columns: Int){
self.rows = rows
self.columns = columns
grid = Array(count: rows * columns,repeatedValue: 0)
}
//检查索引是否超越数组大小
func indexIsValid(row: Int,columns: Int) -> Bool {
return row >= 0 && row < rows && column >= 0 && column < columns
}
//用下标方法 来存取矩阵对应的数组
subscript(row: Int,column: Int) -> {
//取回矩阵对应的数组中的值
get{
assert(indexIsValid(row,column: column),“数组索引越界！”
return grid[(row * columns) + column]
}
//根据索引设置矩阵值到数组中
set{
assert(indexIsValid(row,“数组索引越界！”)
grid[(row * columns) + column] = newValue
}
}
}
var aMatrix = Matrix(rows: 3,columns: 3)
aMatrix[0,0] = 1
aMatrix[0,1] = 2
aMatrix[0,2] = 3
aMatrix[1,0] = 4
aMatrix[1,1] = 5
aMatrix[1,2] = 6
aMatrix[2,0] = 7
aMatrix[2,1] = 8
aMatrix[2,2] = 9
for i in aMatrix.grid {
println(i)
}

//inherit & extension 继承和扩展
//父类
class 车 {
var 速度 = 0
var 描述 : String {
return “时速(速度)公里每小时”
}
func 声响() {
}
}
let 一辆车 = 车()
一辆车.描述
//子类继承父类
class 自行车: 车 {
var 有篮子 = false
}
let 一辆自行车 = 自行车()
一辆自行车.速度 = 25
一辆自行车.描述
//子类的子类
class 情侣自行车: 自行车 {
var 当前乘客数 = 0
}
一辆情侣自行车.当前乘客数 = 2
一辆情侣自行车.速度 = 20
一辆情侣自行车.描述
//子类重载父类的方法
class 动车: 车 {
override func 声响() {
println(“嘟—嘟—嘟”)
}
}
let 一辆动车 = 动车()
一辆动车.声响()
//子类重载父类的计算属性
class 汽车: 车 {
//override var 速度 = 8 这里这么写会报错，不能重载单个属性，只能重载计算属性。
var 轮子数 = 0
override var 描述: String {
return super.描述 + “，有(轮子数)个轮子”
}
override var 速度: Int {
didSet { //一个属性监视器，速度变化后，对其进行了一个判断。
if 速度 > 120 {
println(“警告：您的速度已经超过120公里每小时了，为了您的安全，进入自动驾驶状态。”)
}
}
}
}
let 一辆汽车 = 汽车()
一辆汽车.速度 = 121
一辆汽车.轮子数 = 4
一辆汽车.描述
//扩展
//用于 已存在的类/结构体/枚举类型
//一般用于下面两种情况：
//1.源代码不可知的情况
//2.把复杂的类分解，提高可维护性
extension Double { //对系统的Double类型就行扩展。
var rmb: Double {
return self * 0.0597
}
}
//日本人均月薪31万4150日元
31_4150.rmb // 这里是18754.755
//整数自平方
extension Int {
mutating func 平方() {
self *= self
}
}
var 一个整数 = 1024
一个整数.平方()
一个整数

//诞生和消亡 - 初始化和反初始化
//初始化 - 默认构造器
struct 武器 {
var 持久 = 10
var 攻击力 = 0
var 主人: String?
init() { //默认构造器，把结构体的属性变为初始值。
}
}
var 一把武器 = 武器()
//没有默认构造器那么使用结构体的时候要手动给每个属性赋初始值。
struct 武器 {
var 持久 = 10
var 攻击力 = 0
var 主人: String?
}
var 一把武器 = 武器(持久: 10,攻击力: 10,主人: nil)
//如果结构体默认属性没有值，那么构造器方法就必须给属性赋值。
struct 武器 {
var 持久 = Int
var 攻击力 = Int
var 主人: String
init(持久: Int,攻击力: Int,主人: String){ //一般参数是跟属性相同
self.持久 = 持久
self.攻击力 = 攻击力
self.主人 = 主人
}
}
var 一把武器 = 武器(持久: 8,攻击力: 3,主人: “大法师”)

//多初始化
class 战士 {
var 武器攻击力: Int
var 头盔攻击力: Int
var 戒指攻击力: Int
var 战衣攻击力: Int
var 经验倍数 = 1
var 服务器名: String?
//指定构造器，倾向唯一性，一般一个类里面只有一个指定构造器。
init (武器攻击力: Int,头盔攻击力: Int,戒指攻击力: Int,战衣攻击力: Int) {
self.武器攻击力 = 武器攻击力
self.头盔攻击力 = 头盔攻击力
self.戒指攻击力 = 戒指攻击力
self.战衣攻击力 = 战衣攻击力
}
//便利构造器，可以多个
convenience init (武器攻击力: Int,战衣攻击力: Int,经验倍数: Int) { //相当于做主构造器的代理，可以调用主构造器中的方法，再加上便利构造器的特色参数(经验倍数: Int)。
self.init(武器攻击力: 武器攻击力,头盔攻击力: 头盔攻击力,戒指攻击力: 戒指攻击力,战衣攻击力: 战衣攻击力)
self.经验倍数 = 经验倍数
}
convenience init (服务器名: String,武器攻击力: Int,经验倍数: Int) {
self.init(武器攻击力: 武器攻击力,战衣攻击力: 战衣攻击力,经验倍数: 经验倍数)
self.服务器名 = 服务器名
}
var 总攻击力: Int {
return 经验倍数 * (武器攻击力 + 头盔攻击力 + 戒指攻击力 + 战衣攻击力)
}
}

var 战神 = 战士(服务器名: “一区”,武器攻击力: 3,头盔攻击力: 20,戒指攻击力: 10,战衣攻击力: 50,经验倍数: 5)
let 未付费的菜鸟 = 战士(武器攻击力: 3,头盔攻击力: 2,戒指攻击力: 1,战衣攻击力: 5)
未付费菜鸟.总攻击力
战神.总攻击力

//反初始化 //deinit { //} class 战士 { var 武器攻击力: Int var 头盔攻击力: Int var 戒指攻击力: Int var 战衣攻击力: Int var 经验倍数 = 1 var 服务器名: String? //指定构造器，倾向唯一性，一般一个类里面只有一个指定构造器。 init (武器攻击力: Int,战衣攻击力: Int) { self.武器攻击力 = 武器攻击力 self.头盔攻击力 = 头盔攻击力 self.戒指攻击力 = 戒指攻击力 self.战衣攻击力 = 战衣攻击力 } //便利构造器，可以多个 convenience init (武器攻击力: Int,经验倍数: Int) { //相当于做主构造器的代理，可以调用主构造器中的方法，再加上便利构造器的特色参数(经验倍数: Int)。 self.init(武器攻击力: 武器攻击力,战衣攻击力: 战衣攻击力) self.经验倍数 = 经验倍数 } convenience init (服务器名: String,经验倍数: Int) { self.init(武器攻击力: 武器攻击力,经验倍数: 经验倍数) self.服务器名 = 服务器名 } deinit { //把实例中所有的属性、方法等所占的内存、引用全部给释放，一般情况下swift会帮我们自动处理，所以一般不用这个方法。 } var 总攻击力: Int { return 经验倍数 * (武器攻击力 + 头盔攻击力 + 戒指攻击力 + 战衣攻击力) } }