1º SRP (Single Responsibility Principle)

O Princípio da Responsabilidade Única, é um dos cinco princípios do SOLID, um conjunto de diretrizes que visam melhorar a qualidade e a manutenibilidade do código em programação orientada a objetos. O SRP estabelece que uma classe deve ter uma única responsabilidade e motivo para mudar. Em outras palavras, uma classe deve ter apenas uma razão para ser alterada.

Um exemplo que viola o SRP em Swift seria o seguinte:

class User {
    var name: String
    var email: String
    
    init(name: String, email: String) {
        self.name = name
        self.email = email
    }
    
    func saveToDatabase() {
        // Lógica para salvar o usuário no banco de dados
    }
    
    func sendEmail() {
        // Lógica para enviar um e-mail para o usuário
    }
}

Neste exemplo, a classe User está lidando com duas responsabilidades distintas: salvar o usuário no banco de dados e enviar e-mails. Isso viola o SRP, porque se houver mudanças nas regras de envio de e-mails, por exemplo, a classe User precisará ser modificada, mesmo que a mudança não esteja diretamente relacionada à sua representação e armazenamento.

Exemplo corrigido que não viola o SRP

class User {
    var name: String
    var email: String
    
    init(name: String, email: String) {
        self.name = name
        self.email = email
    }
}

class UserRepository {
    func saveUser(_ user: User) {
        // Lógica para salvar o usuário no banco de dados
    }
}

class EmailService {
    func sendEmail(to recipient: String, subject: String, body: String) {
        // Lógica para enviar um e-mail
    }
}

Neste exemplo, a classe User tem a única responsabilidade de representar um usuário. As responsabilidades de salvar o usuário no banco de dados e enviar e-mails foram movidas para as classes UserRepository e EmailService, respectivamente. Isso adere ao SRP, facilitando a manutenção e evitando que mudanças em uma área afetem indevidamente as outras.

2º OCP (Open-Closed Principle)

O Princípio Aberto-Fechado é outro princípio do SOLID e sugere que as entidades de software, como classes, módulos ou funções, devem ser abertas para extensão, mas fechadas para modificação**.** Isso significa que você deve ser capaz de adicionar novos comportamentos ou funcionalidades a um sistema sem modificar o código existente.

Um exemplo que viola o OCP em Swift seria o seguinte:

class Shape {
    var type: String
    
    init(type: String) {
        self.type = type
    }
    
    func area() -> Double {
        fatalError("Subclasses must implement this method")
    }
}

Neste exemplo, a classe Shape é uma classe base para várias formas geométricas. No entanto, se você quiser adicionar um novo tipo de forma, precisará modificar a classe Shape e criar uma nova implementação para o método area(), violando o OCP.

Exemplo corrigido que segue o OCP:

protocol Shape {
    func area() -> Double
}

class Circle: Shape {
    var radius: Double
    
    init(radius: Double) {
        self.radius = radius
    }
    
    func area() -> Double {
        return Double.pi * radius * radius
    }
}

class Rectangle: Shape {
    var width: Double
    var height: Double
    
    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
    
    func area() -> Double {
        return width * height
    }
}