Menu

Padrões de projeto em Java: Singleton, Factory e Builder

design patterns java

Experimente Nosso Instrumento Para Eliminar Problemas

Neste tutorial, discutiremos Design Patterns em Java. Vamos estudar os padrões Singleton, Factory e Builder com exemplos e vantagens:

Quando resolvemos um problema específico, podemos resolvê-lo de forma mais eficiente se tivermos algumas das melhores práticas já definidas. Isso realmente nos ajudará a seguir essas melhores práticas e desenvolver soluções mais confiáveis.

Esses Melhores Práticas que pode ser usado para desenvolver soluções comprovadas para resolver problemas são chamados de “ Padrões de design ”. Desenvolvedores de software OOP experientes usam padrões de design para resolver tarefas específicas.

=> Dê uma olhada no guia para iniciantes em Java aqui

Padrões de design em Java

O que você aprenderá:

Padrões de design em Java

Os padrões de design foram inventados por Christopher Alexander em 1977. Mais tarde, porém, quatro desenvolvedores, nomeadamente Erich Gamma, Richard Helm, John Vlissides e Ralph Johnson escreveram um livro intitulado “ Padrões da Gang of Four-Design, elementos de software orientado a objetos reutilizáveis ”No ano de 1995.

A partir de então, todos os padrões de design passaram a ser conhecidos como “ Gang of Four Design Patterns ”.

o que é teste beta em teste de software

Os padrões de projeto são independentes de quaisquer linguagens de programação, pois são usados ​​para resolver problemas comuns de projeto orientado a objetos e não estão limitados apenas a uma linguagem de programação específica. Então, basicamente, é uma ideia e não uma implementação.

Assim, usando padrões de projeto, podemos desenvolver programas que são mais eficientes, flexíveis, de fácil manutenção e reutilizáveis.

Vantagens dos padrões de design

Listadas abaixo estão algumas das vantagens do uso de padrões de design em nossos aplicativos:

  • Os padrões de design são reutilizáveis ​​e podem ser usados ​​por vários projetos.
  • Podemos definir a arquitetura do sistema usando padrões de projeto.
  • Os padrões de design fornecem transparência ao design do aplicativo.
  • Os padrões de design já estão bem testados e comprovados para que possamos usá-los sem preocupações.
  • Os padrões de projeto nos permitem construir sistemas melhores e também fornecem clareza na arquitetura do sistema.

Quando usar padrões de projeto

Então, quando devemos usar exatamente os padrões de projeto?

Normalmente usamos um padrão de design durante a análise inicial e a fase de requisitos do SDLC (Ciclo de Vida de Desenvolvimento de Software). Quando usado durante a fase de análise e requisitos do SDLC, ele fornece mais informações para esta fase. Java suporta internamente padrões de design.

Os padrões de design em Java são categorizados da seguinte maneira:

Padrões de design em Java

No que diz respeito a este tutorial, estamos interessados ​​apenas em padrões de design criacionais.

Os padrões de design de criação são ainda classificados da seguinte forma:

Padrões de design criativo

Neste tutorial, discutiremos os seguintes padrões de design:

  • Padrão de design singleton
  • Padrão de design de fábrica
  • Builder design pattern

Vamos começar com um padrão de design singleton em Java.

Leitura recomendada = >> Padrões de design para aplicativos baseados em Flask

Padrão Singleton em Java

Um padrão singleton é um tipo de padrão de criação em Java. O padrão Singleton é um padrão de design no qual apenas uma instância de uma classe está presente na máquina virtual Java. Uma classe singleton (implementando o padrão singleton) deve fornecer um ponto de acesso global para obter a instância da classe.

Em outras palavras, um padrão singleton restringe a instanciação de uma classe. O padrão Singleton é usado na implementação do logger para aplicativos. Ele também é usado na implementação de pool de threads ou cache.

As classes Java, java.awt.Desktop e java.lang.runtime também usa um padrão singleton.

Vantagens

  • Como apenas uma instância da classe singleton é usada, economizamos memória.
  • Além disso, garante a reutilização, já que o mesmo objeto singleton é usado repetidamente.

Agora vamos passar para a implementação do padrão singleton.

Implementação do padrão Singleton

Como já mencionado, um padrão de design singleton restringe a classe com apenas uma instância e essa instância recebe um ponto de acesso global. Essas eram todas as classes que se referiam ao mesmo objeto repetidamente.

O diagrama UML a seguir explica o padrão Singleton.

Implementação do padrão singleton

Como mostra o diagrama UML acima, uma classe singleton tem uma única instância definida e nós a acessamos pelo método getInstance (). Portanto, uma fábrica de singleton que é responsável por criar objetos faz uso do método getInstance para retornar o mesmo objeto (que está lá na classe) repetidamente.

Então, como implementamos o padrão Singleton em um programa?

Criamos uma classe singleton e temos seu construtor como “privado” para que a classe não possa ser instanciada. Em seguida, criamos uma instância privada dessa classe singleton dentro da própria classe. Então, temos um método público especial getInstance () que retorna um objeto singleton para o mundo externo.

Esta implementação desta classe singleton, conforme explicado acima, é mostrada no programa Java abaixo.

class SingletonObject { //create an object of SingletonObject private static SingletonObject instance = new SingletonObject(); //private constructor so that we cannot instantiate the class private SingletonObject(){} //returns the only available object public static SingletonObject getInstance(){ return instance; } public void printMessage(){ System.out.println('Hello from Singleton object!!!'); } } public class Main { public static void main(String() args) { //illegal statement because constructor is private //Compile Time Error: The constructor SingletonObject() is not visible //SingletonObject object = new SingletonObject(); //call getInstance to retrieve the object available from the class SingletonObject object = SingletonObject.getInstance(); //show the message object.printMessage(); } }

Resultado:

Implementação de padrão singleton em um programa

Agora, se verificarmos o método principal, observe que se tentarmos criar um objeto da classe singleton usando um novo operador, o compilador dará um erro de compilação (veja o código comentado no método principal). Obtemos o objeto da classe singleton usando o método getInstance () e então podemos usá-lo normalmente para acessar os métodos.

Padrão de fábrica em Java

O padrão de fábrica também é chamado de “Padrão de método de fábrica” ou “Construtor virtual” em Java. Nesse padrão, criamos uma interface ou uma classe abstrata com declarações de método e, em seguida, as classes ou subclasses concretas que implementam essa interface ou herdam a classe são responsáveis ​​por criar instâncias da classe.

Vantagens

  • O padrão de fábrica é um tipo de padrão de criação e é o padrão mais comumente usado em Java.
  • Ao usar um padrão de fábrica, garantimos que a lógica de criação real não seja exposta ao mundo exterior.

Portanto, se uma classe que implementa um padrão de fábrica possui um método para calcular a taxa de juros, as classes concretas irão implementar essa classe e também implementar o método para calcular a taxa de juros.

Então haverá outra classe que é uma classe de fábrica que acessará essas instâncias de classe concretas de forma que não tenhamos conhecimento de como a lógica para calcular a taxa de juros é implementada. Apenas chamamos o método e obtemos a saída.

Então, quando exatamente podemos usar o padrão Factory Method?

Quando as classes pai decidem delegar a criação de instâncias para suas subclasses, então podemos ir para um padrão de fábrica (isso é explicado acima). Também podemos usar o método de fábrica quando a classe não sabe quais subclasses devem ser criadas.

Agora vamos ver a implementação do padrão de método de fábrica.

Implementação do padrão de fábrica

Como exemplo, vamos implementar uma interface de forma genérica. Podemos derivar várias classes concretas dessa interface, como círculo, retângulo, etc. Então, teremos uma classe shapeFactory que acessará os objetos da classe concreta. A UML para este padrão é mostrada abaixo.

Implementos de Padrão de Fábrica

Como já explicado, este é o diagrama UML para o padrão de fábrica. Agora vamos implementar um programa Java demonstrando o padrão de fábrica.

//Geometric_shape interface interface Geometric_shape { void draw_shape(); } //Geometric shape classes implementing Geometric_shape interface class Rectangle implements Geometric_shape { @Override public void draw_shape() { System.out.println('Rectangle class::draw_shape() method.'); } } class Square implements Geometric_shape { @Override public void draw_shape() { System.out.println('Square class::draw_shape() method.'); } } class Circle implements Geometric_shape { @Override public void draw_shape() { System.out.println('Circle class::draw_shape() method.'); } } //Factory class for Geometric_shape class ShapeFactory { //shapeObject method gets particular shapeType (circle, Square or Rectangle) public Geometric_shape shapeObject(String shapeType){ if(shapeType == null){ return null; } //retrieve Circle object if(shapeType.equalsIgnoreCase('Circle')){ return new Circle(); //retrieve Rectangle object } else if(shapeType.equalsIgnoreCase('Rectangle')){ return new Rectangle(); ////retrieve Square object } else if(shapeType.equalsIgnoreCase('Square')){ return new Square(); } return null; } } public class Main { public static void main(String() args) { //Create a ShapeFactory object to get different geometric shapes ShapeFactory shapeFactory = new ShapeFactory(); //circle Geometric_shape shape_Circle = shapeFactory.shapeObject('CIRCLE'); //draw method of Circle shape_Circle.draw_shape(); //Rectangle Geometric_shape shape_Rectangle = shapeFactory.shapeObject('RECTANGLE'); //draw method of Rectangle shape_Rectangle.draw_shape(); //Square Geometric_shape shape_Square = shapeFactory.shapeObject('SQUARE'); //draw method of square shape_Square.draw_shape(); } }

Resultado:

Padrão de fábrica - saída

Padrão Builder em Java

No padrão Builder, usamos uma abordagem passo a passo para construir um objeto complexo usando objetos pequenos e simples.

Portanto, sempre que encontramos um objeto que não pode ser criado em uma única etapa, optamos por um padrão construtor.

Vantagens

  • Usando o padrão Builder, podemos separar a construção e a representação de um objeto.
  • Também podemos alterar a representação interna do objeto.
  • Podemos construir projetos complexos como um sistema de entrega inteiro usando o padrão do construtor.

Um exemplo prático de um padrão Builder é o sistema de pedido de alimentos, que envolve etapas complexas de coleta de itens de alimentos que são pedidos, embalagem, faturamento, construção de pedido e remessa.

Neste tutorial, implementaremos um exemplo de sistema de pedido de tablet usando o padrão Builder.

Implementação do padrão Builder

O diagrama UML geral para o padrão Builder é fornecido abaixo.

Implementação do padrão Builder

O diagrama acima mostra o diagrama UML do padrão Builder. Conforme mostrado no diagrama acima, temos quatro componentes no padrão Builder.

  • Produtos: Isso representa o objeto complexo a ser construído.
  • Classe Builder Abstract: Uma classe abstrata contendo protótipos de todas as funcionalidades necessárias para construir um objeto complexo.
  • Classe ConcreteBuilder: Esta é uma classe concreta que herda da classe Builder e cria um objeto complexo específico. Podemos ter quantas classes ConcreteBuilder forem necessárias.
  • Classe de diretor: Esta classe controla os algoritmos que geram o produto final.

O exemplo de programação a seguir mostra a demonstração de um padrão Builder usando um sistema de construção de pedido de tablet.

import java.util.ArrayList; import java.util.List; //Packing interface for tablets interface Packing { public String pack(); public int price(); } //Tablet class - abstract abstract class Tablet implements Packing{ public abstract String pack(); } //company - extends Tablet abstract class Company extends Tablet{ public abstract int price(); } //Lenovo tablet class Lenovo extends Company{ @Override public int price(){ return 541; } @Override public String pack(){ return 'Lenovo Yoga'; } } //Micromax tablet class MicroMax extends Company { @Override public int price(){ return 338; } @Override public String pack(){ return 'MicroMax'; } } //Tablet type class TabType { private List items=new ArrayList(); //add items public void addItem(Packing packs) { items.add(packs); } //retrieve cost public void getCost(){ for (Packing packs : items) { packs.price(); } } //show all items public void showItems(){ for (Packing packing : items){ System.out.print('Tablet name : '+packing.pack()); System.out.println(', Price(in U.S.Dollars) : '+packing.price()); } } } //builder class for tablets order class TabBuilder { public TabType buildLenovoTab(){ TabType lenovo =new TabType(); lenovo.addItem(new Lenovo()); return lenovo; } public TabType buildMicroMaxTab(){ TabType mmx=new TabType(); mmx.addItem(new MicroMax()); return mmx; } } public class Main{ public static void main(String args()){ //build the tablets order and display the order TabBuilder tabBuilder=new TabBuilder(); TabType tabtype1=tabBuilder.buildLenovoTab(); tabtype1.showItems(); TabType tabtype2=tabBuilder.buildMicroMaxTab(); tabtype2.showItems(); } }

Resultado:

Padrão de construção - saída

No exemplo acima, construímos o sistema completo de pedido de tablets para duas marcas de tablets, ou seja, Lenovo e Micromax. Essas são as classes concreteBuilder que herdam da empresa de classe abstrata. Então temos uma classe TabBuilder que cria os pedidos para ambas as classes de tablet.

perguntas frequentes

P # 1) O que são Design Patterns em Java? Quais são os tipos de padrões de design em Java?

site para assistir anime online gratuitamente

Responda: Os padrões de design são as melhores práticas que podem ser usadas para desenvolver soluções bem testadas.

Java tem três tipos de padrões de design:

  • Padrão de design criativo: Padrão de fábrica, padrão Abstract Factory, padrão Singleton, padrão Builder e padrão de protótipo são exemplos de padrões de design criacionais. Eles estão principalmente envolvidos com a criação de objetos.
  • Padrão de projeto estrutural: Eles são usados ​​principalmente para criar uma estrutura de classe. Adaptador, ponte e padrão composto são padrões de projeto estruturais populares.
  • Padrão de design comportamental: Eles fornecem melhor interação entre os objetos, juntamente com a flexibilidade para estender facilmente a implementação. Padrões de observador, padrão de estratégia, etc. são alguns exemplos dos padrões de comportamento.

P # 2) Por que os Design Patterns são usados?

Responda: Os padrões de projeto nos fornecem um modelo de solução comprovado e testado que podemos usar para resolver problemas complexos. Os padrões de projeto nos permitem construir módulos coesos com acoplamento fraco. Os padrões de design também tornam a interação entre os designers mais eficiente e eficaz.

Q # 3) Quais são os exemplos de padrões?

Responda: Exemplos de padrões naturais são regularidades visíveis encontradas na natureza. Padrões naturais como simetrias, árvores, ondas, espumas, listras, rachaduras, etc. são alguns exemplos de padrões naturais.

P # 4) MVC é um padrão de projeto?

Responda: Sim, é um tipo de padrão de design com o qual podemos construir um aplicativo que consiste no modelo de dados, apresentação ou camada de visualização e controlador. Podemos classificá-lo mais como um padrão arquitetônico.

Conclusão

Isso conclui nossa discussão sobre padrões de design em Java. Embora o Java suporte três tipos de viz de padrões de projeto. Padrões criacionais, estruturais e comportamentais, estamos mais interessados ​​no padrão de design criacional.

De acordo com o escopo deste tutorial, discutimos três exemplos de padrões de design criacionais, a saber, padrão singleton, padrão de fábrica e padrão de construtor.

O padrão singleton é o padrão de projeto mais simples e o método de fábrica deve ser um padrão de projeto comum amplamente utilizado. O padrão do construtor é usado para construir objetos complexos e é usado principalmente no desenvolvimento de aplicativos complexos.

=> Confira o guia de treinamento Java perfeito aqui.

Leitura recomendada

^