Swift - Methods

---

---

Methods are the functions of a particular type, such as class, structure or enumeration. They define the behavior and functionality for instances of a type. They are generally accessed by the instances. Swift also supports type methods that are associated with the type itself.

Instance Methods in Swift

In Swift, instance methods are the functions that belong to the specific instance of a class, structure or enumeration. They are called on an instance of the type and can access and modify instance properties or other instance methods, or also add functionality related to the instance's need.

The syntax of the instance method is the same as the function. Instance method can also have, parameters, return type, parameter names, and argument labels. It can be written inside the {} curly braces. It has implicit access to methods and properties of the type instance. An instance method is called only using the instance of that particular type, we are not allowed to call an instance method without any instance.

Syntax

Following is the syntax of the instance method-

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

Instance methods are accessed with '.' dot syntax.

instanceName.methodName()

Example

// 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()

Output

It will produce the following output −

Result is: 880
Result is: 850

Mutating Instance Method

In Swift, structures and enumerations are value types, which means we cannot alter the properties inside the instance method. So to modify the properties inside a method we need to specify that method as a mutating method using the mutating keyword and the changes made by the method in its properties will written back to the original structure when the method ends.

We can only mutate methods of structure and enumeration but not class because a class is a reference type so their properties can be modified without using mutating keyword. Also, we cannot call a mutating method on a constant of structure type.

Syntax

Following is the syntax of the mutating instance method −

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

Example

Swift program to demonstrate the mutating method in structure.

// 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())

Output

It will produce the following output −

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

Assigning Instance to self within a Mutating Method

In mutating methods, we are allowed to assign a new instance to the implicit self property. It will replace the existing instance with the new instance. While assigning a new instance to the self always be careful because it changes the state of the instance and any reference related to the original instance will not reflect the changes.

Example

Swift program to demonstrate how to assign an instance to self within a mutating method.

// 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)")

Output

It will produce the following output −

New age: 23, New name: Jyoti

Method Argument label and Parameter name in Swift

Just like a function, a method can also have labels and names for its arguments and parameters. These labels and names provide a clear and descriptive context for the argument and parameter. The parameter name is used in the declaration of the method whereas the argument label is used when the method is called. By default, the argument label and parameter name are the same, but multiple parameters can have the same or unique argument label. The names of the parameters should be unique so that the compiler can easily distinguish them. We can also ignore the argument label by placing the underscore(_) before the name of the parameter.

Syntax

Following is the syntax for the argument label and parameter name −

// 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)

Example

Swift program to demonstrate how to specify the parameter name and argument label in the method.

// 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)

Output

It will produce the following output −

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

The self property in Methods

The self keyword is used to distinguish between the property name and the method’s parameters. The self keyword is generally used with a property inside the instance methods, mutating methods, or initializer so that the compiler can easily discriminate which one is a parameter and a property if their names are the same. Or the self keyword is used to refer to the current instance for its defined methods. We can use the self keyword in structure, classes, and enumerations.

Syntax

Following is the syntax of the self keyword −

self.PropertyName

Example

Swift program to demonstrate how to use self keyword.

// 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")

Output

It will produce the following output −

Hello, my name is Mohina.

Type Methods

Swift supports a special type of methods that are known as Type methods. Type methods are called on the type itself, not by the instance of the type. These methods are represented by a static keyword in Structure and Enumeration whereas a class keyword in Classes. In classes, the type method allows a subclass to override the superclass’s implementation of the type method. The type method is accessed by using dot(.) notation.

In the type method, the property will refer to the type itself, not the instance of the type, which means we can distinguish between type property and type method parameters. A type method is allowed to call another type method within the other method’s name without using any prefix type name. Similarly in structure and enumeration, a type method can access the type property by using the name of the property without any prefix type.

Syntax

Following is the syntax of the type method in structure and enumeration −

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

Following is the syntax of the type method in class −

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

Following is the syntax of the accessing type method −

type.typeMethodName()

Example

Swift program to demonstrate how to create and access type methods in structure and class.

// 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)

Output

It will produce the following output −

Area of rectangle is  120
Area of triangle is  37.5

Example

Swift program to demonstrate how a type method calls another type method and type property.

// 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())

Output

It will produce the following output −

Name of the student: Mohina
Percentage:  80.0