Swift 方法

在本教程中，我们将通过示例了解 Swift 方法及其类型。

在类中定义的 Swift 函数称为方法。例如，

class Person {
  . . .
  // define methods
  func greet() {
  // method body
  }
}

这里，greet() 是在 Person 类中定义的方法。在学习方法之前，请确保了解 Swift 中 类 和 结构 的工作方式。

实例： 类方法

class Person {
  // define a method
  func greet() {
    print("Hey there!")
  }
}
var nick = Person()
// call method
nick.greet()

结果为:

Hey there!

在上面的例子中，我们在 Person 类中创建了一个名为 greet() 的方法。在这里，我们使用了类的对象 nick 来调用该方法。

// call method
nick.greet()

实例：使用 Swift 方法计算面积和体积

// create a class
class Hall {
  var length = 0.0
  var breadth = 0.0
  var height = 0.0
  // method to calculate area
  func calculateArea() {
    print("Area of Hall =", length * breadth)
  }
  // method to calculate volume
  func calculateVolume() {
    print("Volume of Hall =", length * breadth * height)
  }
}
// create object of Hall class
var hall1 = Hall()
hall1.length = 42.5
hall1.breadth = 30.8
hall1.height = 45.2
// call calculateArea() method
hall1.calculateArea()
// call calculateVolume() method
hall1.calculateVolume()

结果为:

Area of Room = 1309.0
Volume of Room = 59166.8

在上面的实例中，我们使用两个方法创建了一个名为 Hall 的类：

• calculateArea() - 计算大厅的面积

• calulateVolume() - 计算大厅的体积

因为这些方法是在类内声明的，所以我们使用类的对象 hall1 来调用它们。

hall1.calculateArea()
hall1.calculateVolume()

Swift 静态方法

在前面的实例中，我们使用了类的对象来访问其方法。但是，我们也可以创建无需创建对象即可访问的方法。

这些类型的方法称为静态方法。在 Swift 中，我们使用 static 关键字创建静态方法。例如，

class Calculator {
  // static method
  static func add() {
  ...
  }
}

这里，add() 是静态方法。

要访问静态方法，我们使用类名。例如，

// access static method
Calculator.add()

实例：Swift 静态方法

class Calculator {
  // non-static method
  func multiply(num1: Int, num2: Int) -> Int {
    return num1 * num2
  }
  // static method
  static func add(num1: Int, num2: Int) -> Int {
    return num1 + num2
   }
}
// create an instance of the Calculator class
var obj = Calculator()
// call static method
var result2 =  Calculator.add(num1: 2, num2: 3)
print("2 + 3 =", result2)
// call non-static method
var result1 = obj.multiply(num1:2,num2:2)
print("2 * 2 =", result1)

结果为:

2 * 2 = 4
2 + 3 = 5

在上面的实例中，我们创建了一个名为 Calculator 的类。该类包含静态方法：add() 和非静态方法 - multiply()

• Calculator.add() - 使用类名调用静态方法

• multiply() - 使用类的对象调用非静态方法。

静态方法是类类型（与类而不是对象相关联），因此我们可以使用类名访问它们。

Swift 方法中的自身属性

有时，属性的名称和方法参数的名称可能相同。例如，

var physics = 0
func checkEligibility(physics: Int) {
...
}

这里，property 和 method 参数具有相同的名称 physics。

在这种情况下，名称之间可能存在歧义。为了区分它们，我们使用了 self 属性。self 属性是指方法的当前对象。

实例：swift 自属性

class Marks {
  var physics = 0
  func checkEligibility(physics: Int) {
    // using self property
    if (self.physics < physics) {
      print("Not Eligible for admission")
    }
    else {
      print("Eligible for admission")
    }
  }
}
var student1 = Marks()
student1.physics = 28
student1.checkEligibility(physics: 50)

结果为:

Not eligible for admission

在上面的例子中，我们对属性和方法参数使用了相同的名称 physics。

为了区分它们，我们在 checkEligibility() 方法中使用了 self 属性。

if (self.physics < physics) {
  ...
}

这里，

• self.physics -指值为 28 的 student1 对象的属性。

• physics - 指值为 50 的方法参数。

由于条件（28<50）为 true，因此执行 if 中的语句。

Swift mutating 方法

在 Swift 中，如果我们在类或结构中声明属性，则无法在方法中修改它们。例如，

struct Employee {
  var salary = 0.0
  ...
  func salaryIncrement() {
    // Error Code
    salary = salary * 1.5
  }
}

在这里，由于 struct 是一种值类型，如果我们试图修改 salary 的值，我们将得到一条错误消息。

然而，如果我们想从方法内部修改值类型的属性，我们需要在声明方法时使用 mutating 关键字。

实例：从方法修改值类型

struct Employee {
  var salary = 0
  // define mutating function
  mutating func salaryIncrement(increase: Int) {
  // modify salary property
  salary = salary + increase
  print("Increased Salary:",salary)
  }
}
var employee1 = Employee()
employee1.salary = 20000
employee1.salaryIncrement(increase: 5000)

结果如下:

Increased Salary: 25000

在上面的实例中，我们创建了一个名为 Employee 的结构。注意，

mutating func salaryIncrement(increase: Int) {
  // modify salary property
  salary = salary + increase
  ...
}

这里，mutating 方法让我们可以修改方法中的 salary 值。