Swift Academy · Aula

Princípios de design orientado a protocolos

Prefira a composição de protocolos à herança de classes para obter um design flexível.

Princípios de design orientado a protocolos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 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.

Boas-vindas

A programação orientada a protocolos (POP) favorece a composição de protocolos em vez da herança de classes para criar código Swift flexível, testável e reutilizável.

O problema da herança

Hierarquias profundas de classes causam problemas: • As subclasses herdam ALL o estado e o comportamento da superclasse • Alterar uma superclasse pode quebrar as subclasses • Não é possível herdar de duas classes Os protocolos resolvem os três problemas.

Comece com um protocolo

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` As extensões de protocolo fornecem implementações padrão que qualquer tipo em conformidade recebe gratuitamente.

Compondo comportamentos

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` Combine comportamentos como peças de LEGO — não é necessária uma hierarquia de classes.

Extensões de protocolo para lógica compartilhada

```swift extension Loggable { func log(_ msg: String) { print("[\(type(of: self))] \(msg)") } } // Every Loggable type gets this for free ```

Modelagem retroativa

Os protocolos podem ser aplicados a tipos que não pertencem ao seu código: ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` Adicione conformidades a tipos da biblioteca padrão sem usar herança.

Tipos de valor + protocolos

Estruturas em conformidade com protocolos oferecem semântica de valor *e* polimorfismo: ```swift protocol Shape { var area: Double { get } } struct Circle: Shape { var radius: Double; var area: Double { .pi * radius * radius } } struct Square: Shape { var side: Double; var area: Double { side * side } } let shapes: [any Shape] = [Circle(radius:3), Square(side:4)] shapes.map { $0.area } // [28.27, 16] ```

Injeção de dependência por meio de um protocolo

```swift protocol DataStore { func save(_ data: Data) } struct FileStore: DataStore { func save(_ d: Data) { /* disk */ } } struct MockStore: DataStore { func save(_ d: Data) { /* test log */ } } class Service { let store: DataStore init(store: DataStore) { self.store = store } } ```

Quando usar classes

Dê preferência às classes quando: • For necessário um estado mutável compartilhado (semântica de referência) • Houver integração com APIs ObjC/UIKit • A herança for o modelo correto (o que é raro) Como padrão, use protocolos + estruturas para todo o resto.

Convenções de nomenclatura de protocolos

• Protocolos de capacidade: sufixos `-able`, `-ible`, `-ing` (Equatable, Hashable, Coding) • Protocolos de delegado: sufixo `Delegate` ou `DataSource` • Papel abstrato: substantivo (`Store`, `Parser`, `Renderer`) Bons nomes tornam o código orientado a protocolos autodocumentado.

Verificação rápida

O que as extensões de protocolo fornecem aos tipos em conformidade?

Recapitulação

Principais conclusões: • Prefira protocolos + estruturas a hierarquias de classes • As extensões de protocolo fornecem implementações padrão compartilhadas • Componha comportamentos a partir de protocolos pequenos e com uma única finalidade • Os protocolos permitem injeção de dependência para facilitar os testes • Reserve as classes para semântica de referência e interoperabilidade com ObjC Curso concluído! Próximo: Tipos de valor vs. tipos de referência em profundidade.

Perguntas Frequentes

A aula “Princípios de design orientado a protocolos” é grátis?

Sim — o texto completo de “Princípios de design orientado a protocolos” é 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 “Princípios de design orientado a protocolos”?

Prefira a composição de protocolos à herança de classes para obter um design flexível. 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 4 de 4.

Quanto tempo leva a aula “Princípios de design orientado a protocolos”?

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

Composição de protocolos com &
Conformidade condicional
Requisitos de Self e design com Equatable
Princípios de design orientado a protocolos

← Voltar para Swift Academy