Menu

Designmønstre i Java: Singleton, fabrik og bygherre

design patterns java

Prøv Vores Instrument Til At Fjerne Problemer

I denne vejledning diskuterer vi designmønstre i Java. Vi vil studere Singleton, Factory og Builder mønstre med eksempler og fordele:

Når vi løser et specifikt problem, kan vi løse det mere effektivt, hvis vi allerede har defineret nogle af de bedste fremgangsmåder. Dette vil virkelig hjælpe os med at følge disse bedste praksis og udvikle mere pålidelige løsninger.

Disse bedste praksis der kan bruges til at udvikle sig velprøvede løsninger til løsning af problemer kaldes “ Designmønstre ”. Erfarne OOP-softwareudviklere bruger designmønstre til at løse specifikke opgaver.

=> Se på Java Beginners Guide her

Design mønstre i Java

Hvad du lærer:

Design mønstre i Java

Designmønstre blev først opfundet af Christopher Alexander i 1977. Men senere skrev fire udviklere, nemlig Erich Gamma, Richard Helm, John Vlissides og Ralph Johnson en bog med titlen ' Gang of Four-Design mønstre, elementer i genanvendelig objektorienteret software ”I 1995.

Fra da blev alle designmønstre kendt som “ Gang of Four Design Patterns ”.

hvad bruges c ++ til?

Designmønstre er uafhængige af ethvert programmeringssprog, da de bruges til at løse almindelige objektorienterede designproblemer og er ikke kun begrænset til et specifikt programmeringssprog. Så dybest set er det en idé og ikke en implementering.

Således ved hjælp af designmønstre kan vi udvikle programmer, der er mere effektive, fleksible, vedligeholdelige og genanvendelige.

Fordele ved designmønstre

Nedenfor er nogle af fordelene ved at bruge designmønstre i vores applikationer:

  • Designmønstre kan genbruges og kan bruges af flere projekter.
  • Vi kan definere systemarkitektur ved hjælp af designmønstre.
  • Designmønstre giver gennemsigtighed i applikationsdesignet.
  • Designmønstre er allerede velafprøvede og bevist, så vi kan bruge dem uden bekymringer.
  • Designmønstre giver os mulighed for at opbygge bedre systemer og også give klarhed om systemarkitektur.

Hvornår skal man bruge designmønstre

Så hvornår skal vi nøjagtigt bruge designmønstrene?

Vi bruger normalt et designmønster i den indledende analyse- og kravfase i SDLC (Software Development Life Cycle). Når det bruges i SDLC's analyse- og kravfase, giver det mere information til denne fase. Java understøtter internt designmønstre.

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

Design mønstre i Java

For så vidt angår denne tutorial, er vi kun interesserede i skabelsesmønstre.

Skabelsesmønstre er yderligere klassificeret som følger:

Kreative designmønstre

I denne vejledning vil vi diskutere følgende designmønstre:

  • Singleton design mønster
  • Fabriksdesignmønster
  • Builder design mønster

Lad os starte med et enkelt designmønster i Java.

Anbefalet læsning = >> Design mønstre til flaskebaserede apps

Singleton-mønster i Java

Et singleton-mønster er en type skabelsesmønster i Java. Singleton-mønster er et designmønster, hvor kun en forekomst af en klasse er til stede i den virtuelle Java-maskine. En singleton-klasse (implementering af singleton-mønster) skal give et globalt adgangspunkt for at få forekomsten af ​​klassen.

Med andre ord begrænser et singleton-mønster instantiering af en klasse. Singleton mønster bruges i implementeringen af ​​loggeren til applikationer. Det bruges også til implementering af trådpuljer eller cache.

Java-klasser, java.awt.Desktop og java.lang.kørselstid Brug også et enkelt mønster.

Fordele

  • Da kun én forekomst af singleton-klassen bruges, sparer vi hukommelse.
  • Sikrer også genanvendelighed, da det samme singleton-objekt bruges igen og igen.

Lad os nu gå videre til implementeringen af ​​singleton-mønsteret.

Implementering af Singleton-mønsteret

Som allerede nævnt begrænser et singleton-designmønster klassen med kun en forekomst, og denne forekomst får et globalt adgangspunkt. Dette var alle klasser, der henviser til det samme objekt igen og igen.

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

Implementering af singleton-mønsteret

Som ovenstående UML-diagram viser, har en singleton-klasse en enkelt instans defineret, og vi får adgang til den ved getInstance () -metoden. Så en enkeltfabrik, der er ansvarlig for at skabe objekter, bruger metoden getInstance til at returnere det samme objekt (som er der i klassen) igen og igen.

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

Vi opretter en singleton-klasse og har dens konstruktør som 'privat', så klassen ikke kan instantieres. Derefter opretter vi en privat forekomst af denne singleton-klasse inde i selve klassen. Så har vi en særlig offentlig metode getInstance (), der returnerer et enkelt objekt til omverdenen.

Denne implementering af denne singleton-klasse som forklaret ovenfor er vist 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(); } }

Produktion:

Implementering af singleton mønster i et program

Hvis vi nu kontrollerer hovedmetoden, skal du bemærke, at hvis vi forsøger at oprette et objekt fra singleton-klassen ved hjælp af en ny operator, vil compileren give en kompileringsfejl (se den kommenterede kode i hovedmetoden). Vi opnår objektet fra singleton-klassen ved hjælp af getInstance () -metoden, og så kan vi bruge det som normalt til at få adgang til metoder.

Fabriksmønster i Java

Fabriksmønsteret kaldes også 'Fabriksmetodemønster' eller 'Virtual Constructor' i Java. I dette mønster opretter vi en grænseflade eller en abstrakt klasse med metodedeklarationer, og derefter er de konkrete klasser eller underklasser, der implementerer denne grænseflade eller arver klassen, ansvarlige for at skabe forekomster af klassen.

Fordele

  • Fabriksmønsteret er en type skabelsesmønster og er det mest anvendte mønster i Java.
  • Ved at bruge et fabriksmønster sikrer vi, at den faktiske oprettelseslogik ikke udsættes for omverdenen.

Så hvis en klasse, der implementerer et fabriksmønster, har en metode til at beregne renten, vil de konkrete klasser implementere denne klasse og også implementere metoden til at beregne renten.

Så vil der være en anden klasse, der er en fabriksklasse, der får adgang til disse konkrete klasseinstanser, så vi ikke er klar over, hvordan logikken til at beregne rentesatsen implementeres. Vi kalder kun metoden og får output.

Så hvornår kan vi nøjagtigt bruge Factory Method-mønsteret?

Når overordnede klasser beslutter at delegere oprettelsen af ​​forekomster til deres underklasser, kan vi gå efter et fabriksmønster (Dette forklares ovenfor). Vi kan også bruge fabriksmetoden, når klassen ikke ved, hvilke underklasser der skal oprettes.

Lad os nu se implementeringen af ​​fabriksmetodemønsteret.

Implementering af fabriksmønsteret

Lad os som et eksempel implementere en generisk formgrænseflade. Vi kan udlede forskellige betonklasser fra denne grænseflade som cirkel, rektangel osv. Så får vi en formFabrikklasse, der får adgang til betonklasseobjekterne. UML for dette mønster er vist nedenfor.

Implementeringer af fabriksmønster

Som allerede forklaret er dette UML-diagrammet for fabriksmønster. Nu implementerer vi et Java-program, der demonstrerer fabriksmø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(); } }

Produktion:

Fabriksmønster - output

Builder-mønster i Java

I Builder-mønsteret bruger vi en trin-for-trin tilgang til at opbygge et komplekst objekt ved hjælp af små og enkle objekter.

Så når vi støder på et objekt, der ikke kan oprettes i et enkelt trin, går vi efter et bygmønster.

Fordele

  • Ved hjælp af Builder-mønsteret kan vi adskille konstruktionen og repræsentationen af ​​et objekt.
  • Vi kan også ændre objektets interne repræsentation.
  • Vi kan bygge komplekse designs som et helt leveringssystem ved hjælp af bygningsmønsteret.

Et praktisk eksempel på et Builder-mønster er madbestillingssystemet, der involverede komplekse trin til indsamling af madvarer, der bestilles, derefter emballering, fakturering, bygordre og derefter forsendelse.

I denne vejledning implementerer vi et eksempel på et tabletbestillingssystem ved hjælp af Builder-mønsteret.

Implementering af byggemønster

Det generelle UML-diagram for Builder-mønsteret er angivet nedenfor.

Implementering af Builder-mønster

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

  • Produkt: Dette repræsenterer det komplekse objekt, der skal bygges.
  • Builder Abstrakt klasse: En abstrakt klasse indeholdende prototyper af al den funktionalitet, der kræves for at opbygge et komplekst objekt.
  • ConcreteBuilder klasse: Dette er en konkret klasse, der arver fra Builder-klassen og skaber et bestemt komplekst objekt. Vi kan have så mange ConcreteBuilder-klasser, som vi har brug for.
  • Direktørklasse: Denne klasse styrer algoritmerne, der genererer det endelige produkt.

Følgende programmeringseksempel viser demonstrationen af ​​et Builder-mønster ved hjælp af et tabletbestillingssystem.

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:

Byg mønster - output

I ovenstående eksempel har vi bygget det komplette tabletbestillingssystem til to tabletmærker, dvs. Lenovo og Micromax. Dette er de concreteBuilder-klasser, der arver fra det abstrakte klasseselskab. Derefter har vi en TabBuilder-klasse, der bygger ordrer til begge tabletklasser.

Ofte stillede spørgsmål

Q # 1) Hvad er designmønstre i Java? Hvad er typerne af designmønstre i Java?

hvor man kan se anime gratis online

Svar: Designmønstre er de bedste fremgangsmåder, der kan bruges til at udvikle velafprøvede løsninger.

Java har tre typer designmønstre:

  • Skabelsesmønster: Fabriksmønster, Abstrakt Fabriksmønster, Singleton-mønster, Byggemønster og prototype-mønster er eksempler på kreative designmønstre. Disse er primært involveret i oprettelsen af ​​objekter.
  • Strukturelt designmønster: De bruges mest til at skabe en klassestruktur. Adapter, bro og sammensat mønster er populære strukturelle designmønstre.
  • Adfærdsmæssigt designmønster: Disse giver bedre interaktion mellem objekterne sammen med fleksibiliteten til let at udvide implementeringen. Observatørmønstre, strategimønster osv. Er nogle eksempler på adfærdsmønstre.

Q # 2) Hvorfor bruges designmønstre?

Svar: Designmønstre giver os en gennemprøvet og testet løsningsmodel, som vi kan bruge til at løse komplekse problemer. Designmønstre giver os mulighed for at bygge sammenhængende moduler med løs kobling. Designmønstre gør også interaktion mellem designere mere effektiv og effektiv.

Q # 3) Hvad er eksemplerne på mønstre?

Svar: Eksempler på naturlige mønstre er synlige regelmæssigheder, der findes i naturen. Naturlige mønstre som symmetrier, træer, bølger, skum, striber, revner osv. Er nogle eksempler på naturlige mønstre.

Q # 4) Er MVC et designmønster?

Svar: Ja, det er en slags designmønster, hvor vi kan bygge en applikation bestående af datamodellen, præsentationen eller visningslaget og controlleren. Vi kan klassificere det mere som et arkitektonisk mønster.

Konklusion

Dette fuldender vores diskussion om designmønstre i Java. Selvom Java understøtter tre typer designmønstre nemlig. Skabelsesmæssige, strukturelle og adfærdsmønstre, vi er mere interesserede i det skabende designmønster.

I henhold til omfanget af denne vejledning har vi diskuteret tre eksempler på skabelsesmønstre, nemlig singleton-mønster, fabriksmønster og bygmønster.

Singleton-mønster er det enkleste designmønster, og fabriksmetoden antages at være et almindeligt designmønster, der er meget udbredt. Bygningsmønsteret bruges til at konstruere komplekse objekter og bruges mest til at udvikle komplekse applikationer.

=> Tjek den perfekte Java-træningsvejledning her.

Anbefalet læsning

^