Swift - Métodos

Na linguagem Swift 4, as funções associadas a tipos específicos são chamadas de métodos. Em Objective C Classes são usadas para definir métodos, enquanto a linguagem Swift 4 fornece ao usuário flexibilidade para ter métodos para Classes, Estruturas e Enumerações.

Métodos de Instância

Na linguagem Swift 4, as instâncias de Classes, Structures e Enumeration são acessadas através dos métodos de instância.

Métodos de instância fornecem funcionalidade

Para acessar e modificar as propriedades da instância
funcionalidade relacionada à necessidade da instância

O método de instância pode ser escrito dentro das {} chaves. Ele tem acesso implícito a métodos e propriedades da instância do tipo. Quando uma instância específica do tipo é chamada, ela obterá acesso a essa instância específica.

Sintaxe

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

Exemplo

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}
let pri = calculations(a: 600, b: 300)
pri.result()

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

Result is: 880
Result is: 850

Class Calculations define dois métodos de instância -

init () é definido para adicionar dois números aeb e armazená-los no resultado 'res'
tot () é usado para subtrair o 'res' de passar o valor 'c'

Finalmente, para imprimir os métodos de cálculos com valores para a e b é chamado. Os métodos de instância são acessados com '.' sintaxe de ponto

Nomes de parâmetros locais e externos

As funções do Swift 4 descrevem declarações locais e globais para suas variáveis. Da mesma forma, as convenções de nomenclatura dos Métodos do Swift 4 também se parecem com as do Objetivo C. Mas as características das declarações de nomes de parâmetros locais e globais são diferentes para funções e métodos. O primeiro parâmetro no Swift 4 são referidos por nomes de preposição como 'com', 'para' e 'por' para facilitar o acesso às convenções de nomenclatura.

O Swift 4 fornece flexibilidade nos métodos, declarando o primeiro nome do parâmetro como nomes de parâmetros locais e os nomes de parâmetros restantes como nomes de parâmetros globais. Aqui, 'no1' é declarado pelos métodos Swift 4 como nomes de parâmetros locais. 'no2' é usado para declarações globais e acessado por meio do programa.

class division {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 / no2
      print(count)
   }
}

let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

600
320
3666

Nome do parâmetro externo com # e símbolo _

Mesmo que os métodos do Swift 4 forneçam primeiros nomes de parâmetro para declarações locais, o usuário tem a possibilidade de modificar os nomes de parâmetro de declarações locais para globais. Isso pode ser feito prefixando o símbolo '#' com o primeiro nome do parâmetro. Ao fazer isso, o primeiro parâmetro pode ser acessado globalmente em todos os módulos.

Quando o usuário precisa acessar os nomes dos parâmetros subsequentes com um nome externo, o nome do método é substituído com a ajuda do símbolo '_'.

class multiplication {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 * no2
      print(count)
   }
}

let counter = multiplication()

counter.incrementBy(no1: 800, no2: 3)
counter.incrementBy(no1: 100, no2: 5)
counter.incrementBy(no1: 15000, no2: 3)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

2400
500
45000

Propriedade própria em métodos

Os métodos têm uma propriedade implícita conhecida como 'self' para todas as suas instâncias de tipo definidas. A propriedade 'Self' é usada para referir as instâncias atuais para seus métodos definidos.

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
      print("Inside Self Block: \(res)")
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450

Modificando Tipos de Valor de Métodos de Instância

Na linguagem Swift 4, as estruturas e enumerações pertencem a tipos de valor que não podem ser alterados por seus métodos de instância. No entanto, a linguagem Swift 4 fornece flexibilidade para modificar os tipos de valor por 'mutação' do comportamento. Mutate fará qualquer alteração nos métodos de instância e retornará à forma original após a execução do método. Além disso, pela propriedade 'self' uma nova instância é criada para sua função implícita e irá substituir o método existente após sua execução

struct area {
   var length = 1
   var breadth = 1
   
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      length *= res
      breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado -

Propriedade própria para método mutante

Métodos mutantes combinados com a propriedade 'self' atribuem uma nova instância ao método definido.

struct area {
   var length = 1
   var breadth = 1
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      self.length *= res
      self.breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado. -

39
65

Métodos de Tipo

Quando uma determinada instância de um método é chamada, ela é chamada como um método de Instância; e quando o método chama um tipo específico de método, ele é chamado de 'Métodos de tipo'. Os métodos de tipo para 'classes' são definidos pela palavra-chave 'func' e os métodos de tipo de estruturas e enumerações são definidos com a palavra-chave 'estática' antes da palavra-chave 'func'.

Os métodos de tipo são chamados e acessados por '.' sintaxe onde, em vez de chamar uma instância particular, todo o método é invocado.

class Math {
   class func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

struct absno {
   static func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

let no = Math.abs(number: -35)
let num = absno.abs(number: -5)

print(no)
print(num)

Quando executamos o programa acima usando playground, obtemos o seguinte resultado. -

35
5