📅 最后修改于: 2020-12-25 04:34:45 🧑 作者: Mango
在Swift 4语言中，与特定类型关联的功能称为“方法”。在Objective C中，类用于定义方法，而Swift 4语言为用户提供了灵活的类，结构和枚举方法。
在Swift 4语言中，可通过实例方法访问Class，Structures和Enumeration实例。
实例方法提供功能
实例方法可以写在{}花括号内。它具有对类型实例的方法和属性的隐式访问。当调用该类型的特定实例时，它将可以访问该特定实例。
func funcname(Parameters) -> returntype {
Statement1
Statement2
---
Statement N
return parameters
}
class calculations {
let a: Int
let b: Int
let 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() {
print("Result is: \(tot(c: 20))")
print("Result is: \(tot(c: 50))")
}
}
let pri = calculations(a: 600, b: 300)
pri.result()
当我们使用游乐场运行上述程序时，我们得到以下结果-
Result is: 880
Result is: 850
类计算定义了两个实例方法-
最后，调用要打印具有a和b值的计算方法。实例方法用’。’访问。点语法
Swift 4函数同时描述了其变量的局部和全局声明。同样，Swift 4 Methods的命名约定也类似于目标C的约定。但是，函数和方法的局部和全局参数名称声明的特征不同。 Swift 4中的第一个参数由介词名称称为“ with”，“ for”和“ by”，以便于访问命名约定。
Swift 4通过将第一个参数名称声明为局部参数名称，其余参数名称声明为全局参数名称，从而提供了方法的灵活性。在这里，Swift 4方法将“ no1”声明为本地参数名称。 “ no2”用于全局声明，并在整个程序中进行访问。
class division {
var count: Int = 0
func incrementBy(no1: Int, no2: Int) {
count = no1 / no2
print(count)
}
}
let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)
当我们使用游乐场运行上述程序时，我们得到以下结果-
600
320
3666
即使Swift 4方法为本地声明提供了第一个参数名称，用户仍然可以将参数名称从本地声明修改为全局声明。这可以通过在第一个参数名称前加上“＃”符号来实现。这样，可以在整个模块中全局访问第一个参数。
当用户需要使用外部名称访问后续参数名称时，将使用’_’符号覆盖方法名称。
class multiplication {
var count: Int = 0
func incrementBy(no1: Int, no2: Int) {
count = no1 * no2
print(count)
}
}
let counter = multiplication()
counter.incrementBy(no1: 800, no2: 3)
counter.incrementBy(no1: 100, no2: 5)
counter.incrementBy(no1: 15000, no2: 3)
当我们使用游乐场运行上述程序时，我们得到以下结果-
2400
500
45000
方法具有所有定义的类型实例的隐式属性，称为“自身”。 “ Self”属性用于为其定义的方法引用当前实例。
class calculations {
let a: Int
let b: Int
let res: Int
init(a: Int, b: Int) {
self.a = a
self.b = b
res = a + b
print("Inside Self Block: \(res)")
}
func tot(c: Int) -> Int {
return res - c
}
func result() {
print("Result is: \(tot(c: 20))")
print("Result is: \(tot(c: 50))")
}
}
let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)
pri.result()
sum.result()
当我们使用游乐场运行上述程序时，我们得到以下结果-
Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450
在Swift 4中，语言结构和枚举属于值类型，不能通过其实例方法更改。但是，Swift 4语言提供了通过“变异”行为来修改值类型的灵活性。 Mutate将对实例方法进行任何更改，并在执行该方法后返回到原始形式。同样，通过’self’属性，将为其隐式函数创建新实例，并在执行后替换现有方法
struct area {
var length = 1
var breadth = 1
func area() -> Int {
return length * breadth
}
mutating func scaleBy(res: Int) {
length *= res
breadth *= res
print(length)
print(breadth)
}
}
var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)
当我们使用游乐场运行上述程序时，我们得到以下结果-
9
15
270
450
81000
135000
结合“ self”属性的变异方法会为定义的方法分配一个新实例。
struct area {
var length = 1
var breadth = 1
func area() -> Int {
return length * breadth
}
mutating func scaleBy(res: Int) {
self.length *= res
self.breadth *= res
print(length)
print(breadth)
}
}
var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)
当我们在操场上运行上述程序时，得到以下结果。 –
39
65
当一个方法的特定实例被调用时，它被称为实例方法。当方法调用特定类型的方法时，称为“类型方法”。 “类”的类型方法由“ func”关键字定义，结构和枚举类型方法在“ func”关键字之前由“ static”关键字定义。
类型方法由’。’调用和访问。语法，而不是调用特定实例，而是调用整个方法。
class Math {
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
}
}
}
let no = Math.abs(number: -35)
let num = absno.abs(number: -5)
print(no)
print(num)
当我们在操场上运行上述程序时，得到以下结果。 –
35
5