Os métodos en Swift son exactamente igual que as funcións vistas no tema anterior. A única diferenza é que os métodos están asociados a un tipo, é dicir, creámolos dentro dun tipo (dentro dunha Class ou Struct).

Os métodos dunha clase son rutinas de código que se poden chamar para realizar tarefas específicas dentro do contexto desa clase.

Os métodos veñen en dúas formas diferentes:

• Os métodos de instancia, funcionan só nas instancias dunha clase. Decláranse dentro das chaves de apertura e peche da clase á que pertencen e utilizando a sintaxe de declaración de funcións Swift estándar.
• Os métodos de tipo operan a nivel de clase. Decláranse da mesma maneira que os métodos de instancia, coa excepción de que a declaración está precedida pola palabra chave class

Por exemplo, a declaración dun método (de instancia) para mostrar o saldo da conta no noso exemplo podería ser a seguinte:

class ContaBancaria {
    var numConta: Int = 0
    var saldoConta: Float = 0.0
    
    func visualizarSaldo(){
        print("O número de conta é: \(numConta)")
        print("Saldo actual: \(saldoConta)")
    }
}

Ao deseñar a clase ContaBancaria, podería ser útil poder chamar a un método de tipo para identificar o saldo máximo permitido que pode almacenar a clase.

• Isto permitiría a unha aplicación identificar se a clase ContaBancaria é adecuada para almacenar detalles dun novo cliente sen ter que pasar polo proceso de crear primeiro unha instancia de clase.
• Este método chamarase getSaldoMax e impleméntase da seguinte maneira:

class ContaBancaria {
    var numConta: Int = 0
    var saldoConta: Float = 0.0
    
    func visualizarSaldo(){
        print("O número de conta é: \(numConta)")
        print("Saldo actual: \(saldoConta)")
    }
    
    class func getSaldoMax() -> Float{
        return 10000000.00
    }
}

print("Saldo máximo: \(ContaBancaria.getSaldoMax())")

Métodos de instancia #

Son métodos que creamos dentro dun tipo, por exemplo dentro dunha Struct ou Class.

class Xogo {
    var puntuacion = 0
    
    func incrementarPuntuacion() {
        puntuacion += 1
    }
       
    func reset() {
        puntuacion = 0
    }
}

let game = Xogo()
game.incrementarPuntuacion()
game.incrementarPuntuacion()

print(game.puntuacion)

No anterior exemplo creamos unha Class con 2 métodos (liñas 4 e 8). Estes 2 métodos son métodos de instancia, por tanto primeiro temos que crear unha instancia de Xogo (liña 13) para poder acceder aos seus métodos (liñas 14 e 15).

Modificar propiedades mediante métodos de Instancia en Struct #

As propiedades dunha Struct, por defecto, non poden modificarse dentro dos métodos da súa instancia. Así, o seguinte código dará erro de compilación na liña 4:

struct Usuario {
    var nome: String
    
    func update(nome: String) {
        self.nome = nome
    }
}

Para poder modificar o valor da propiedade nome desde o método da Struct, temos que engadir a keyword mutating ao comezo do método:

struct Usuario {
    var nome: String
    
    mutating func update(nome: String) {
        self.nome = nome
    }
}

Nas clases, este problema non o temos, xa que se pasan por referencia e non fará falta indicar a keyword mutating:

class Usuario {
    var nome: String
    
    init(nome: String) {
        self.nome = nome
    }
    
    func update(nome: String) {
        self.nome = nome
    }
}

self #

Ao crear unha instancia dun tipo (Struct ou Class, por exemplo) podemos acceder á propiedade implícita chamada self.

Usamos esta propiedade self para referirnos á instancia actual e así poder chamar ás propiedades e métodos que temos dentro do tipo:

class ProbaSelf {
    var numero = 0
    
    func engadirDez() {
        self.numero += 5
        numero += 5
        print("numero = \(self.numero)")
    }
    
    func engadir(numero: Int) {
        self.numero += numero
        print("numero = \(self.numero)")
    }
    
}

var proba = ProbaSelf()
proba.engadirDez() //Imprime: numero = 10
proba.engadir(numero: 20) //Imprime: numero = 30

• Na maioría dos casos, o seu uso é opcional (liñas 5 e 7).
• En ocasións é obrigatorio, por exemplo, nas liñas 11 e 12, temos que distinguir dúas variables que se chaman igual. No exemplo, a propiedade numero chámase igual ca variable pasada por parámetro á función engadir.

Outro exemplo #

Por exemplo, na clase Xogo que vimos na sección anterior, poderiamos usar self para chamar ás propiedades e os seus métodos.
Imos modificar a clase que vimos antes e vou engadir un método novo chamado imprimirPuntuacion:

class Xogo {
    var puntuacion = 0
    
    func incrementarPuntuacion() {
        self.puntuacion += 1
        self.imprimirPuntuacion()
    }
       
    func reset() {
        self.puntuacion = 0
    }
    
    func imprimirPuntuacion() {
        print("Puntuación incrementada! \(puntuacion)")
    }
}

let game = Xogo()
game.incrementarPuntuacion()
game.incrementarPuntuacion()

print(game.puntuacion)

// RESULTADO 👇
// 2

Métodos de estáticos e de clase #

Métodos de tipo ou estáticos #

Os métodos de tipo ou estáticos son métodos que podemos chamar directamente desde a nosa Class ou Struct sen crear a instancia do tipo. Para diferenciar un método de instancia dun método de tipo, usamos a keyword static.

Imos ver un exemplo creando unha estrutura cun método de tipo:

struct Coche {
    var pasaxeiros = 0
    
    static func prenderMotor() {
        print("Start engine...")
    }
    
    func engadirPasaxeiro() {
        pasaxeiros += 1
    }
       
    func apagarMotor() {
        pasaxeiros = 0
    }
}

Coche.prenderMotor()

// RESULTADO 👇
// Start engine...

Para usar o método prenderMotor() chamamos á función directamente sen crear unha instancia (liña 17)

• Para chamar a métodos ou propiedades de instancia, primeiro debemos crear unha instancia do noso tipo.
• En cambio, para chamar a métodos estáticos, escribimos o tipo e directamente o método ou propiedade que queremos usar.

Métodos de clase #

En Swift, unha función ou método de clase é moi parecido o un método estático, pero so se pode asociar cunha clase (non es estruturas).

Emprégase a palabra chave class

Imos ver un exemplo dun método de clase:

struct Coche {
    var pasaxeiros = 0
    
    class func prenderMotor() {
        print("Start engine...")
    }
    
    func engadirPasaxeiro() {
        pasaxeiros += 1
    }
       
    func apagarMotor() {
        pasaxeiros = 0
    }
}

Coche.prenderMotor()

// RESULTADO 👇
// Start engine...

Diferencias entre métodos estáticos e de clase #