上一节:
下一节:

  Swift - 方法

  • 简述

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

  • 实例方法

    在 Swift 4 语言中，通过实例方法访问类、结构和枚举实例。
    实例方法提供功能
    • 访问和修改实例属性
    • 与实例需求相关的功能
    实例方法可以写在 {} 大括号内。它可以隐式访问类型实例的方法和属性。当调用该类型的特定实例时，它将访问该特定实例。

    句法

    
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()
    当我们使用Playground运行上述程序时，我们得到以下结果 - 
    
Result is: 880
Result is: 850
    类计算定义了两个实例方法 -
    • init() 被定义为将两个数字 a 和 b 相加并将其存储在结果“res”中
    • tot() 用于从传递的“c”值中减去“res”
    最后，调用带有 a 和 b 值的计算方法。实例方法通过“.”访问。点语法

  • 局部和全局参数名称

    Swift 4 函数描述了它们变量的局部和全局声明。类似地，Swift 4 Methods 的命名约定也类似于 Objective C。但是对于函数和方法，局部和全局参数名称声明的特征是不同的。Swift 4 中的第一个参数由介词名称引用为“with”、“for”和“by”，以便于访问命名约定。
    Swift 4 通过将第一个参数名称声明为局部参数名称而将其余参数名称声明为全局参数名称来提供方法的灵活性。这里 'no1' 被 Swift 4 方法声明为局部参数名称。“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)
    当我们使用Playground运行上述程序时，我们得到以下结果 - 
    
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)
    当我们使用Playground运行上述程序时，我们得到以下结果 - 
    
2400
500
45000

  • 方法中的 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("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()
    当我们使用Playground运行上述程序时，我们得到以下结果 - 
    
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)
    当我们使用Playground运行上述程序时，我们得到以下结果 - 
    
9
15
270
450
81000
135000

  • 改变方法的 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)
    当我们使用 Playground 运行上述程序时，我们得到以下结果。- 
    
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)
    当我们使用 Playground 运行上述程序时，我们得到以下结果。- 
    
35
5
上一节:
下一节: