Swift Academy · Aula

override, final e prevenção de subclasses

Substitua métodos e propriedades e impeça a criação de subclasses com final.

Aula 2 de 412 etapas

override, final e prevenção de subclasses é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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 palavra-chave `override` permite que as subclasses substituam as implementações da superclasse. `final` impede novas substituições ou a criação de subclasses, protegendo o contrato da sua API.

Métodos substituídos

```swift class Animal { func speak() { print("...") } } class Cat: Animal { override func speak() { print("Meow") } } Cat().speak() // "Meow" ``` `override` é obrigatório — o compilador rejeita ocultações acidentais.

Propriedades substituídas

```swift class Shape { var area: Double { 0 } } class Square: Shape { var side: Double init(_ s: Double) { side = s } override var area: Double { side * side } } print(Square(4).area) // 16 ```

Chamando a superclasse em uma substituição

```swift class Logger { func log(_ msg: String) { print("[LOG] \(msg)") } } class TimedLogger: Logger { override func log(_ msg: String) { print(Date(), terminator: " ") super.log(msg) } } ```

Métodos e propriedades finais

Marque um método ou uma propriedade como `final` para impedir substituições: ```swift class BankAccount { final func transfer(amount: Double) { ... } // cannot override var balance: Double = 0 } ```

Classes finais

Marque uma classe inteira como `final` para impedir a criação de subclasses: ```swift final class Singleton { static let shared = Singleton() private init() {} } // class Sub: Singleton { } ❌ ``` `final` também permite otimizações — o compilador pode despachar as chamadas estaticamente.

Por que usar final?

Benefícios de `final`: 1. Desempenho: despacho estático em vez de consulta à tabela virtual 2. Segurança: contrato da API garantido — as subclasses não podem quebrar suas invariantes 3. Documentação: indica que a classe não foi projetada para herança

Substituição de propriedades calculadas

```swift class Vehicle { var description: String { "Vehicle" } } class Tesla: Vehicle { override var description: String { "Tesla - " + super.description } } print(Tesla().description) // "Tesla - Vehicle" ```

Substituição de observadores de propriedades

```swift class A { var x = 0 } class B: A { override var x: Int { didSet { print("B.x changed to \(x)") } } } var b = B() b.x = 5 // "B.x changed to 5" ```

Prevenção de substituições acidentais

Sem `override`, a ocultação acidental gera um erro de compilação: ```swift class Parent { func greet() { } } class Child: Parent { func greet() { } // ❌ must write 'override' } ``` Isso protege contra erros silenciosos quando as APIs da classe pai evoluem.

Verificação rápida

Qual palavra-chave impede que uma classe seja usada como superclasse?

Responda na aula interativa

Recapitulação

Principais conclusões: • `override` é obrigatório ao substituir um método ou uma propriedade da superclasse • `super.method()` chama a versão da superclasse • `final func/var` — impede a substituição desse membro específico • `final class` — impede qualquer criação de subclasse • `final` permite o despacho estático — um ganho de desempenho sem custo adicional Próximo: conversão de tipos com is, as?, as!

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “override, final e prevenção de subclasses” é grátis?

Sim — o texto completo de “override, final e prevenção de subclasses” é 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 “override, final e prevenção de subclasses”?

Substitua métodos e propriedades e impeça a criação de subclasses com final. 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 2 de 4.

Quanto tempo leva a aula “override, final e prevenção de subclasses”?

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

Herança de classes e a palavra-chave super
override, final e prevenção de subclasses
Conversão de tipos: is, as?, as! e as
Desinicializadores e ciclo de vida da memória

← Voltar para Swift Academy