14.11.2024

Lição 24: Protocolos e Padrão de Delegação em Swift

Nesta lição, exploraremos dois conceitos importantes em Swift: Protocolos e o Padrão de Delegação. Compreender esses conceitos é fundamental para criar um código flexível e reutilizável em suas aplicações.

O que são Protocolos?

Um protocolo em Swift é um modelo para métodos, propriedades e outros requisitos que se adequam a uma determinada tarefa ou funcionalidade. Quando uma classe, estrutura ou enumeração adota um protocolo, ela deve implementar todos os requisitos definidos por esse protocolo.

Definindo um Protocolo

Aqui está um exemplo simples de como definir e adotar um protocolo:

protocol Veiculo {
    var numeroDeRodas: Int { get }
    func ligarMotor()
}

class Carro: Veiculo {
    var numeroDeRodas: Int {
        return 4
    }

    func ligarMotor() {
        print("Motor do carro ligado.")
    }
}

class Moto: Veiculo {
    var numeroDeRodas: Int {
        return 2
    }

    func ligarMotor() {
        print("Motor da moto ligado.")
    }
}

Neste exemplo, definimos um protocolo Veiculo com uma propriedade e um método. As classes Carro e Moto adotam esse protocolo e fornecem suas próprias implementações.

O que é o Padrão de Delegação?

O padrão de delegação é um padrão de design que permite que um objeto se comunique de volta com outro objeto. É comumente utilizado no UIKit para lidar com eventos e gerenciar interações entre objetos.

Implementando o Padrão de Delegação

Vamos ilustrar o padrão de delegação com um exemplo. Criaremos uma classe simples Contador que notifica seu delegado quando a contagem muda.

Passo 1: Definir o Protocolo

Primeiro, definimos um protocolo ao qual o delegado irá se conformar:

protocol DelegadoContador: AnyObject {
    func contadorIncrementadoPara(valor: Int)
}

Passo 2: Criar a Classe Contador

Em seguida, implementamos a classe Contador que utiliza este protocolo:

class Contador {
    weak var delegado: DelegadoContador?
    private var contagem: Int = 0

    func incrementar() {
        contagem += 1
        delegado?.contadorIncrementadoPara(valor: contagem)
    }
}

Observe que usamos uma referência weak para o delegado, o que ajuda a prevenir ciclos de retenção.

Passo 3: Implementar o Delegado

Agora, criamos uma classe que atua como delegado:

class ViewController: DelegadoContador {
    let contador = Contador()

    init() {
        contador.delegado = self
    }

    func contadorIncrementadoPara(valor: Int) {
        print("O valor do contador agora é \(valor)")
    }
}

Usando o Contador

Agora, quando criamos uma instância de ViewController e chamamos o método incrementar no contador, ele notificará o delegado sobre as mudanças:

let viewController = ViewController()
viewController.contador.incrementar() // Saída: O valor do contador agora é 1
viewController.contador.incrementar() // Saída: O valor do contador agora é 2

Vantagens de Usar Protocolos e Delegação

1. Reusabilidade: Você pode definir comportamentos comuns em protocolos e adotá-los em diversas classes, estruturas ou enums.

2. Separação de Responsabilidades: A delegação permite que um objeto gerencie o comportamento de outro, mantendo suas responsabilidades separadas.

3. Flexibilidade: Você pode facilmente mudar ou adicionar funcionalidades ao fazer diferentes delegados implementarem o mesmo protocolo.

Conclusão

Nesta lição, abordamos os fundamentos dos Protocolos e do Padrão de Delegação em Swift. Usando esses poderosos conceitos, você pode escrever um código modular, manutenível e reutilizável. Na próxima lição, mergulharemos mais profundamente em outro tópico essencial em Swift. Boas codificações!

Video

Navigation