# Swift方法
在 Swift 中特定类型的相关联功能被称为方法。在 Objective C 中类是用来定义方法，其中作为 Swift 语言为用户提供了灵活性，类，结构和枚举中可以定义使用方法。
####实例方法
在 Swift 语言，类，结构和枚举实例通过实例方法访问。
**实例方法提供的功能**
- 访问和修改实例属性
- 函数关联实例的需要
实例方法可以写在花括号 {} 内。它隐含的访问方法和类实例的属性。当该类型指定具体实例它调用获得访问该特定实例。
语法
func funcname(Parameters)-> returntype
{
Statement1Statement2---Statement N
return parameters
}
示例
class calculations {
let a:Intlet b:Intlet res:Int
init(a:Int, b:Int){self.a = a
self.b = b
res = a + b
}
func tot(c:Int)->Int{
return res - c
}
func result(){
println("Result is: \(tot(20))")
println("Result is: \(tot(50))")
}
}
let pri = calculations(a:600, b:300)
pri.result()
当我们使用 playground 运行上面的程序，得到以下结果
Result is: 880
Result is: 850
`Calculations` 类定义了两个实例方法：
init() 被定义为两个数 a 和 b 相加，并将其结果存储在'res'
tot() 用于通过从 “res” 值减去 'c'
最后，调用打印的计算a和b的值方法. 实例方法以 "." 语法访问
####局部和外部参数名称
Swift 函数描述了局部和全局变量声明。同样，Swift 方法的命名规则也类似 Objective C。但是局部和全局参数名称声明的特性对于函数和方法不同。 swift 第一个参数是由介词名称'with', 'for' 和 'by' 访问命名规则。
Swift 提供声明作为局数参数名称，其它参数名称为全局参数名，第一参数是方法名称。在这里，“no1”方法作为局部参数名来声明。 'no2' 用于全局声明，并通过该程序访问。
class division {var count:Int=0
func incrementBy(no1:Int, no2:Int){
count = no1 / no2
println(count)
}
}
let counter = division()
counter.incrementBy(1800, no2:3)
counter.incrementBy(1600, no2:5)
counter.incrementBy(11000, no2:3)
当我们使用 playground 运行上面的程序，得到以下结果
600
320
3666
外部参数名称使用 # 和 _ 符号
尽管 Swift 方法提供第一个参数名称作为局部声明，用户必须提供以修改参数名称从局部到全局声明。这可以通过'＃'符号前缀使用第一参数名来完成。通过这样做，第一参数可以作为全局在整个模块访问。
当用户需要使用外部名称访问在后面的参数名中，方法的名字使用“_”符号覆盖。
class multiplication {
var count:Int=0
func incrementBy(#no1:Int, no2:Int){
count = no1 * no2
println(count)
}
}
let counter = multiplication()
counter.incrementBy(no1:800, no2:3)
counter.incrementBy(no1:100, no2:5)
counter.incrementBy(no1:15000, no2:3)
当我们使用 playground 运行上面的程序，得到以下结果
2400
500
45000
在方法中的Self属性
方法有一个隐式属性被称为“self”，所有定义的类型实例所都有。“self”属性被用于表示当前的实例定义的方法。
class calculations {
let a:Intlet b:Intlet res:Int
init(a:Int, b:Int){self.a = a
self.b = b
res = a + b
println("Inside Self Block: \(res)")}
func tot(c:Int)->Int{return res - c
}
func result(){
println("Result is: \(tot(20))")
println("Result is: \(tot(50))")
}
}
let pri = calculations(a:600, b:300)
let sum = calculations(a:1200, b:300)
pri.result()
sum.result()
当我们使用 playground 运行上面的程序，得到以下结果
Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450
####修改的实例方法值类型
在 Swift 语言结构和枚举和值类型不能由它的实例方法来改变。然而，swift 语言通过“变异”行为提供了灵活修改值类型。突变将使得在实例方法中的任何变化，将方法执行之后变化返回到原来的形式。此外，由 “selft” 属性的新实例其隐式函数创建，执行之后将取代现有的方法
struct area {
var length =1var breadth =1
func area()->Int{
return length * breadth
}
mutating func scaleBy(res:Int){
length *= res
breadth *= res
println(length)
println(breadth)
}
}
var val = area(length:3, breadth:5)
val.scaleBy(3)
val.scaleBy(30)
val.scaleBy(300)
当我们使用 playground 运行上面的程序，得到以下结果
9
15
270
450
81000
135000
Self 属性的不同诱变方法
突变方法结合 “self” 属性分配给新实例所定义的方法。
struct area {
var length =1var breadth =1
func area()->Int{return length * breadth
}
mutating func scaleBy(res:Int){self.length *= res
self.breadth *= res
println(length)
println(breadth)}}var val = area(length:3, breadth:5)
val.scaleBy(13)
当我们使用 playground 运行上面的程序，得到以下结果
39
65
##类型方法
当方法的特定实例调用，它调用一个实例方法并且当方法调用特定类型的方法的一个被定义为 "类型方法“。类型方法 “类” 是由“func”关键字和结构定义,和枚举型方法使用 “func” 关键字之前的“static”关键字定义。
类型方法调用，是通过访问 '.' 而不是调用特定实例的方法，例子和语法如下：
classMath{
class func abs(number:Int)->Int{
if number <0{
return(-number)
}else{
return number
}
}
}
struct absno {
static func abs(number:Int)->Int{
if number <0{
return(-number)
}else{
return number
}
}
}
letno=Math.abs(-35)let num = absno.abs(-5)
println(no)
println(num)
当我们使用 playground 运行上面的程序，得到以下结果
35
5
# Swift下标
访问一个集合的元素成员，在类中的序列和列表，结构和枚举都可以使用下标。这些下标用于存储和使用索引来检索值。数组元素可使用如：`someArray[index]`，在 Dictionary 实例及其后续成员元素的访问也可以使用如：`someDicitonary[key]`。
对于单一类型，下标范围可以从单一到多个声明。我们可以用适当的下标重载传递给下标索引值的类型。下标也可以根据输入数据类型声明范围从单一维度到多维度。
####下标声明语法和用法
让我们回顾一下计算属性。下标也遵循计算属性相同的语法。对于查询类型的实例下标括在方括号内，接着是实例名称。下标语法遵循结构作为 “实例方法” 和 “计算属性” 相同的语法。`“subscript”` 关键字用来定义标，用户可以指定一个或多个参数，它们带有返回类型。下标可以有读写或只读属性和实例存储和检索使用 `“getter”` 和 `“setter”` 属性作为计算属性。
####语法
subscript(index:Int)->Int{
get{
// used for subscript value declarations
}
set(newValue){
// definitions are written here
}
}
**示例1**
struct subexample {
let decrementer:Int
subscript(index:Int)->Int{
return decrementer / index
}
}
let division = subexample(decrementer:100)
println("The number is divisible by \(division[9]) times")
println("The number is divisible by \(division[2]) times")
println("The number is divisible by \(division[3]) times")
println("The number is divisible by \(division[5]) times")
println("The number is divisible by \(division[7]) times")
当我们使用 playground 运行上面的程序，得到以下结果
The number is divisible by 11 times
The number is divisible by 50 times
The number is divisible by 33 times
The number is divisible by 20 times
The number is divisible by 14 times
**示例2**
class daysofaweek {
private var days=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","saturday"]
subscript(index:Int)->String{
get{
return days[index]
}
set(newValue){
self.days[index]= newValue
}
}
}
var p = daysofaweek()
println(p[0])
println(p[1])
println(p[2])
println(p[3])
当我们使用 playground 运行上面的程序，得到以下结果
Sunday
Monday
Tuesday
Wednesday
####下标选项
下标采用单一到多元的输入参数，这些输入参数也属于任意数据类型。还可以使用变量，可变参数的参数。下标不能提供缺省参数值，或使用任何 `in-out` 参数。
定义多个标被称为`下标重载`在一个类 或结构体根据需要可以提供多个下标定义。这些多个标是基于被下标括号内声明值的类型推断。
structMatrix{
let rows:Int, columns:Intvarprint:[Double]
init(rows:Int, columns:Int){
self.rows = rows
self.columns = columns
print=Array(count: rows * columns, repeatedValue:0.0)}
subscript(row:Int, column:Int)->Double{
get{
returnprint[(row * columns)+ column]
}
set{
print[(row * columns)+ column]= newValue
}
}
}
var mat =Matrix(rows:3, columns:3)
mat[0,0]=1.0
mat[0,1]=2.0
mat[1,0]=3.0
mat[1,1]=5.0
println("\(mat[0,0])")
println("\(mat[0,1])")
println("\(mat[1,0])")
println("\(mat[1,1])")
当我们使用 playground 运行上面的程序，得到以下结果
1.0
2.0
3.0
5.0
Swift 下标支持单参数到多参数声明相应数据类型。该程序声明的“矩阵”结构为2*2维数组矩阵来存储 “Double” 数据类型。 矩阵参数被输入整数数据类型用来声明行和列。
矩阵新实例是通过使行和列数来初始化创建的，如下所示。
var mat = Matrix(rows: 3, columns: 3)
矩阵值可通过传递行和列值到下标，通过逗号隔开，进行定义如下所示。
mat[0,0] = 1.0
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0
# Swift数组
Swift 数组用于存储相同类型的值的顺序列表。Swift 要严格检查，它不允许错误地在数组中存放了错误的类型。
如果赋值创建数组到一个变量，它总是可变的，这意味着可以通过添加元素来改变它， 删除或更改其项目，但如果分配一个数组常量到则该数组，则数组是不可被改变的， 也就它的大小和内容不能被改变。
**创建数组**
可以使用下面的初始化程序语法来创建某种类型的空数组：
var someArray = [SomeType]()
下面是创建一个给定的大小，并用初始值的数组的语法：
var someArray = [SomeType](count: NumbeOfElements, repeatedValue: InitialValue)
下面是一个例子，以创建具有3个元素并初始值为零的 int 类型空数组：
var someInts = [Int](count: 3, repeatedValue: 0)
下面是一个创建三个元素的数组，并指定三个值的数组的例子：
var someInts:[Int] = [10, 20, 30]
**访问数组**
可以使用下标语法从数组中检索对应值，传递数组名后方括号内的索引对应的值，如下：
var someVar = someArray[index]
在这里，指数从0开始，这意味着可以使用索引0来访问第一个元素，第二元素可以通过使用索引1进行访问，其它类似。让我们来看看下面创建，初始化和访问数组的例子：
import Cocoa
var someInts = [Int](count: 3, repeatedValue: 10)
var someVar = someInts[0]
println( "Value of first element is \(someVar)" )
println( "Value of second element is \(someInts[1])" )
println( "Value of third element is \(someInts[2])" )
当上述代码被编译和执行时，它产生了以下结果：
Value of first element is 10
Value of second element is 10
Value of third element is 10
**修改数组**
可以使用 append()方法或加法赋值运算符(+=)将新的项目添加到数组的末尾，在这里首先创建一个空的数组，然后添加新的元素到数组中，如下图所示:
import Cocoa
var someInts = [Int]()
someInts.append(20)
someInts.append(30)
someInts += [40]
var someVar = someInts[0]
println( "Value of first element is \(someVar)" )
println( "Value of second element is \(someInts[1])" )
println( "Value of third element is \(someInts[2])" )
当上述代码被编译和执行时，它产生了以下结果：
Value of first element is 20
Value of second element is 30
Value of third element is 40
可以通过分配一个在给定的索引处新的值修改数组的现有元素，如在下面的例子：
import Cocoa
var someInts = [Int]()
someInts.append(20)
someInts.append(30)
someInts += [40]
// Modify last element
someInts[2] = 50
var someVar = someInts[0]
println( "Value of first element is \(someVar)" )
println( "Value of second element is \(someInts[1])" )
println( "Value of third element is \(someInts[2])" )
当上述代码被编译和执行时，它产生了以下结果：
Value of first element is 20
Value of second element is 30
Value of third element is 50
**迭代/遍历数组**
可以使用 for-in 循环迭代级数，在下面的例子是数组的整个集值，如下图所示：
import Cocoa
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]
for item in someStrs {
println(item)
}
当上述代码被编译和执行时，它产生了以下结果：
Apple
Amazon
也可以使用 enumerate() 函数，如下面的例子所示，它返回索引及对应的值：
import Cocoa
var someStrs = [String]()
someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]
for (index, item) in someStrs.enumerate {
println("Value at index = \(index) is \(item)")
}
当上述代码被编译和执行时，它产生了以下结果：
Value at index = 0 is Apple
Value at index = 1 is Amazon
Value at index = 2 is Google
两个数组相加
使用加法运算符(+)，以添加的相同类型的数组，这将产生新的数组是来自两个数组值相加组合后的数组，如下：
import Cocoa
var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = intsA + intsB
for item in intsC {
println(item)
}
当上述代码被编译和执行时，它产生了以下结果：
2
2
1
1
1
**count 属性**
可以使用只读计算 (count) 数组属性，找出下面显示出数组中元素的个数：
import Cocoa
var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = intsA + intsB
println("Total items in intsA = \(intsA.count)")
println("Total items in intsB = \(intsB.count)")
println("Total items in intsC = \(intsC.count)")
当上述代码被编译和执行时，它产生了以下结果：
Total items in intsA = 2
Total items in intsB = 3
Total items in intsC = 5
**空属性**
使用只读数组的空属性(isEmpty)找出一个数组是否为空，如下图所示：
import Cocoa
var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = [Int]()
println("intsA.isEmpty = \(intsA.isEmpty)")
println("intsB.isEmpty = \(intsB.isEmpty)")
println("intsC.isEmpty = \(intsC.isEmpty)")
当上述代码被编译和执行时，它产生了以下结果：
intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true
