Menu

Modelli di design in Java: Singleton, Factory e Builder

design patterns java

Prova Il Nostro Strumento Per Eliminare I Problemi

In questo tutorial discuteremo di Design Patterns in Java. Studieremo i pattern Singleton, Factory e Builder con esempi e vantaggi:

Quando risolviamo un problema specifico, possiamo risolverlo in modo più efficiente se disponiamo di alcune best practice già definite. Questo effettivamente ci aiuterà a seguire queste migliori pratiche e sviluppare soluzioni più affidabili.

Questi migliori pratiche che può essere utilizzato per sviluppare soluzioni ben collaudate per risolvere i problemi si chiamano ' Modelli di progettazione '. Gli sviluppatori di software OOP esperti utilizzano modelli di progettazione per risolvere compiti specifici.

=> Dai un'occhiata alla guida per principianti di Java qui

Modelli di design in Java

Cosa imparerai:

Modelli di design in Java

I modelli di design furono inventati per la prima volta da Christopher Alexander nel 1977. Ma più tardi quattro sviluppatori, ovvero Erich Gamma, Richard Helm, John Vlissides e Ralph Johnson, scrissero un libro intitolato ' Gang of Four-Design patterns, elementi di software riutilizzabile orientato agli oggetti 'Nell'anno 1995.

Da allora tutti i modelli di design divennero noti come ' Gang of Four Design Patterns '.

c ++ converte l'array di caratteri in int

I modelli di progettazione sono indipendenti da qualsiasi linguaggio di programmazione poiché vengono utilizzati per risolvere problemi di progettazione orientati agli oggetti comuni e non sono limitati solo a un linguaggio di programmazione specifico. Quindi fondamentalmente è un'idea e non un'implementazione.

Quindi, utilizzando modelli di progettazione, possiamo sviluppare programmi più efficienti, flessibili, gestibili e riutilizzabili.

Vantaggi dei modelli di design

Di seguito sono elencati alcuni dei vantaggi dell'utilizzo di modelli di progettazione nelle nostre applicazioni:

  • I modelli di progettazione sono riutilizzabili e possono essere utilizzati da più progetti.
  • Possiamo definire l'architettura del sistema utilizzando modelli di progettazione.
  • I modelli di progettazione forniscono trasparenza alla progettazione dell'applicazione.
  • I modelli di design sono già ben testati e provati in modo che possiamo usarli senza preoccupazioni.
  • I modelli di progettazione ci consentono di creare sistemi migliori e forniscono anche chiarezza sull'architettura del sistema.

Quando utilizzare i modelli di design

Quindi quando dovremmo usare esattamente i modelli di progettazione?

Di solito utilizziamo un modello di progettazione durante la fase iniziale di analisi e requisiti di SDLC (Software Development Life Cycle). Quando viene utilizzato durante la fase di analisi e requisiti di SDLC, fornisce ulteriori informazioni a questa fase. Java supporta internamente i modelli di progettazione.

I modelli di progettazione in Java sono classificati come segue:

Modelli di design in Java

Per quanto riguarda questo tutorial, siamo interessati solo ai modelli di design creazionali.

I modelli di design creativi sono ulteriormente classificati come segue:

Modelli di design creativi

In questo tutorial, discuteremo i seguenti modelli di progettazione:

  • Modello di design Singleton
  • Modello di progettazione di fabbrica
  • Modello di progettazione del generatore

Cominciamo con un design pattern singleton in Java.

Lettura consigliata = >> Modelli di progettazione per app basate su Flask

Pattern Singleton in Java

Un pattern singleton è un tipo di pattern creazionale in Java. Il modello singleton è un modello di progettazione in cui è presente solo un'istanza di una classe nella macchina virtuale Java. Una classe singleton (che implementa il pattern singleton) deve fornire un punto di accesso globale per ottenere l'istanza della classe.

In altre parole, un pattern singleton limita la creazione di istanze di una classe. Il pattern Singleton viene utilizzato nell'implementazione del logger per le applicazioni. Viene anche utilizzato nell'implementazione del pool di thread o nella cache.

Le classi Java, java.awt.Desktop e java.lang.runtime usa anche un pattern singleton.

Vantaggi

  • Poiché viene utilizzata solo un'istanza della classe singleton, risparmiamo memoria.
  • Inoltre, garantisce la riusabilità poiché lo stesso oggetto singleton viene utilizzato più e più volte.

Passiamo ora all'implementazione del pattern singleton.

Implementazione del modello Singleton

Come già accennato, un modello di progettazione singleton limita la classe con una sola istanza e a questa istanza viene assegnato un punto di accesso globale. Queste erano tutte classi che si riferiscono allo stesso oggetto ancora e ancora.

Il seguente diagramma UML spiega il pattern Singleton.

Implementazione del pattern singleton

Come mostra il diagramma UML sopra, una classe singleton ha una singola istanza definita e vi si accede tramite il metodo getInstance (). Quindi una fabbrica singleton responsabile della creazione di oggetti utilizza il metodo getInstance per restituire lo stesso oggetto (che è presente nella classe) ancora e ancora.

Quindi come implementiamo il pattern Singleton in un programma?

Creiamo una classe singleton e abbiamo il suo costruttore come 'privato' in modo che la classe non possa essere istanziata. Quindi creiamo un'istanza privata di questa classe singleton all'interno della classe stessa. Quindi abbiamo uno speciale metodo pubblico getInstance () che restituisce un oggetto singleton al mondo esterno.

Questa implementazione di questa classe singleton come spiegato sopra è mostrata nel programma Java di seguito.

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(); } }

Produzione:

Implementazione di pattern singleton in un programma

Ora se controlliamo il metodo main, nota che se proviamo a creare un oggetto della classe singleton usando un nuovo operatore, il compilatore darà un errore di compilazione (vedi il codice commentato nel metodo main). Otteniamo l'oggetto della classe singleton usando il metodo getInstance () e poi possiamo usarlo come al solito per accedere ai metodi.

Modello di fabbrica in Java

Il pattern factory è anche chiamato 'Factory Method pattern' o 'Virtual Constructor' in Java. In questo modello, creiamo un'interfaccia o una classe astratta con dichiarazioni di metodo, quindi le classi o sottoclassi concrete che implementano questa interfaccia o ereditano la classe sono responsabili della creazione di istanze della classe.

Vantaggi

  • Il pattern factory è un tipo di pattern creazionale ed è il pattern più comunemente usato in Java.
  • Utilizzando un modello di fabbrica ci assicuriamo che l'effettiva logica di creazione non sia esposta al mondo esterno.

Quindi, se una classe che implementa un modello di fabbrica ha un metodo per calcolare il tasso di interesse, le classi concrete implementeranno questa classe e implementeranno anche il metodo per calcolare il tasso di interesse.

Quindi ci sarà un'altra classe che è una classe factory che accederà a queste istanze di classe concrete in modo che non siamo consapevoli di come viene implementata la logica per calcolare il tasso di interesse. Chiamiamo solo il metodo e otteniamo l'output.

Quindi, quando possiamo usare esattamente il pattern Factory Method?

Quando le classi genitore decidono di delegare la creazione di istanze alle loro sottoclassi, allora possiamo optare per un pattern factory (questo è spiegato sopra). Possiamo anche utilizzare il metodo factory quando la classe non sa quali sottoclassi devono essere create.

Vediamo ora l'implementazione del pattern del metodo factory.

Implementazione del modello di fabbrica

Ad esempio, implementiamo un'interfaccia di forma generica. Possiamo derivare varie classi concrete da questa interfaccia come il cerchio, il rettangolo, ecc. Quindi avremo una classe shapeFactory che accederà agli oggetti della classe concreta. L'UML per questo modello è mostrato di seguito.

Strumenti di Factory Pattern

Come già spiegato, questo è il diagramma UML per il pattern factory. Ora implementeremo un programma Java che dimostri il pattern di fabbrica.

//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(); } }

Produzione:

Pattern di fabbrica - output

Modello generatore in Java

Nel pattern Builder, usiamo un approccio passo passo per costruire un oggetto complesso usando oggetti piccoli e semplici.

Quindi, ogni volta che incontriamo un oggetto che non può essere creato in un unico passaggio, optiamo per un modello builder.

Vantaggi

  • Usando il pattern Builder, possiamo separare la costruzione e la rappresentazione di un oggetto.
  • Possiamo anche cambiare la rappresentazione interna dell'oggetto.
  • Possiamo costruire progetti complessi come un intero sistema di consegna utilizzando il modello del costruttore.

Un esempio pratico di un modello Builder è il sistema di ordinazione degli alimenti che prevedeva passaggi complessi di raccolta degli alimenti ordinati, quindi imballaggio, fatturazione, ordine di costruzione e quindi spedizione.

In questo tutorial, implementeremo un esempio di un sistema di ordinazione dei tablet utilizzando il pattern Builder.

Implementazione del modello Builder

Di seguito è riportato il diagramma UML generale per il modello Builder.

Implementazione del pattern Builder

Il diagramma sopra mostra il diagramma UML del modello Builder. Come mostrato nel diagramma sopra, abbiamo quattro componenti nel pattern Builder.

  • Prodotto: Questo rappresenta l'oggetto complesso da costruire.
  • Builder Abstract class: Una classe astratta contenente prototipi di tutte le funzionalità richieste per costruire un oggetto complesso.
  • Classe ConcreteBuilder: Questa è una classe concreta che eredita dalla classe Builder e crea un particolare oggetto complesso. Possiamo avere tutte le classi ConcreteBuilder di cui abbiamo bisogno.
  • Classe regista: Questa classe controlla gli algoritmi che generano il prodotto finale.

Il seguente esempio di programmazione mostra la dimostrazione di un modello Builder utilizzando un sistema di creazione di ordini di 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(); } }

Produzione:

Build Pattern - output

Nell'esempio sopra, abbiamo costruito il sistema completo di ordinazione dei tablet per due marchi di tablet, ovvero Lenovo e Micromax. Queste sono le classi concreteBuilder che ereditano dalla classe astratta company. Quindi abbiamo una classe TabBuilder che crea gli ordini per entrambe le classi tablet.

Domande frequenti

D # 1) Cosa sono i design pattern in Java? Quali sono i tipi di design pattern in Java?

dove guardare anime gratis online

Risposta: I modelli di progettazione sono le migliori pratiche che possono essere utilizzate per sviluppare soluzioni ben testate.

Java ha tre tipi di design pattern:

  • Modello di progettazione creazionale: Il modello di fabbrica, il modello di fabbrica astratto, il modello Singleton, il modello di generatore e il modello di prototipo sono esempi di modelli di progettazione creazionali. Questi sono principalmente coinvolti nella creazione di oggetti.
  • Modello di progettazione strutturale: Sono usati principalmente per creare una struttura di classe. L'adattatore, il ponte e il modello composito sono modelli di progettazione strutturale popolari.
  • Modello di progettazione comportamentale: Questi forniscono una migliore interazione tra gli oggetti insieme alla flessibilità per estendere facilmente l'implementazione. I modelli dell'osservatore, il modello della strategia, ecc. Sono alcuni esempi dei modelli comportamentali.

D # 2) Perché vengono utilizzati i Design Pattern?

Risposta: I modelli di progettazione ci forniscono un modello di soluzione comprovato e testato che possiamo utilizzare per risolvere problemi complessi. I modelli di design ci consentono di costruire moduli coesivi con accoppiamento libero. I design pattern rendono anche l'interazione tra i designer più efficiente ed efficace.

D # 3) Quali sono gli esempi di Pattern?

Risposta: Esempi di schemi naturali sono regolarità visibili che si trovano in natura. Modelli naturali come simmetrie, alberi, onde, schiume, strisce, crepe, ecc. Sono alcuni esempi di modelli naturali.

D # 4) MVC è un Design Pattern?

Risposta: Sì, è una sorta di modello di progettazione utilizzando il quale possiamo creare un'applicazione composta dal modello di dati, dalla presentazione o dal livello di visualizzazione e dal controller. Possiamo classificarlo più come un modello architettonico.

Conclusione

Questo completa la nostra discussione sui modelli di progettazione in Java. Sebbene Java supporti tre tipi di modelli di progettazione vale a dire. Modelli creazionali, strutturali e comportamentali, siamo più interessati al modello di progettazione creazionale.

In base allo scopo di questo tutorial, abbiamo discusso tre esempi di pattern di progettazione creazionali, ovvero pattern singleton, pattern factory e pattern builder.

Il modello Singleton è il modello di progettazione più semplice e il metodo factory dovrebbe essere un modello di progettazione comune ampiamente utilizzato. Il modello builder viene utilizzato per costruire oggetti complessi e viene utilizzato principalmente nello sviluppo di applicazioni complesse.

=> Dai un'occhiata alla guida di formazione Java perfetta qui.

Lettura consigliata

^