Meny

Designmønstre i Java: Singleton, Factory And Builder

  • Hoved
  • Annen
  • Designmønstre i Java: Singleton, Factory And Builder

design patterns java

Prøv Instrumentet Vårt For Å Eliminere Problemer

I denne veiledningen vil vi diskutere designmønstre i Java. Vi vil studere Singleton, Factory og Builder mønstre med eksempler og fordeler:

Når vi løser et spesifikt problem, kan vi løse det mer effektivt hvis vi har noen gode fremgangsmåter som allerede er definert. Dette vil virkelig hjelpe oss å følge disse beste praksisene og utvikle mer pålitelige løsninger.

Disse beste praksis som kan brukes til å utvikle seg velprøvde løsninger for å løse problemer kalles “ Design mønstre ”. Erfarne OOP-programvareutviklere bruker designmønstre for å løse spesifikke oppgaver.

=> Ta en titt på Java Beginners Guide her

Design mønstre i Java

Hva du vil lære:

Design mønstre i Java

Designmønstre ble først oppfunnet av Christopher Alexander i 1977. Men senere skrev fire utviklere, nemlig Erich Gamma, Richard Helm, John Vlissides og Ralph Johnson en bok med tittelen “ Gang of Four-Design mønstre, elementer av gjenbrukbar objektorientert programvare ”I 1995.

Fra da ble alle designmønstrene kjent som “ Gang of Four Design Patterns ”.

hva er testing av hvit boks med eksempel

Designmønstre er uavhengige av programmeringsspråk, ettersom de brukes til å løse vanlige objektorienterte designproblemer og ikke bare er begrenset til et bestemt programmeringsspråk. Så i utgangspunktet er det en idé og ikke en implementering.

Dermed kan vi bruke designmønstre og utvikle programmer som er mer effektive, fleksible, vedlikeholdbare og gjenbrukbare.

Fordeler med designmønstre

Nedenfor er noen av fordelene ved å bruke designmønstre i våre applikasjoner:

  • Designmønstre er gjenbrukbare og kan brukes av flere prosjekter.
  • Vi kan definere systemarkitektur ved hjelp av designmønstre.
  • Designmønstre gir gjennomsiktighet i applikasjonsdesignet.
  • Designmønstre er allerede godt testet og bevist slik at vi kan bruke dem uten bekymringer.
  • Designmønstre tillater oss å bygge bedre systemer og også gi klarhet i systemarkitekturen.

Når skal du bruke designmønstre

Så når skal vi nøyaktig bruke designmønstrene?

Vi bruker vanligvis et designmønster i løpet av den første fasen for analyse og krav til SDLC (Software Development Life Cycle). Når den brukes under analyse- og kravfasen til SDLC, gir den mer informasjon til denne fasen. Java støtter internt designmønstre.

Designmønstre i Java er kategorisert som følger:

Design mønstre i Java

Når det gjelder denne veiledningen, er vi bare interessert i skapende designmønstre.

Kreative designmønstre klassifiseres videre som følger:

Creational Design mønstre

I denne opplæringen vil vi diskutere følgende designmønstre:

  • Singleton designmønster
  • Fabrikkdesignmønster
  • Builder designmønster

La oss starte med et enkelt designmønster i Java.

Anbefalt lesing = >> Design mønstre for kolbaserte apper

Singleton-mønster i Java

Et singleton-mønster er en type skapelsesmønster i Java. Singleton-mønster er et designmønster der bare en forekomst av en klasse er tilstede i den virtuelle Java-maskinen. En singleton-klasse (implementering av singleton-mønster) må gi et globalt tilgangspunkt for å få forekomsten av klassen.

Med andre ord, en singleton mønster begrenser instantiering av en klasse. Singleton-mønster brukes i implementeringen av loggeren for applikasjoner. Den brukes også i implementering av trådbasseng eller hurtigbuffer.

Java-klassene, java.awt.Desktop og java.lang. kjøretid bruk også et singleton-mønster.

Fordeler

  • Ettersom bare én forekomst av singleton-klassen brukes, sparer vi minne.
  • Sikrer også gjenbrukbarhet da det samme singleton-objektet brukes igjen og igjen.

La oss nå gå videre til implementeringen av singleton-mønsteret.

Implementering av Singleton-mønsteret

Som allerede nevnt begrenser et singleton-designmønster klassen med bare en forekomst, og denne forekomsten får et globalt tilgangspunkt. Dette var alle klasser som refererer til det samme objektet igjen og igjen.

Følgende UML-diagram forklarer Singleton-mønsteret.

Implementering av singleton-mønsteret

Som ovenstående UML-diagram viser, har en singleton-klasse en enkelt forekomst definert, og vi får tilgang til den med getInstance () -metoden. Så en singleton-fabrikk som er ansvarlig for å lage objekter bruker getInstance-metoden for å returnere det samme objektet (som er der i klassen) igjen og igjen.

Så hvordan implementerer vi Singleton-mønsteret i et program?

Vi lager en singleton-klasse og har sin konstruktør som 'privat' slik at klassen ikke kan instantieres. Så oppretter vi en privat forekomst av denne singleton-klassen i selve klassen. Så har vi en spesiell offentlig metode getInstance () som returnerer et enkelt objekt til omverdenen.

Denne implementeringen av denne singleton-klassen som forklart ovenfor, vises i Java-programmet nedenfor.

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

Produksjon:

Implementering av singleton mønster i et program

Nå hvis vi sjekker hovedmetoden, vær oppmerksom på at hvis vi prøver å lage et objekt av singleton-klassen ved hjelp av en ny operator, vil kompilatoren gi en kompileringsfeil (se den kommenterte koden i hovedmetoden). Vi får tak i objektet til singleton-klassen ved hjelp av getInstance () -metoden, og så kan vi bruke det som vanlig for å få tilgang til metoder.

Fabrikkmønster i Java

Fabrikkmønsteret kalles også 'Factory Method pattern' eller 'Virtual Constructor' på Java. I dette mønsteret lager vi et grensesnitt eller en abstrakt klasse med metodedeklarasjoner, og deretter er de konkrete klassene eller underklassene som implementerer dette grensesnittet eller arver klassen, ansvarlige for å skape forekomster av klassen.

Fordeler

  • Fabrikkmønsteret er en type skapelsesmønster og er det mest brukte mønsteret i Java.
  • Ved å bruke et fabrikkmønster sikrer vi at den faktiske skapelseslogikken ikke blir utsatt for omverdenen.

Så hvis en klasse som implementerer et fabrikkmønster har en metode for å beregne renten, vil de konkrete klassene implementere denne klassen og også implementere metoden for å beregne renten.

Så vil det være en annen klasse som er en fabriksklasse som får tilgang til disse konkrete klasseinstansene slik at vi ikke er klar over hvordan logikken for å beregne renten blir implementert. Vi kaller bare metoden og får utdataene.

Så når kan vi bruke Factory Method-mønsteret?

Når foreldreklassene bestemmer seg for å delegere oppretting av forekomster til underklassene, kan vi gå etter et fabrikkmønster (Dette er forklart ovenfor). Vi kan også bruke fabrikkmetoden når klassen ikke vet hvilke underklasser som skal opprettes.

La oss nå se implementeringen av fabrikkmetodemønsteret.

Implementering av fabrikkmønsteret

Som et eksempel, la oss implementere et generisk formgrensesnitt. Vi kan utlede forskjellige betongklasser fra dette grensesnittet som sirkel, rektangel osv. Da vil vi ha en formFabrikklasse som får tilgang til betongklasseobjektene. UML for dette mønsteret er vist nedenfor.

Implementeringer av fabrikkmønster

Som allerede forklart er dette UML-diagrammet for fabrikkmønster. Nå skal vi implementere et Java-program som demonstrerer fabrikkmønsteret.

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

Produksjon:

Fabrikkmønster - utgang

Byggmønster i Java

I Builder-mønsteret bruker vi en trinnvis tilnærming til å bygge et komplekst objekt ved hjelp av små og enkle objekter.

Så når vi møter et objekt som ikke kan opprettes i et enkelt trinn, går vi etter et byggmønster.

Fordeler

  • Ved hjelp av Builder-mønsteret kan vi skille konstruksjonen og representasjonen av et objekt.
  • Vi kan også endre den interne representasjonen av objektet.
  • Vi kan bygge komplekse design som et helt leveringssystem ved hjelp av byggemønsteret.

Et praktisk eksempel på et Builder-mønster er matbestillingssystemet som involverte komplekse trinn for å samle matvarer som er bestilt, deretter emballasje, fakturering, byggordre og deretter frakt.

I denne opplæringen vil vi implementere et eksempel på et nettbrettbestillingssystem ved hjelp av Builder-mønsteret.

Implementering av byggmønster

Det generelle UML-diagrammet for Builder-mønsteret er gitt nedenfor.

Implementering av byggmønster

Ovenstående diagram viser Builder-mønster UML-diagram. Som vist i diagrammet ovenfor har vi fire komponenter i Builder-mønsteret.

  • Produkt: Dette representerer det komplekse objektet som skal bygges.
  • Builder Abstrakt klasse: En abstrakt klasse som inneholder prototyper av all funksjonalitet som kreves for å bygge et komplekst objekt.
  • ConcreteBuilder-klasse: Dette er en konkret klasse som arver fra Builder-klassen og skaper et spesielt komplekst objekt. Vi kan ha så mange ConcreteBuilder-klasser som vi trenger.
  • Direktørklasse: Denne klassen styrer algoritmene som genererer det endelige produktet.

Følgende programmeringseksempel viser demonstrasjonen av et Builder-mønster ved hjelp av et nettbrettbestillingssystem.

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

Produksjon:

Bygg mønster - utgang

I eksemplet ovenfor har vi bygget det komplette bestillingssystemet for nettbrett for to nettbrettmerker, dvs. Lenovo og Micromax. Dette er concreteBuilder-klassene som arver fra det abstrakte klasseselskapet. Så har vi en TabBuilder-klasse som bygger ordrene for begge nettbrettklassene.

ofte stilte spørsmål

Q # 1) Hva er designmønstre i Java? Hva er typene designmønstre i Java?

hvordan du åpner en .bin fil i Windows

Svar: Designmønstre er de beste metodene som kan brukes til å utvikle velprøvde løsninger.

Java har tre typer designmønstre:

  • Kreativt designmønster: Fabrikkmønster, Abstrakt Fabrikkmønster, Singleton mønster, Byggmønster og prototype mønster er eksempler på skapelsesmønstre. Disse er hovedsakelig involvert i oppretting av objekter.
  • Strukturelt designmønster: De brukes mest til å lage en klassestruktur. Adapter, bro og sammensatt mønster er populære strukturelle designmønstre.
  • Atferdsmessig mønster: Disse gir bedre samhandling mellom objektene sammen med fleksibiliteten for å enkelt utvide implementeringen. Observatørmønstre, strategimønster osv. Er noen eksempler på atferdsmønstre.

Spørsmål 2) Hvorfor brukes designmønstre?

Svar: Designmønstre gir oss en bevist og testet løsningsmodell som vi kan bruke til å løse komplekse problemer. Designmønstre tillater oss å bygge sammenhengende moduler med løs kobling. Designmønstre gjør også samspillet mellom designere mer effektivt og effektivt.

Sp # 3) Hva er eksemplene på mønstre?

Svar: Eksempler på naturlige mønstre er synlige regelmessigheter som finnes i naturen. Naturlige mønstre som symmetri, trær, bølger, skum, striper, sprekker osv. Er noen eksempler på naturlige mønstre.

Q # 4) Er MVC et designmønster?

Svar: Ja, det er et slags designmønster der vi kan bygge en applikasjon som består av datamodellen, presentasjonen eller visningslaget og kontrolleren. Vi kan klassifisere det mer som et arkitektonisk mønster.

Konklusjon

Dette fullfører vår diskusjon om designmønstre i Java. Selv om Java støtter tre typer designmønstre, nemlig. Kreasjonelle, strukturelle og atferdsmønstre, vi er mer interessert i det skapende designmønsteret.

I henhold til omfanget av denne opplæringen har vi diskutert tre eksempler på skapelsesdesignmønstre, nemlig singleton-mønster, fabrikkmønster og byggmønster.

Singleton-mønster er det enkleste designmønsteret og fabrikkmetoden skal være et vanlig designmønster som er mye brukt. Bygningsmønsteret brukes til å konstruere komplekse objekter og brukes mest til å utvikle komplekse applikasjoner.

=> Ta en titt på den perfekte Java-treningsveiledningen her.

Anbefalt lesing

^