跳到主要内容

Swift中的方法

提示
  1. 方法的定义和使用：方法是在 Swift 类内定义的函数，用于执行特定任务，可以通过类的对象调用。
  2. 静态方法和 self 属性：Swift 中的静态方法可以直接通过类名访问，而 self 属性用于解决方法参数与类属性同名的情况。
  3. 变异方法：在 Swift 结构体中，使用 mutating 关键字声明的方法允许在方法内部修改结构体的属性。

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

class Person {
  . . .

  // 定义方法
  func greet() {
  // 方法体
  }
}

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

示例 1：Swift 方法​

class Person {

  // 定义一个方法
  func greet() {
    print("嗨！")
  }
}

var nick = Person()

// 调用方法
nick.greet()

输出

嗨！

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

// 调用方法
nick.greet()

greet() 方法简单地在其内部打印字符串 "嗨！"。

示例 2：使用 Swift 方法计算面积和体积​

// 创建一个类
class Hall {

  var length = 0.0
  var breadth = 0.0
  var height = 0.0

  // 计算面积的方法
  func calculateArea() {
    print("大厅的面积 =", length * breadth)
  }

  // 计算体积的方法
  func calculateVolume() {
    print("大厅的体积 =", length * breadth * height)
  }
}

// 创建 Hall 类的对象
var hall1 = Hall()

hall1.length = 42.5
hall1.breadth = 30.8
hall1.height = 45.2

// 调用 calculateArea() 方法
hall1.calculateArea()

// 调用 calculateVolume() 方法
hall1.calculateVolume()

输出

房间的面积 = 1309.0
房间的体积 = 59166.8

在上面的示例中，我们创建了一个名为 Hall 的类，其中包含两个方法：

  • calculateArea() - 用于计算大厅的面积
  • calculateVolume() - 用于计算大厅的体积

由于这些方法在类内声明，我们使用了类的对象 hall1 来调用它们。

hall1.calculateArea()

hall1.calculateVolume()

Swift 静态方法​

在之前的例子中，我们使用了类的对象来访问其方法。然而，我们也可以创建不需要创建对象就能访问的方法。

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

class Calculator {

  // 静态方法
  static func add() {
  ...
  }
}

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

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

// 访问静态方法
Calculator.add()

示例：Swift 静态方法​

class Calculator {

  // 非静态方法
  func multiply(num1: Int, num2: Int) -> Int {
    return num1 * num2
  }

  // 静态方法
  static func add(num1: Int, num2: Int) -> Int {
    return num1 + num2
   }
}

// 创建 Calculator 类的实例
var obj = Calculator()

// 调用静态方法
var result2 =  Calculator.add(num1: 2, num2: 3)
print("2 + 3 =", result2)

// 调用非静态方法
var result1 = obj.multiply(num1: 2, num2: 2)
print("2 * 2 =", result1)

输出

2 * 2 = 4
2 + 3 = 5

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

这里，

  • Calculator.add() - 使用类名调用静态方法
  • obj.multiply() - 使用类的对象调用非静态方法。

静态方法是类类型的（与类相关而不是与对象相关），所以我们能够使用类名来访问它们。

注意：同样，我们也可以在结构体中创建静态方法。结构体中的静态方法属于结构体类型，所以我们使用结构体名称来访问它们。

Swift 方法中的 self 属性​

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

var physics = 0

func checkEligibility(physics: Int) {
...
}

这里，属性和方法参数的名称都是 physics。

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

示例：Swift self 属性​

class Marks {

  var physics = 0

  func checkEligibility(physics: Int) {

    // 使用 self 属性
    if (self.physics < physics) {
      print("不符合入学资格")
    }

    else {
      print("符合入学资格")
    }
  }
}

var student1 = Marks()
student1.physics = 28
student1.checkEligibility(physics: 50)

输出

不符合入学资格

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

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

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

这里，

  • self.physics - 指的是 student1 对象的属性，其值为 28。
  • physics - 指的是方法参数，其值为 50。

由于条件 (28 < 50) 为 true，if 内的语句被执行。

Swift 变异方法​

在 Swift 中，如果我们在类或结构体内声明了属性，我们不能在方法内修改它们。例如，

struct Employee {

  var salary = 0.0
  ...
  func salaryIncrement() {
    // 错误代码
    salary = salary * 1.5
  }

这里，由于 struct 是值类型，如果我们尝试修改 salary 的值，将会收到一个错误消息。

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

示例：从方法中修改值类型​

struct Employee {
  var salary = 0

  // 定义变异函数
  mutating func salaryIncrement(increase: Int) {

  // 修改 salary 属性
  salary = salary + increase
  print("增加后的工资:", salary)
  }
}

var employee1 = Employee()
employee1.salary = 20000
employee1.salaryIncrement(increase: 5000)

输出

增加后的工资: 25000

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

mutating func salaryIncrement(increase: Int) {

  // 修改 salary 属性
  salary = salary + increase
  ...
}

这里，mutating 方法允许我们在方法内部修改 salary 的值。

最后于 更新