swift类和结构体的方法解析 - Swift最新教程

在Swift中与特定类型相关的语言函数被称为方法，在Objective – C中，类用于定义方法，而Swift语言为用户提供了灵活的方法来定义类、结构和枚举。

实例方法

在Swift语言中，类、结构和枚举实例是通过实例方法访问的。

实例方法提供功能：

访问和修改实例属性
与实例需要相关的功能

实例方法可以写在{}花括号内，它可以隐式地访问类型实例的方法和属性，当调用该类型的特定实例时，它将访问该特定实例。

语法

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("结果: \(tot(c: 20))")
       print("结果: \(tot(c: 50))")
    }
 }
 let pri = calculations(a: 600, b: 300)
 pri.result()

类计算定义了两个实例方法

init()被定义为添加两个数字a和b并将其存储在结果“res”中
tot()用于从传递“c”值中减去“res”

最后，调用带有a和b值的计算方法。使用’.’点语法访问实例方法。

本地和外部参数名

Swift函数描述了变量的局部和全局声明，类似地，Swift方法的命名约定也类似于Objective C，但是局部和全局参数名声明的特征与函数和方法不同，Swift中的第一个参数由介词名称“with”、“for”和“by”表示，以便于访问命名约定。

Swift通过将第一个参数名声明为本地参数名，其余参数名声明为全局参数名，从而在方法中提供了灵活性。这里的“no1”由Swift方法声明为本地参数名，’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)

带有#和_符号的外部参数名

即使Swift方法为局部声明提供了第一个参数名，用户也可以将参数名从局部声明修改为全局声明，这可以通过在’#’符号前面加上第一个参数名来实现，通过这样做，第一个参数可以在整个模块中全局访问。

当用户需要使用外部名称访问随后的参数名时，方法名在’_’符号的帮助下被覆盖。

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)

方法中的self属性

方法的所有定义的类型实例都有一个称为“self”的隐式属性，“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("内部块: \(res)")
    }
    
    func tot(c: Int) -> Int {
       return res - c
    }
    
    func result() {
       print("结果: \(tot(c: 20))")
       print("结果: \(tot(c: 50))")
    }
 }
 
 let pri = calculations(a: 600, b: 300)
 let sum = calculations(a: 1200, b: 300)
 
 pri.result()
 sum.result()

从实例方法修改值类型

在Swift中，语言结构和枚举属于不能被实例方法改变的值类型，然而，Swift语言提供了通过“突变”行为来修改值类型的灵活性。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)

用于突变方法的self属性

将方法与“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)

类型的方法

当一个方法的特定实例被调用时，它被称为一个实例方法;当方法调用特定类型的方法时，它被称为“类型方法”。‘类’的类型方法由‘func’关键字定义，结构和枚举类型方法由‘static’关键字在‘func’关键字之前定义。

类型方法由’.’调用和访问，而不是调用一个特定的实例，整个方法被调用。

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)