O que é programação orientada a objetos (POO)?

Quais os benefícios disso tudo? Separei alguns superpoderes que a POO traz para seu código:

• Organização e legibilidade: código dividido em classes e objetos é mais intuitivo. Cada classe cuida de um assunto, facilitando encontrar e entender funcionalidades.

• Reutilização de código: você pode reutilizar classes em diferentes partes do projeto (ou até em projetos futuros), em vez de copiar e colar código. Além disso, através da herança (veremos já já), uma classe pode herdar características de outra, evitando retrabalho.

• Facilidade de manutenção: ficou mais fácil adicionar novas funcionalidades ou corrigir bugs. Como os objetos são independentes, você altera uma classe sem quebrar o resto do app (quando tudo está bem estruturado).

• Abstração: você modela apenas os detalhes relevantes de cada objeto para o problema que está resolvendo, escondendo complexidades desnecessárias. Isso deixa o código mais simples de usar e focado no que importa.

• Encapsulamento: os objetos protegem seus dados internos, permitindo acesso somente por métodos controlados. Assim você evita que qualquer parte do programa saia modificando dados de qualquer jeito – quem manda nos dados de um objeto é ele mesmo!

• Polimorfismo: possibilidade de tratar objetos de classes diferentes de forma uniforme, se elas compartilham a mesma superclasse ou protocolo. Isso dá flexibilidade pro código, como ter uma função que aceita "qualquer coisa que seja Pessoa", podendo passar tanto um Aluno quanto um Mentor (já já vamos ver na prática).

Pilares da POO

Classes e objetos no Swift

class PessoaRocketseat {
    var nome: String
    var trilha: String

    // Construtor (inicializador) da classe
    init(nome: String, trilha: String) {
        self.nome = nome
        self.trilha = trilha
    }

    func seApresentar() {
        print("Fala, dev! Eu sou \(nome) e faço parte da trilha \(trilha).")
    }
}

// Criando objetos (instâncias) da classe PessoaRocketseat
let rodrigo = PessoaRocketseat(nome: "Rodrigo", trilha: "iOS")
let isabela = PessoaRocketseat(nome: "Isabela", trilha: "iOS")

rodrigo.seApresentar()  // Output: Fala, dev! Eu sou Rodrigo e faço parte da trilha iOS.
isabela.seApresentar()  // Output: Fala, dev! Eu sou Isabela e faço parte da trilha iOS.

Encapsulamento em Swift

class Aluno {
    var nome: String
    private var nivelDeConhecimento: Int = 0  // encapsulado: começa em 0, ninguém de fora pode alterar diretamente

    init(nome: String) {
        self.nome = nome
    }

    func estudar() {
        // Toda vez que o aluno estuda, incrementa seu conhecimento
        nivelDeConhecimento += 1
        print("\(nome) está estudando Swift. Conhecimento atual: \(nivelDeConhecimento).")
    }

    func exibirConhecimento() {
        print("Conhecimento de \(nome): \(nivelDeConhecimento).")
    }
}

let fernanda = Aluno(nome: "Fernanda")
fernanda.estudar()        // Fernanda está estudando Swift. Conhecimento atual: 1.
fernanda.estudar()        // Fernanda está estudando Swift. Conhecimento atual: 2.
fernanda.exibirConhecimento()  // Conhecimento de Fernanda: 2.
// fernanda.nivelDeConhecimento = 100  // Isto daria erro, pois nivelDeConhecimento é private

Herança em Swift

class Pessoa {
    var nome: String

    init(nome: String) {
        self.nome = nome
    }

    func seApresentar() {
        print("Olá, meu nome é \(nome).")
    }
}

// Herança: Mentor e Aluno herdam de Pessoa
class Mentor: Pessoa {
    var trilha: String

    init(nome: String, trilha: String) {
        self.trilha = trilha
        super.init(nome: nome)  // chama o init da superclasse Pessoa
    }

    override func seApresentar() {
        print("Olá, eu sou \(nome), mentor da trilha \(trilha).")
    }

    func orientar() {
        print("\(nome) está orientando a galera da trilha \(trilha).")
    }
}

class AlunoRocket: Pessoa {  // usei AlunoRocket para não confundir com a classe Aluno anterior
    var trilha: String

    init(nome: String, trilha: String) {
        self.trilha = trilha
        super.init(nome: nome)
    }

    override func seApresentar() {
        print("Olá, eu sou \(nome), aluno(a) da trilha \(trilha).")
    }
}

let diego = Mentor(nome: "Diego", trilha: "iOS")
let mayk = Mentor(nome: "Mayk", trilha: "Web")
let joao = AlunoRocket(nome: "João", trilha: "iOS")

diego.seApresentar()  // Olá, eu sou Diego, mentor da trilha iOS.
joao.seApresentar()   // Olá, eu sou João, aluno(a) da trilha iOS.
diego.orientar()      // Diego está orientando a galera da trilha iOS.

Polimorfismo em Swift

// Array de Pessoa contendo tanto Mentor quanto AlunoRocket
let equipe: [Pessoa] = [diego, mayk, joao]

print("Apresentação de toda a equipe:")
for pessoa in equipe {
    pessoa.seApresentar()  // Cada objeto usa sua própria versão de seApresentar()
}
// Output:
// Olá, eu sou Diego, mentor da trilha iOS.
// Olá, eu sou Mayk, mentor da trilha Web.
// Olá, eu sou João, aluno(a) da trilha iOS.

• Definimos classes e criamos objetos para organizar o código.

• Usamos encapsulamento para proteger dados internos.

• Aplicamos herança para reutilizar código e especializar comportamentos.

• Aproveitamos o polimorfismo para tratar objetos de forma genérica, mantendo diferenças internas quando necessário.

Importância da POO para desenvolvimento iOS

Conclusão