Swift 方法

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

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

  1. class Person {
  2. . . .
  3. // define methods
  4. func greet() {
  5. // method body
  6. }
  7. }

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


实例: 类方法
  1. class Person {
  2. // define a method
  3. func greet() {
  4. print("Hey there!")
  5. }
  6. }
  7. var nick = Person()
  8. // call method
  9. nick.greet()

结果为:

  1. Hey there!

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

  1. // call method
  2. nick.greet()

实例:使用 Swift 方法计算面积和体积
  1. // create a class
  2. class Hall {
  3. var length = 0.0
  4. var breadth = 0.0
  5. var height = 0.0
  6. // method to calculate area
  7. func calculateArea() {
  8. print("Area of Hall =", length * breadth)
  9. }
  10. // method to calculate volume
  11. func calculateVolume() {
  12. print("Volume of Hall =", length * breadth * height)
  13. }
  14. }
  15. // create object of Hall class
  16. var hall1 = Hall()
  17. hall1.length = 42.5
  18. hall1.breadth = 30.8
  19. hall1.height = 45.2
  20. // call calculateArea() method
  21. hall1.calculateArea()
  22. // call calculateVolume() method
  23. hall1.calculateVolume()

结果为:

  1. Area of Room = 1309.0
  2. Volume of Room = 59166.8

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

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

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

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

  1. hall1.calculateArea()
  2. hall1.calculateVolume()

Swift 静态方法

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

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

  1. class Calculator {
  2. // static method
  3. static func add() {
  4. ...
  5. }
  6. }

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

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

  1. // access static method
  2. Calculator.add()
实例:Swift 静态方法
  1. class Calculator {
  2. // non-static method
  3. func multiply(num1: Int, num2: Int) -> Int {
  4. return num1 * num2
  5. }
  6. // static method
  7. static func add(num1: Int, num2: Int) -> Int {
  8. return num1 + num2
  9. }
  10. }
  11. // create an instance of the Calculator class
  12. var obj = Calculator()
  13. // call static method
  14. var result2 = Calculator.add(num1: 2, num2: 3)
  15. print("2 + 3 =", result2)
  16. // call non-static method
  17. var result1 = obj.multiply(num1:2,num2:2)
  18. print("2 * 2 =", result1)

结果为:

  1. 2 * 2 = 4
  2. 2 + 3 = 5

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

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

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

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

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

Swift 方法中的自身属性

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

  1. var physics = 0
  2. func checkEligibility(physics: Int) {
  3. ...
  4. }

这里,propertymethod 参数具有相同的名称 physics

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

实例:swift 自属性
  1. class Marks {
  2. var physics = 0
  3. func checkEligibility(physics: Int) {
  4. // using self property
  5. if (self.physics < physics) {
  6. print("Not Eligible for admission")
  7. }
  8. else {
  9. print("Eligible for admission")
  10. }
  11. }
  12. }
  13. var student1 = Marks()
  14. student1.physics = 28
  15. student1.checkEligibility(physics: 50)

结果为:

  1. Not eligible for admission

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

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

  1. if (self.physics < physics) {
  2. ...
  3. }

这里,

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

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

由于条件(28<50)为 true,因此执行 if 中的语句。


Swift mutating 方法

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

  1. struct Employee {
  2. var salary = 0.0
  3. ...
  4. func salaryIncrement() {
  5. // Error Code
  6. salary = salary * 1.5
  7. }
  8. }

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

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

实例:从方法修改值类型
  1. struct Employee {
  2. var salary = 0
  3. // define mutating function
  4. mutating func salaryIncrement(increase: Int) {
  5. // modify salary property
  6. salary = salary + increase
  7. print("Increased Salary:",salary)
  8. }
  9. }
  10. var employee1 = Employee()
  11. employee1.salary = 20000
  12. employee1.salaryIncrement(increase: 5000)

结果如下:

  1. Increased Salary: 25000

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

  1. mutating func salaryIncrement(increase: Int) {
  2. // modify salary property
  3. salary = salary + increase
  4. ...
  5. }

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