Métodos Swift

Métodos Swift são funções associadas a tipos específicos

No Objective-No C, a classe é o único tipo que pode definir métodos. Mas no Swift, você não só pode escolher se deseja definir uma classe/Estrutura/Enumeração, ainda pode ser flexível no tipo que você criar (classe/Estrutura/definir métodos em enumeração).

Métodos de exemplo

Em Swift, métodos de exemplo pertencem a um exemplo específico de classe, estrutura ou tipo de enumeração.

Métodos de exemplo fornecem os seguintes métodos:

• Pode acessar e modificar propriedades do exemplo

• Fornecer funcionalidades relacionadas ao objetivo do exemplo

Métodos de exemplo devem ser escritos entre os chavetas de abertura e fechamento do tipo ao qual pertencem ({}).

Métodos de exemplo podem acessar implicitamente todos os outros métodos e propriedades do tipo ao qual pertencem.

Métodos de exemplo podem ser chamados apenas por um exemplo específico da classe a que pertencem.

Métodos de exemplo não podem ser chamados sem se separar de um exemplo existente.

Sintaxe

func funcname(Parâmetros) -> tiporetorno
{
    Sentença1
    Sentença2
    ……
    Sentença N
    retornar parâmetros
}

Exemplo Online

import Cocoa
class Counter {
    var count = 0
    func increment() {
        contagem += 1
    }
    func incrementarPor(quantidade: Int) {
        contagem += quantidade
    }
    func reset() {
        contagem = 0
    }
}
// O valor contabilizado inicial é 0
let contagem = Counter()
// O valor contabilizado agora é1
contagem.increment()
// O valor contabilizado agora é6
contagem.incrementarPor(quantidade: 5)
print(contagem.contagem)
// O valor contabilizado agora é 0
contagem.reset()
print(contagem.contagem)

O resultado de execução do programa acima é:

6
0

A classe Counter define três métodos de exemplo:

• increment Aumentar o contador por 1 Aumentar;
• incrementarPor(quantidade: Int) Aumentar o contador por um valor inteiro específico;
• reset Reiniciar o contador para 0.

Counter Essa classe também declara um atributo mutável contagempara manter o rastreamento do valor atual do contador.

Os nomes dos parâmetros locais e dos parâmetros externos dos métodos

Os parâmetros de função no Swift podem ter tanto um nome local (usado dentro do corpo da função) quanto um nome externo (usado ao chamar a função)

Os métodos no Swift e no Objective-Os métodos no C são extremamente semelhantes. Como no Objective-Da mesma forma que no C, o nome do método no Swift geralmente usa um préposicional para apontar para o primeiro parâmetro, como: com, para, por etc.

O Swift padrão fornece apenas um nome de parâmetro local para o primeiro parâmetro do método; padrão, também fornece nomes de parâmetro globais para os segundos e os parâmetros subsequentes.

No exemplo a seguir, 'não1' é declarado como nome de parâmetro local no Swift. 'não2' é usado para declarações globais e acessadas por programas externos.

import Cocoa
class divisão {
    var contagem: Int = 0
    func incrementarPor(não1: Int, não2: Int) {
        contagem = não1 / não2
        print(contagem)
    }
}
let contagem = divisão()
contagem.incrementarPor(não1: 1800, sem2: 3)
contagem.incrementarPor(não1: 1600, sem2: 5)
contagem.incrementarPor(não1: 11000, sem2: 3)

O resultado de execução do programa acima é:

600
320
3666

Se fornecer nome externo

Nós forçamos a adição de um nome externo ao primeiro parâmetro para usar esse nome local como nome externo (Swift 2.0 antes é usar o sinal #).

Ao contrário, também podemos usar o sublinhado (_ _) para definir o segundo e os parâmetros subsequentes sem fornecer um nome externo.

import Cocoa
class multiplicação {
    var contagem: Int = 0
    func incrementarPor(primeiro não1: Int, não2: Int) {
        contagem = não1 * não2
        print(contagem)
    }
}
let contagem = multiplicação()
counter.incrementBy(first: 800, sem2: 3)
counter.incrementBy(first: 100, sem2: 5)
counter.incrementBy(first: 15000, sem2: 3)

O resultado de execução do programa acima é:

2400
500
45000

Atributo self

Cada exemplo do tipo tem um atributo implícito chamado self, que é completamente equivalente ao exemplo em si.

Você pode usar o atributo implícito self em um método de exemplo de um exemplo para se referir ao exemplo atual.

import Cocoa
class cálculos {
    let a: Int
    let b: Int
    let res: Int
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
        res = a + b
        print("Dentro de Self: \(res)")
    }
    func tot(c: Int) -> Int {
        return res - c
    }
    func result() {
        print("O resultado é: \(tot(c: 20))
        print("O resultado é: \(tot(c: 50))
    }
}
let pri = cálculos(a: 600, b: 300)
let sum = cálculos(a: 1200, b: 300)
pri.result()
sum.result()

O resultado de execução do programa acima é:

Dentro de Self: 900
Dentro de Self: 1500
O resultado é: 880
O resultado é: 850
O resultado é: 1480
O resultado é: 1450

Modificação de tipos de valor em métodos de exemplo

Estruturas e enums no Swift são tipos de valor. Geralmente, os atributos de tipos de valor não podem ser modificados em seus métodos de exemplo.

Mas, se você realmente precisar modificar os atributos de uma estrutura ou enumeração em um método específico, você pode optar por mutável (mutating) esse método, então o método pode mudar seus atributos internamente; e qualquer mudança feita será mantida no exemplo original no final do método.

O método também pode atribuir um novo exemplo ao atributo implícito self, que substituirá o exemplo original no final do método.

import Cocoa
struct área {
    var largura = 1
    var largura = 1
    func área() -> Int {
        return largura * largura
    }
    mutável func scaleBy(res: Int) {
        largura *= res
        largura *= res
        print(largura)
        print(largura)
    }
}
var val = área(largura: 3, largura: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

O resultado de execução do programa acima é:

9
15
270
450
81000
135000

Atribuição de valores em métodos mutáveis

Métodos mutáveis podem atribuir um novo exemplo ao atributo implícito self.

import Cocoa
struct área {
    var largura = 1
    var largura = 1
    func área() -> Int {
        return largura * largura
    }
    mutável func scaleBy(res: Int) {
        self.largura *= res
        self.largura *= res
        print(largura)
        print(largura)
    }
}
var val = área(largura: 3, largura: 5)
val.scaleBy(res: 13)

O resultado de execução do programa acima é:

39
65

Método de tipo

Os métodos de exemplo são chamados por uma instância do tipo. Você também pode definir métodos que a própria instância do tipo pode chamar, esses métodos são chamados de métodos de tipo.

Os métodos de tipo declarados em estruturas e enumerações devem ter a palavra-chave static antes da palavra-chave func. As classes podem usar a palavra-chave class para permitir que subclasses sobrescrevam a implementação dos pais.

Os métodos de tipo são chamados usando a sintaxe de ponto (.) como os métodos de exemplo.

import Cocoa
classe Math
{
    função de classe class func abs(number: Int) -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}
struct absno
{
    função estática 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)

O resultado de execução do programa acima é:

35
5