No desenvolvimento de software, os padrões de design são uma solução comprovada que ajuda os desenvolvedores a organizar e escrever códigos melhor. Os padrões de design podem não apenas melhorar a legibilidade e a manutenção do código, mas também acelerar o processo de desenvolvimento de software.
Este artigo apresentará 23 padrões de design comuns e sete princípios de padrão de design e fornecerá explicações detalhadas e demonstrações de código de exemplo para cada padrão.
23 padrões de design
padrões de criação
Os padrões de criação concentram-se no processo de criação de objetos, incluindo padrões de fábrica simples, padrões de método de fábrica, padrões de fábrica abstratos, padrões de singleton, padrões de construtor e padrões de protótipo.
- Padrão Simples de Fábrica
O padrão de fábrica simples cria objetos por meio de uma classe de fábrica, oculta os detalhes da criação do objeto e fornece uma interface unificada, para que o cliente não precise conhecer a implementação específica.
public class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Invalid product type: " + type);
}
}
}
- padrão de método de fábrica
O padrão de método de fábrica adia a criação de objetos para as subclasses, desacoplando ao permitir que as subclasses decidam como criar objetos.
public abstract class Creator {
public abstract Product createProduct();
}
public class ConcreteCreatorA extends Creator {
public Product createProduct() {
return new ConcreteProductA();
}
}
public class ConcreteCreatorB extends Creator {
public Product createProduct() {
return new ConcreteProductB();
}
}
- padrão de fábrica abstrato
O padrão fábrica abstrata fornece uma interface para criar uma série de produtos relacionados sem especificar uma classe de implementação específica. Ele estende o padrão do método de fábrica para várias famílias de produtos.
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA1();
}
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
public ProductA createProductA() {
return new ConcreteProductA2();
}
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
- padrão singleton
O padrão singleton garante que haja apenas uma instância de uma classe e fornece um ponto de acesso global para que outros objetos possam acessar a instância.
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
- modo construtor
O padrão do construtor divide o processo de criação de um objeto complexo em várias etapas simples, e diferentes construtores podem usar essas etapas para construir diferentes objetos.
public class Product {
private String part1;
private String part2;
public void setPart1(String part1) {
this.part1 = part1;
}
public void setPart2(String part2) {
this.part2 = part2;
}
}
public abstract class AbstractBuilder {
protected Product product = new Product();
public abstract void buildPart1();
public abstract void buildPart2();
public Product getResult() {
return product;
}
}
public class ConcreteBuilder extends AbstractBuilder {
public void buildPart1() {
product.setPart1("Part 1");
}
public void buildPart2() {
product.setPart2("Part 2");
}
}
public class Director {
private AbstractBuilder builder;
public Director(AbstractBuilder builder) {
this.builder = builder;
}
public void buildProduct() {
builder.buildPart1();
builder.buildPart2();
}
}
- padrão de protótipo
O modo protótipo cria novos objetos especificando um objeto protótipo, e novos objetos podem ser criados por clonagem.
public abstract class Prototype implements Cloneable {
public abstract Prototype clone();
}
public class ConcretePrototypeA extends Prototype {
public Prototype clone() {
try {
return (Prototype) super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
}
public class Client {
private Prototype prototype;
public Client(public Prototype prototype) {
this.prototype = prototype;
}
public Prototype createPrototype() {
return prototype.clone();
}
}
padrão estrutural
Os padrões estruturais se concentram em como os objetos são combinados, incluindo padrões de adaptador, padrões de ponte, padrões de composição, padrões de decorador, padrões de aparência, padrões flyweight e padrões proxy.
- padrão de adaptador
O padrão adaptador converte a interface de uma classe em outra interface esperada pelos clientes. Ele implementa a conversão de interface encapsulando uma classe existente.
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
}
}
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specificRequest();
}
}
- Modo Ponte
O padrão de ponte separa a abstração da implementação para que possam variar independentemente. Ele faz isso delegando detalhes de implementação para outra classe.
public abstract class Abstraction {
protected Implementor implementor;
public Abstraction(Implementor implementor) {
this.implementor = implementor;
}
public abstract void operation();
}
public interface Implementor {
void operationImpl();
}
public class ConcreteImplementorA implements Implementor {
public void operationImpl() {
}
}
public class RefinedAbstraction extends Abstraction {
public RefinedAbstraction(Implementor implementor) {
super(implementor);
}
public void operation() {
implementor.operationImpl();
}
}
- modo de combinação
O padrão Composite organiza um conjunto de objetos em uma estrutura de árvore para representar uma hierarquia "parte-todo". Ele permite que os clientes trabalhem uniformemente com objetos únicos e compostos.
public abstract class Component {
protected String name;
public Component(String name) {
this.name = name;
}
public abstract void add(Component component);
public abstract void remove(Component component);
public abstract void display(int depth);
}
public class Leaf extends Component {
public Leaf(String name) {
super(name);
}
public void add(Component component) {
}
public void remove(Component component) {
}
public void display(int depth) {
System.out.println("-".repeat(depth) + name);
}
}
public class Composite extends Component {
private List<Component> children = new ArrayList<>();
public Composite(String name) {
super(name);
}
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
public void display(int depth) {
System.out.println("-".repeat(depth) + name);
for (Component component : children) {
component.display(depth + 1);
}
}
}
- padrão decorador
O padrão decorador pode estender sua funcionalidade envolvendo um objeto decorador sem alterar o objeto original.
public abstract class Component {
public abstract void operation();
}
public class ConcreteComponent extends Component {
public void operation() {
}
}
public abstract class Decorator extends Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
}
}
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void operation() {
super.operation();
// Add extra behavior
}
}
- modo de aparência
O padrão de fachada fornece uma interface simples que oculta a complexa estrutura interna de um conjunto de subsistemas. Ele separa dependências entre clientes e subsistemas.
public class Subsystem1 {
public void operation1() {
}
}
public class Subsystem2 {
public void operation2() {
}
}
public class Facade {
private Subsystem1 subsystem1;
private Subsystem2 subsystem2;
public Facade() {
subsystem1 = new Subsystem1();
subsystem2 = new Subsystem2();
}
public void operation() {
subsystem1.operation1();
subsystem2.operation2();
}
}
- Modo Flyweight
O modo Flyweight reduz o número de objetos na memória compartilhando objetos, melhorando assim o desempenho do sistema. Ele divide os objetos em estado interno e estado externo, o estado interno pode ser compartilhado e o estado externo deve ser passado pelo cliente.
public interface Flyweight {
void operation(String extrinsicState);
}
public class ConcreteFlyweight implements Flyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
public void operation(String extrinsicState) {
}
}
public class FlyweightFactory {
private Map<String, Flyweight> flyweights = new HashMap<>();
public Flyweight getFlyweight(String key) {
if (!flyweights.containsKey(key)) {
flyweights.put(key, new ConcreteFlyweight(key));
}
return flyweights.get(key);
}
}
- Modo proxy
O modo proxy introduz um objeto proxy ao acessar um objeto para controlar o acesso ao objeto original. Ele pode ocultar os detalhes de implementação do objeto e fornecer uma maneira de acessar o objeto com segurança.
public interface Subject {
void request();
}
public class RealSubject implements Subject {
public void request() {
}
}
public class Proxy implements Subject {
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void request() {
// Access control and additional behavior
realSubject.request();
// Additional behavior
}
}
Sete princípios de padrão de design
- Princípio de Responsabilidade Única (SRP)
Uma classe deve ter apenas um motivo para alterá-la.
- Princípio Aberto Fechado (OCP)
As entidades de software devem estar abertas para extensão e fechadas para modificação.
- Princípio da Substituição de Liskov (LSP)
Um subtipo deve ser capaz de substituir completamente seu supertipo.
- Princípio de Segregação de Interface (ISP)
Um cliente não deve depender de interfaces de que não precisa.
- Princípio de Inversão de Dependência (DIP)
Módulos de alto nível não devem depender de módulos de baixo nível, eles devem depender de interfaces abstratas. As interfaces abstratas não devem depender de implementações concretas, e as implementações concretas devem depender de interfaces abstratas.
- Lei de Deméter (LoD)
Um objeto deve ter conhecimento mínimo sobre outros objetos.
- Princípio de Reutilização de Combinação/Agregação (CARP)
Ao combinar um grupo de objetos em um novo objeto, você deve usar combinação/agregação em vez de herança para atingir o propósito de reutilização.
Resumir
Padrões de projeto e princípios de projeto são conceitos muito importantes no desenvolvimento de software, eles podem nos ajudar a entender e projetar melhor os sistemas de software. Este artigo apresenta 23 padrões de design comuns e sete princípios de padrão de design e fornece demonstrações de código de amostra detalhadas. Espero que os leitores possam dominar esse conhecimento por meio deste artigo e aplicá-lo no desenvolvimento real.