Swiftda metodlar

Swiftda class ichida e'lon qilingan funksiya metod deyiladi. Masalan,

class Person {
  . . .    
 
  // metodlarni e'lon qilish
  func greet() {
  // metod tanasi    
  }
}

Bu yerda greet() — Person classi ichida e'lon qilingan metod. Metodlar haqida o'rganishdan oldin swiftdagi class va struct qanday ishlashini bilib olish kerak.

Misol:

Swift•

Oddiy Metod

class Person {

// metod e'lon qilish
func greet() {
  print("Salom!")
}
}

var nick = Person()

// metodga murojaat
nick.greet()

Yuqoridagi misolda Person classi ichida greet() nomli metod yaratdik. Bu yerda nick obyekti orqali metodga murojaat qildik.

// metodga murojaat
nick.greet()

greet() metodi shunchaki "Salom!" matnini chop etadi.

Misol:

Swift•

Bir necha metodlar

// class yaratish
class Hall {

var length = 0.0     // uzunlik
var breadth = 0.0    // kenglik
var height = 0.0     // balandlik

// yuzani hisoblash metodi
func calculateArea() {
  print("Xonaning yuzasi =", length * breadth)
}

// hajmni hisoblash metodi
func calculateVolume() {
  print("Xonaning hajmi =", length * breadth * height)
}
}

// Hall classidan obyekt yaratish
var hall1 = Hall()

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

// calculateArea() metodiga murojaat
hall1.calculateArea()

// calculateVolume() metodiga murojaat
hall1.calculateVolume()

Yuqoridagi misolda Hall nomli class yaratdik, uning ikkita metodi bor:

calculateArea() — xonaning yuzasini hisoblaydi
calculateVolume() — xonaning hajmini hisoblaydi

Bu metodlar class ichida e'lon qilingani uchun ularga hall1 obyekti orqali murojaat qildik.

hall1.calculateArea()

hall1.calculateVolume()

Static metodlar

Oldingi misollarda metodlarga obyekt orqali murojaat qilgan edik. Ammo obyekt yaratmasdan ham murojaat qilinadigan metodlar mavjud.

Bunday metodlar static metodlar deyiladi. Swiftda static metod yaratish uchun static kalit so'zidan foydalanamiz. Masalan,

class Calculator {

  // static metod 
  static func add() {
  ...  
  }
}

Bu yerda add() — static metod.

Static metodga murojaat qilish uchun klass nomidan foydalanamiz. Masalan,

// static metodga murojaat
Calculator.add()

Misol:

Swift•

Static Metod

class Calculator {

// non-static metod
func multiply(num1: Int, num2: Int) -> Int {
  return num1 * num2
}

// static metod
static func add(num1: Int, num2: Int) -> Int {
  return num1 + num2
 }
}

// Calculator classidan obyekt yaratish
var obj = Calculator()

// static metodga murojaat
var result2 = Calculator.add(num1: 2, num2: 3)
print("2 + 3 =", result2)

// non-static metodga murojaat
var result1 = obj.multiply(num1: 2, num2: 2)
print("2 * 2 =", result1)

Yuqoridagi misolda Calculator nomli class yaratdik. Class ichida static metod: add() va non-static metod: multiply() mavjud.

Bu yerda:

Calculator.add() — static metod, klass nomi orqali chaqiriladi
obj.multiply() — non-static metod, obyekt orqali chaqiriladi

Static metod — klass turiga tegishli (obyekt emas), shuning uchun ularga klass nomi orqali murojaat qilamiz.

Xuddi shunday, struct ichida ham static metodlar yaratish mumkin. Ularga struct nomi orqali murojaat qilinadi.

Metodlarda self propertysi

Ba'zan property nomi va metod parametri bir xil bo'lishi mumkin. Masalan,

var physics = 0

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

Bu yerda property va metod parametri bir xil nomga ega: physics.

Bunday holatlarda noaniqlik yuzaga kelishi mumkin. Ularni farqlash uchun self propertysi ishlatiladi. self — metoddagi joriy obyektga murojaat qiladi.

Misol:

Swift•

self Propertysi

class Marks {

var physics = 0     // fizika bali

func checkEligibility(physics: Int) {

  // self propertysi ishlatilmoqda
  if (self.physics < physics) {
    print("Qabul uchun nomzod emas")
  }

  else {
    print("Qabul uchun nomzod")
  }
}
}

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

Yuqoridagi misolda property va metod parametri uchun bir xil physics nomini ishlatdik.

Ularni farqlash uchun checkEligibility() metodi ichida self propertysi ishlatildi:

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

Bu yerda:

self.physics — student1 obyektining propertysi, qiymati 28
physics — metod parametri, qiymati 50

Shart (28 < 50) bajarilgani uchun if ichidagi kod ishlaydi.

Mutating metodlar

Swiftda class yoki struct ichidagi propertylarni metodlar ichidan o'zgartira olmaymiz. Masalan,

struct Employee {

  var salary = 0.0     // maosh
  ...
  func salaryIncrement() {
    // Xato kod
    salary = salary * 1.5
  }
}

Bu yerda struct — value type bo'lgani uchun salary qiymatini o'zgartirishga urinish xatoga olib keladi.

Ammo value type propertylarini metod ichidan o'zgartirish kerak bo'lsa, metod e'lon qilishda mutating kalit so'zini ishlatishimiz kerak.

Misol:

Swift•

Mutating Metod

struct Employee {
var salary = 0     // maosh

// mutating metodini e'lon qilish
mutating func salaryIncrement(increase: Int) {

// salary propertyni o'zgartirish  
salary = salary + increase
print("Oshirilgan maosh:", salary)
}
}

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

Yuqoridagi misolda Employee nomli struct yaratdik. E'tibor bering:

mutating func salaryIncrement(increase: Int) {

  // salary propertyni o'zgartirish  
  salary = salary + increase
  ...
}

mutating kalit so'zi struct propertylarini metod ichida o'zgartirish imkonini beradi.

Birinchi masalaning yechimi

Keling, birinchi masala "Oddiy metod" ni birga yechib ko'ramiz:

1-qadam: Masalani tushunish

Calculator classida multiply() methodi bo'lsin:

Ikkita Int parametr qabul qiladi
Ularni ko'paytirib qaytaradi

2-qadam: Yechim algoritmi

Parametrlarni ko'paytiramiz
Natijani qaytaramiz

3-qadam: Kodni yozamiz

Swift•

Calculator class yechimi

class Calculator {
  func multiply(a: Int, b: Int) -> Int {
      return a * b
  }
}

// Test
let calc = Calculator()
print("5 * 3 =", calc.multiply(a: 5, b: 3))
print("10 * 4 =", calc.multiply(a: 10, b: 4))
print("7 * 8 =", calc.multiply(a: 7, b: 8))

Natija: Oddiy metodni to'g'ri yaratdik va test qildik!