Swift Academy · Aula

Protocolos como Contratos

Defina contratos de comportamento independentes dos tipos.

Protocolos como Contratos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que é um protocolo

Um protocolo define um modelo de métodos, propriedades e outros requisitos que um tipo que esteja em conformidade precisa implementar. É um contrato: qualquer tipo que o adote promete fornecer tudo o que o protocolo declara.

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

Conformidade com um protocolo

Um tipo entra em conformidade ao adotar o protocolo e fornecer todos os requisitos. Aqui, uma estrutura atende tanto à propriedade name quanto ao método greet().

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

struct Person: Greetable {
    let name: String
    func greet() -> String { "Hello, I am " + name }
}

let p = Person(name: "Ada")
print(p.greet())

Requisitos de propriedade

Os protocolos especificam se uma propriedade precisa permitir leitura ({ get }) ou permitir leitura e escrita ({ get set }). Uma propriedade armazenada ou calculada pode atender a um requisito somente de leitura.

protocol Identifiable {
    var id: String { get }
}

struct User: Identifiable {
    let id: String
}

print(User(id: "u-1").id)

Requisitos de método

Os requisitos de método listam o nome, os parâmetros e o tipo de retorno, mas não possuem corpo. Os tipos que entram em conformidade fornecem a implementação.

protocol Shape {
    func area() -> Double
}

struct Square: Shape {
    let side: Double
    func area() -> Double { side * side }
}

print(Square(side: 3).area())

Requisitos de mutação

Para tipos-valor, os métodos que alteram self precisam ser marcados com mutating. Declare o requisito com mutating para que as estruturas possam atendê-lo.

protocol Toggleable {
    mutating func toggle()
}

struct Switch: Toggleable {
    var isOn = false
    mutating func toggle() { isOn.toggle() }
}

var s = Switch()
s.toggle()
print(s.isOn)

Protocolos como tipos

Um protocolo é um tipo de primeira classe. É possível utilizá-lo em variáveis, parâmetros e valores de retorno, aceitando qualquer valor que esteja em conformidade.

protocol Animal { func sound() -> String }
struct Dog: Animal { func sound() -> String { "Woof" } }
struct Cat: Animal { func sound() -> String { "Meow" } }

let animals: [Animal] = [Dog(), Cat()]
for a in animals { print(a.sound()) }

Polimorfismo por meio de protocolos

Chamar um método de protocolo encaminha a chamada para o tipo concreto por trás do valor. Isso permite escrever código que funcione com muitos tipos por meio de um único contrato.

protocol Describable { func describe() -> String }
struct Book: Describable { let t: String; func describe() -> String { "Book: " + t } }
struct Film: Describable { let t: String; func describe() -> String { "Film: " + t } }

func show(_ d: Describable) { print(d.describe()) }
show(Book(t: "Swift"))
show(Film(t: "Inception"))

Requisitos de inicializador

Os protocolos podem exigir inicializadores. As classes precisam marcar a implementação com required para que as subclasses também a forneçam.

protocol FromInt {
    init(value: Int)
}

struct Wrapper: FromInt {
    let value: Int
    init(value: Int) { self.value = value }
}

print(Wrapper(value: 42).value)

Herança de protocolos

Um protocolo pode herdar de um ou mais outros protocolos, adicionando requisitos extras aos requisitos herdados.

protocol Named { var name: String { get } }
protocol Aged: Named { var age: Int { get } }

struct Member: Aged {
    let name: String
    let age: Int
}

let m = Member(name: "Lin", age: 30)
print(m.name, m.age)

Protocolos exclusivos para classes

Marque um protocolo com AnyObject para restringir a conformidade a classes, o que é útil para requisitos de semântica de referência, como delegação.

protocol Counter: AnyObject {
    var count: Int { get set }
}

class Box: Counter {
    var count = 0
}

let b = Box()
b.count = 5
print(b.count)

Verificando a conformidade

Utilize is e as? para testar em tempo de execução se um valor está em conformidade com um protocolo.

protocol Flyer { func fly() }
struct Bird: Flyer { func fly() { print("flap") } }
struct Rock {}

let things: [Any] = [Bird(), Rock()]
for t in things {
    if let f = t as? Flyer { f.fly() } else { print("grounded") }
}

Verificação rápida

Teste sua compreensão dos requisitos de protocolo.

Recapitulação

Você aprendeu que um protocolo é um contrato: ele declara requisitos de propriedade, método, mutação e inicializador sem implementações. Os tipos entram em conformidade ao atender a todos os requisitos; os protocolos podem ser utilizados como tipos para polimorfismo, podem herdar de outros protocolos e podem ser restritos a classes com AnyObject.

Perguntas Frequentes

A aula “Protocolos como Contratos” é grátis?

Sim — o texto completo de “Protocolos como Contratos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Protocolos como Contratos”?

Defina contratos de comportamento independentes dos tipos. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Protocolos como Contratos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy