Visão geral dos princípios SOLID
Conheça os cinco princípios SOLID: responsabilidade única, aberto/fechado, substituição de Liskov, segregação de interface e inversão de dependência.
Visão geral dos princípios SOLID é uma aula grátis de Clean Architecture & Design Patterns in Practice 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 Clean Architecture & Design Patterns in Practice, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Clean Architecture & Design Patterns in Practice inclui 4 aulas no total.
What are SOLID Principles?
Os princípios SOLID são cinco diretrizes de design para software que seja fácil de manter, entender e estender. Pense neles como um caminho para um código mais limpo.
Why SOLID Matters
Aplicar SOLID permite ter um código mais fácil de entender, mais simples de testar, mais flexível a mudanças e mais propício ao trabalho em equipe. É a base fundamental de um bom design OO.
S: Single Responsibility Principle (SRP)
O Princípio da Responsabilidade Única: uma classe deve ter uma única razão para mudar. Não misture calcular dados e salvá-los — separe essas responsabilidades.
SRP in Action: Simple Report
Este SimpleReport obedece ao SRP: sua única função é gerar o conteúdo do relatório. A impressão e o salvamento são responsabilidade de outra entidade.
public class SimpleReport {
private String content;
public SimpleReport(String content) {
this.content = content;
}
// This class's single responsibility is to generate/represent the report content
public String generateReportContent() {
return "Report: " + content;
}
public static void main(String[] args) {
SimpleReport report = new SimpleReport("Sales Data for Q1");
System.out.println(report.generateReportContent());
}
}O: Open/Closed Principle (OCP)
O Princípio Aberto/Fechado: o software deve ser aberto para extensão, mas fechado para modificação. Adicione novos comportamentos sem modificar o código existente.
OCP in Action: Flexible Greeters
Aqui, um novo tipo de *greeter* se encaixa sem tocar na interface Greeter ou nas classes existentes — estendendo o comportamento, não o modificando. Isso é o **OCP**.
interface Greeter {
String greet();
}
class EnglishGreeter implements Greeter {
@Override
public String greet() {
return "Hello!";
}
}
class SpanishGreeter implements Greeter {
@Override
public String greet() {
return "¡Hola!";
}
}
public class OCPDemo {
public static void main(String[] args) {
Greeter english = new EnglishGreeter();
Greeter spanish = new SpanishGreeter();
System.out.println(english.greet());
System.out.println(spanish.greet());
}
}L: Liskov Substitution Principle (LSP)
O Princípio da Substituição de Liskov: uma subclasse deve ser utilizável em qualquer lugar onde a sua classe base é esperada, sem quebrar o programa. Subtipos honram o contrato.
LSP in Action: Shapes
Qualquer função que recebe um Shape lida corretamente tanto com Rectangle quanto com Circle — elas respeitam o contrato. Isso é a LSP em ação.
interface Shape {
double getArea();
}
class Rectangle implements Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double getArea() {
return width * height;
}
}
class Circle implements Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
return Math.PI * radius * radius;
}
}
public class LSPDemo {
public static void printArea(Shape shape) {
System.out.println("Area: " + shape.getArea());
}
public static void main(String[] args) {
Shape myRectangle = new Rectangle(5, 4);
Shape myCircle = new Circle(3);
printArea(myRectangle);
printArea(myCircle);
}
}I: Interface Segregation Principle (ISP)
O **Princípio da Segregação de Interfaces**: não force os clientes a depender de métodos que eles não usam. Prefira muitas interfaces pequenas e focadas em vez de uma única interface 'gorda'.
D: Dependency Inversion Principle (DIP)
O Princípio da Inversão de Dependência: módulos de alto nível e de baixo nível devem depender de abstrações, e não de detalhes concretos. É assim que se obtém o acoplamento fraco.
Check Your Understanding
Quais das seguintes afirmações descrevem corretamente os benefícios de aplicar os princípios SOLID?
Recap: The Power of SOLID
Você conheceu todos os cinco princípios **SOLID** — responsabilidade única, aberto/fechado, Liskov, segregação de interfaces, inversão de dependência — o kit de ferramentas para software adaptável.
Perguntas Frequentes
A aula “Visão geral dos princípios SOLID” é grátis?
Sim — o texto completo de “Visão geral dos princípios SOLID” é 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 Clean Architecture & Design Patterns in Practice, atualize para CoddyKit PRO. O curso de Clean Architecture & Design Patterns in Practice inclui 4 aulas no total.
O que vou aprender em “Visão geral dos princípios SOLID”?
Conheça os cinco princípios SOLID: responsabilidade única, aberto/fechado, substituição de Liskov, segregação de interface e inversão de dependência. Você pratica Clean Architecture & Design Patterns in Practice 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 Clean Architecture & Design Patterns in Practice?
Nenhuma experiência prévia é necessária. Clean Architecture & Design Patterns in Practice 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 “Visão geral dos princípios SOLID”?
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 Clean Architecture & Design Patterns in Practice?
Sim. Cada aula de Clean Architecture & Design Patterns in Practice 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
- Introdução ao código limpo
- Visão geral dos princípios SOLID
- O valor de um bom design
- Coesão, acoplamento e separação de responsabilidades