Swift - 方法

---

---

方法是特定类型（如类、结构体或枚举）的函数。它们定义了类型实例的行为和功能。它们通常由实例访问。Swift 还支持与类型本身关联的类型方法。

Swift 中的实例方法

在 Swift 中，实例方法是属于类、结构体或枚举特定实例的函数。它们在类型的实例上调用，并且可以访问和修改实例属性或其他实例方法，或者添加与实例需求相关的功能。

实例方法的语法与函数相同。实例方法也可以具有参数、返回类型、参数名称和参数标签。它可以写在 {} 花括号内。它隐式地访问类型实例的方法和属性。实例方法只能使用该特定类型的实例来调用，不允许在没有实例的情况下调用实例方法。

语法

以下是实例方法的语法：

func methodname(Parameters) -> returntype
{
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

实例方法使用“.”点语法访问。

instanceName.methodName()

示例

// Defining a class
class Calculations {

   // Properties
   let a: Int
   let b: Int
   let res: Int
    
   // Initializer
   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
   }
    
   // Instance method
   func tot(c: Int) -> Int {
      return res - c
   }
    
   // Instance method
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}

// Creating and initializing the instance of the class
let pri = Calculations(a: 600, b: 300)

// Accessing the instance method
pri.result()

输出

它将产生以下输出：

Result is: 880
Result is: 850

可变实例方法

在 Swift 中，结构体和枚举是值类型，这意味着我们不能在实例方法中更改属性。因此，要在方法内部修改属性，我们需要使用 mutating 关键字将该方法指定为可变方法，并且该方法在其属性中所做的更改将在方法结束时写回原始结构。

我们只能修改结构体和枚举的方法，而不能修改类的方法，因为类是引用类型，因此它们的属性可以在不使用 mutating 关键字的情况下修改。此外，我们不能在结构体类型的常量上调用可变方法。

语法

以下是可变实例方法的语法：

mutating func methodname(Parameters) -> returntype
{
   Statement
}

示例

Swift 程序演示结构体中的可变方法。

// Defining a structure
struct CalculateSum {

   // Properties
   var num1 = 1
   var num2 = 1
    
   // Instance method
   func sum() -> Int {
      return num1 + num2
   }
    
   // Mutating instance method
   mutating func increment(res: Int) {
      num1 *= res
      num2 *= res
        
      print("New Number 1 is ", num1)
      print("New Number 2 is ", num2)
   }
}

// Creating and initializing the instance of structure
var obj = CalculateSum(num1: 10, num2: 12)

// Calling mutating method
obj.increment(res: 10)

// Calling instance method
print("Sum is ", obj.sum())

输出

它将产生以下输出：

New Number 1 is  100
New Number 2 is  120
Sum is  220

在可变方法中将实例分配给 self

在可变方法中，允许我们将新实例分配给隐式 self 属性。它将用新实例替换现有实例。将新实例分配给 self 时，务必小心，因为它会更改实例的状态，并且与原始实例相关的任何引用都不会反映这些更改。

示例

Swift 程序演示如何在可变方法中将实例分配给 self。

// Defining a structure
struct Student {
   var age: Int
   var name: String
    
   // Mutating method that assigns a new instance to self
   mutating func newValue() {
      self = Student(age: 23, name: "Jyoti")
   }
}

// Creating an instance of the Student structure
var obj = Student(age: 22, name: "Poonam")

// Calling the mutating method
obj.newValue()

// Displaying the updated values
print("New age: \(obj.age), New name: \(obj.name)")

输出

它将产生以下输出：

New age: 23, New name: Jyoti

Swift 中的方法参数标签和参数名称

就像函数一样，方法也可以为其参数和参数设置标签和名称。这些标签和名称为参数和参数提供了清晰且描述性的上下文。参数名称用于方法的声明中，而参数标签用于调用方法时。默认情况下，参数标签和参数名称相同，但多个参数可以具有相同或唯一的参数标签。参数的名称应该唯一，以便编译器可以轻松地区分它们。我们还可以通过在参数名称前放置下划线 (_) 来忽略参数标签。

语法

以下是参数标签和参数名称的语法：

// Parameter name With argument label
func methodname(argumentLabel parameterName: Type, parameterName: Type) -> returntype
{
   Statement
   return value
}
methodname(name1:value, name2: value)

// Parameter name without argument label
func methodname(_name1: Type, _name2: Type) -> returntype
{
   Statement
   return value
}
methodname(value1, value2)

示例

Swift 程序演示如何在方法中指定参数名称和参数标签。

// Defining class
class CalculateSum {
    
   // Method with parameter name and argument label
   func addingTwoNumbers(num1 x: Int, num2 y: Int) -> Int {
      return x + y
   }
    
   // Method without argument label
   func addingThreeNumbers(_ x: Int, _ y: Int, num1 z: Int) -> Int {
      return x + y + z
   }
}

// Creating an instance of CalculateSum class
let obj = CalculateSum()

// Calling the method with parameter name and argument label
let result1 = obj.addingTwoNumbers(num1: 10, num2: 20)

// Calling the method without argument label
let result2 = obj.addingThreeNumbers(20, 30, num1: 40)

print("Sum of two numbers:", result1)
print("Sum of three numbers:", result2)

输出

它将产生以下输出：

Sum of two numbers: 30
Sum of three numbers: 90

方法中的 self 属性

self 关键字用于区分属性名称和方法的参数。self 关键字通常与实例方法、可变方法或初始化程序中的属性一起使用，以便编译器可以轻松地区分哪个是参数，哪个是属性（如果它们的名称相同）。或者 self 关键字用于引用当前实例以获取其定义的方法。我们可以在结构体、类和枚举中使用 self 关键字。

语法

以下是 self 关键字的语法：

self.PropertyName

示例

Swift 程序演示如何使用 self 关键字。

// Defining class
class Student {
   var name: String
    
   // Initializer 
   init(name: String) {
      self.name = name
   }
    
   // Instance method using self
   func greet(name: String) {
      self.name = name
      print("Hello, my name is \(self.name).")
   }
}

// Creating an instance of the Student class
var obj = Student(name: "Mona")

// Calling the greet method
obj.greet(name: "Mohina")

输出

它将产生以下输出：

Hello, my name is Mohina.

类型方法

Swift 支持一种称为类型方法的特殊类型的函数。类型方法在类型本身上调用，而不是在类型的实例上调用。这些方法在结构体和枚举中由static关键字表示，而在类中由class关键字表示。在类中，类型方法允许子类覆盖超类的类型方法实现。类型方法使用点 (.) 表示法访问。

在类型方法中，属性将引用类型本身，而不是类型的实例，这意味着我们可以区分类型属性和类型方法参数。类型方法允许在其他方法名称内调用另一个类型方法，而无需使用任何前缀类型名称。类似地，在结构体和枚举中，类型方法可以通过使用属性名称而不使用任何前缀类型来访问类型属性。

语法

以下是结构体和枚举中类型方法的语法：

static func methodname(Parameters) -> returntype
{
   Statement
}

以下是类中类型方法的语法：

class ClassName{
   class func methodname(Parameters) -> returntype
   {
      Statement
   }
}

以下是访问类型方法的语法：

type.typeMethodName()

示例

Swift 程序演示如何在结构体和类中创建和访问类型方法。

// Defining a structure
struct AreaOfRectangle {

   // Type method using static keyword
   static func area(_ length: Int, _ breadth: Int) -> Int {
      return length * breadth 
   }
}

// Defining a class
class Area {
   // Type method using class keyword
   class func areaOfTriangle(base: Double, height: Double) -> Double {
      return (1 * base * height)/2
   }
}

// Accessing type method of AreaOfRectangle structure
let result1 = AreaOfRectangle.area(12, 10)
print("Area of rectangle is ", result1)

// Accessing type method of Area class
let result2 = Area.areaOfTriangle(base: 5, height: 15)
print("Area of triangle is ", result2)

输出

它将产生以下输出：

Area of rectangle is  120
Area of triangle is  37.5

示例

Swift 程序演示类型方法如何调用另一个类型方法和类型属性。

// Defining a structure
struct Student {

   // Type Property
   static let name = "Mohina"
   static let totalMarks = 300

   // Type method to add marks of three major subjects
   static func add(_ Maths: Int, _ Chemistry: Int, _ Physics: Int) -> Int {
      return Maths + Physics + Chemistry
   }

   // Type method to find the percentage of three subjects marks by calling another type method
   static func percentage() -> Double {
    
      // Calling another type of method
      let finalMarks = Double(add(70, 80, 90))
        
      // Accessing type property
      let percentage = ((finalMarks / Double(totalMarks)) * 100)
      return percentage
   }
}

// Accessing a type property
print("Name of the student: \(Student.name)")

// Accessing a type method
print("Percentage: ", Student.percentage())

输出

它将产生以下输出：

Name of the student: Mohina
Percentage:  80.0