Meny

Designmönster i Java: Singleton, Factory And Builder

  • Huvud
  • Övrig
  • Designmönster i Java: Singleton, Factory And Builder

design patterns java

Prova Vårt Instrument För Att Eliminera Problem

I denna handledning kommer vi att diskutera designmönster i Java. Vi kommer att studera Singleton, Factory och Builder mönster med exempel och fördelar:

När vi löser ett specifikt problem kan vi lösa det mer effektivt om vi har några bästa praxis som redan definierats. Detta kommer verkligen att hjälpa oss att följa dessa bästa metoder och utveckla mer tillförlitliga lösningar.

Dessa bästa praxis som kan användas för att utvecklas väl beprövade lösningar för att lösa problem kallas ” Design mönster ”. Erfarna OOP-programutvecklare använder designmönster för att lösa specifika uppgifter.

=> Ta en titt på Java-nybörjarguiden här

Designmönster i Java

Vad du kommer att lära dig:

Designmönster i Java

Designmönster uppfanns först av Christopher Alexander 1977. Men senare skrev fyra utvecklare, nämligen Erich Gamma, Richard Helm, John Vlissides och Ralph Johnson en bok med titeln ' Gang of Four-Design-mönster, element i återanvändbar objektorienterad programvara 1995.

Sedan dess blev alla designmönster kända som ” Gang of Four Design Patterns ”.

konvertera char till int i c ++

Designmönster är oberoende av alla programmeringsspråk eftersom de används för att lösa vanliga objektorienterade designproblem och är inte bara begränsade till ett specifikt programmeringsspråk. Så i princip är det en idé och inte en implementering.

Således med hjälp av designmönster kan vi utveckla program som är mer effektiva, flexibla, underhållbara och återanvändbara.

Fördelar med designmönster

Nedan listas några av fördelarna med att använda designmönster i våra applikationer:

  • Designmönster kan återanvändas och kan användas av flera projekt.
  • Vi kan definiera systemarkitektur med hjälp av designmönster.
  • Designmönster ger insyn i applikationsdesignen.
  • Designmönster är redan väl testade och bevisade så att vi kan använda dem utan bekymmer.
  • Designmönster gör att vi kan bygga bättre system och också ge tydlighet i systemarkitekturen.

När ska jag använda designmönster

Så när ska vi exakt använda designmönstren?

Vi använder vanligtvis ett designmönster under den initiala analys- och kravfasen i SDLC (Software Development Life Cycle). När den används under analys- och kravfasen för SDLC, ger den mer information till denna fas. Java stöder internt designmönster.

Designmönster i Java kategoriseras enligt följande:

Designmönster i Java

När det gäller denna handledning är vi bara intresserade av skapande designmönster.

Skapande designmönster klassificeras vidare enligt följande:

Skapande designmönster

I denna handledning kommer vi att diskutera följande designmönster:

  • Singleton designmönster
  • Fabriksdesignmönster
  • Builder designmönster

Låt oss börja med ett singleton-designmönster i Java.

Rekommenderad läsning = >> Designa mönster för kolbaserade appar

Singleton-mönster i Java

Ett singletonmönster är en typ av skapande mönster i Java. Singleton-mönster är ett designmönster där endast en förekomst av en klass finns i Java virtuella maskin. En singleton-klass (implementering av singleton-mönster) måste tillhandahålla en global åtkomstpunkt för att få förekomsten av klassen.

Med andra ord begränsar ett singletonmönster instantiering av en klass. Singleton-mönster används vid implementeringen av loggaren för applikationer. Den används också i trådpoolimplementering eller cache.

Java-klasserna, java.awt.Desktop och java.lang.runtime använd också ett singletonmönster.

Fördelar

  • Eftersom endast en instans av singleton-klassen används sparar vi minne.
  • Säkerställer också återanvändning eftersom samma singleton-objekt används om och om igen.

Låt oss nu gå vidare till implementeringen av singletonmönstret.

Implementering av Singleton-mönstret

Som redan nämnts begränsar ett singleton-designmönster klassen med endast en instans och denna instans ges en global åtkomstpunkt. Detta var alla klasser som hänvisar till samma objekt om och om igen.

Följande UML-diagram förklarar Singleton-mönstret.

Implementering av singletonmönstret

Som ovanstående UML-diagram visar har en singleton-klass en enda instans definierad och vi kommer åt den med getInstance () -metoden. Så en singleton-fabrik som är ansvarig för att skapa objekt använder sig av metoden getInstance för att returnera samma objekt (som finns där i klassen) om och om igen.

Så hur implementerar vi Singleton-mönstret i ett program?

Vi skapar en singleton-klass och har sin konstruktör som 'privat' så att klassen inte kan instansieras. Sedan skapar vi en privat instans av denna singletonklass inuti klassen själv. Sedan har vi en speciell offentlig metod getInstance () som returnerar ett singleton-objekt till omvärlden.

Denna implementering av denna singleton-klass som förklaras ovan visas i Java-programmet nedan.

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

Produktion:

Implementering av singletonmönster i ett program

Om vi ​​nu kontrollerar huvudmetoden, notera att om vi försöker skapa ett objekt av singleton-klassen med en ny operatör, kommer kompilatorn att ge ett kompileringsfel (se den kommenterade koden i huvudmetoden). Vi får objektet för singleton-klassen med getInstance () -metoden och sedan kan vi använda det som vanligt för att komma åt metoder.

Fabriksmönster i Java

Fabriksmönstret kallas också 'Fabriksmetodsmönster' eller 'Virtual Constructor' på Java. I detta mönster skapar vi ett gränssnitt eller en abstrakt klass med metoddeklarationer och sedan är de konkreta klasserna eller underklasserna som implementerar detta gränssnitt eller ärver klassen ansvariga för att skapa instanser av klassen.

Fördelar

  • Fabriksmönstret är en typ av skapande mönster och är det vanligaste mönstret i Java.
  • Genom att använda ett fabriksmönster ser vi till att den faktiska skapelselogiken inte exponeras för omvärlden.

Så om en klass som implementerar ett fabriksmönster har en metod för att beräkna räntan, kommer de konkreta klasserna att implementera denna klass och också implementera metoden för att beräkna räntan.

Sedan kommer det att finnas en annan klass som är en fabriksklass som kommer åt dessa konkreta klassinstanser så att vi inte är medvetna om hur logiken för att beräkna räntan implementeras. Vi anropar bara metoden och får utdata.

Så när kan vi exakt använda Factory Method-mönstret?

När föräldraklasserna beslutar att delegera skapandet av förekomster till sina underklasser, kan vi gå efter ett fabriksmönster (Detta förklaras ovan). Vi kan också använda fabriksmetoden när klassen inte vet vilka underklasser som ska skapas.

Låt oss nu se implementeringen av fabriksmetodsmönstret.

Implementering av fabriksmönstret

Som ett exempel kan vi implementera ett generiskt formgränssnitt. Vi kan härleda olika betongklasser från detta gränssnitt som cirkel, rektangel etc. Då har vi en formFabriksklass som kommer åt betongklassobjekten. UML för detta mönster visas nedan.

Redskap av fabriksmönster

Som redan förklarats är detta UML-diagrammet för fabriksmönster. Nu kommer vi att implementera ett Java-program som visar fabriksmönstret.

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

Produktion:

Fabriksmönster - utgång

Byggmönster i Java

I byggmönstret använder vi en steg-för-steg-metod för att bygga ett komplext objekt med små och enkla objekt.

Så när vi stöter på ett objekt som inte kan skapas i ett enda steg, går vi efter ett byggmönster.

Fördelar

  • Med hjälp av byggmönstret kan vi separera konstruktionen och representationen av ett objekt.
  • Vi kan också ändra objektets interna representation.
  • Vi kan bygga komplexa mönster som ett helt leveranssystem med hjälp av byggmönstret.

Ett praktiskt exempel på ett byggmönster är matbeställningssystemet som involverade komplexa steg för att samla in matvaror som beställts, sedan förpackning, fakturering, byggorder och sedan leverans.

I denna handledning kommer vi att implementera ett exempel på ett beställningssystem för surfplattor med hjälp av Builder-mönstret.

Implementering av byggmönster

Det allmänna UML-diagrammet för byggmönstret ges nedan.

Implementering av byggmönster

Ovanstående diagram visar UML-diagrammet för byggmönster. Som visas i ovanstående diagram har vi fyra komponenter i byggmönstret.

  • Produkt: Detta representerar det komplexa objektet som ska byggas.
  • Byggnadsabstraktklass: En abstrakt klass som innehåller prototyper av all funktionalitet som krävs för att bygga ett komplext objekt.
  • ConcreteBuilder-klass: Detta är en konkret klass som ärver från Builder-klassen och skapar ett särskilt komplext objekt. Vi kan ha så många ConcreteBuilder-klasser som vi behöver.
  • Regissörsklass: Denna klass styr algoritmerna som genererar den slutliga produkten.

Följande programmeringsexempel visar demonstrationen av ett Builder-mönster med hjälp av ett beställningssystem för surfplattor.

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

Produktion:

Byggmönster - utdata

I exemplet ovan har vi byggt det kompletta beställningssystemet för surfplattor för två surfplattamärken, dvs Lenovo och Micromax. Dessa är concreteBuilder-klasserna som ärver från det abstrakta klassföretaget. Sedan har vi en TabBuilder-klass som bygger beställningarna för båda tablettklasserna.

Vanliga frågor

F # 1) Vad är designmönster i Java? Vilka typer av designmönster i Java?

konvertera char-nummer till int c ++

Svar: Designmönster är de bästa metoderna som kan användas för att utveckla välprovade lösningar.

Java har tre typer av designmönster:

  • Skapande designmönster: Fabriksmönster, Abstrakt Fabriksmönster, Singletonmönster, Byggmönster och prototypmönster är exempel på skapande designmönster. Dessa är främst involverade i skapandet av objekt.
  • Konstruktionsmönster: De används mest för att skapa en klassstruktur. Adapter, bro och kompositmönster är populära strukturella designmönster.
  • Beteendemönster: Dessa ger bättre interaktion mellan objekten tillsammans med flexibiliteten för att enkelt förlänga implementeringen. Observatörsmönster, strategimönster etc. är några exempel på beteendemönstren.

F # 2) Varför används designmönster?

Svar: Designmönster ger oss en beprövad och testad lösningsmodell som vi kan använda för att lösa komplexa problem. Designmönster gör det möjligt för oss att bygga sammanhängande moduler med lös koppling. Designmönster gör också interaktionen mellan designers mer effektiv och effektiv.

F # 3) Vilka är exemplen på mönster?

Svar: Exempel på naturliga mönster är synliga regelbundenheter som finns i naturen. Naturliga mönster som symmetrier, träd, vågor, skum, ränder, sprickor etc. är några exempel på naturliga mönster.

F # 4) Är MVC ett designmönster?

Svar: Ja, det är ett slags designmönster med vilket vi kan bygga en applikation bestående av datamodellen, presentationen eller vyskiktet och styrenheten. Vi kan klassificera det mer som ett arkitektoniskt mönster.

Slutsats

Detta kompletterar vår diskussion om designmönster i Java. Även om Java stöder tre typer av designmönster, nämligen. Skapande, strukturella och beteendemönster, vi är mer intresserade av det skapande designmönstret.

Enligt omfattningen av denna handledning har vi diskuterat tre exempel på skapande designmönster, nämligen singletonmönster, fabriksmönster och byggmönster.

Singleton-mönster är det enklaste designmönstret och fabriksmetoden ska vara ett vanligt designmönster som används i stor utsträckning. Byggmönstret används för att konstruera komplexa objekt och används mest för att utveckla komplexa applikationer.

=> Kolla in den perfekta Java-träningsguiden här.

Rekommenderad läsning

^