Prototype Design Pattern in Java

Prototype ontwerppatroon is een van de creërende ontwerppatronen, dus het biedt een mechanisme voor objectcreatie.

Prototype Ontwerppatroon

Het prototype ontwerppatroon wordt gebruikt wanneer het maken van een object kostbaar is en veel tijd en middelen vereist, en je al een vergelijkbaar object hebt. Het prototypepatroon biedt een mechanisme om het oorspronkelijke object naar een nieuw object te kopiëren en het vervolgens aan te passen aan onze behoeften. Het prototype ontwerppatroon maakt gebruik van Java-klonen om het object te kopiëren.

Voorbeeld van het Prototype Ontwerppatroon

Het zou gemakkelijk zijn om het prototype ontwerppatroon te begrijpen met een voorbeeld. Stel dat we een Object hebben dat gegevens uit een database laadt. Nu moeten we deze gegevens meerdere keren aanpassen in ons programma, dus het is geen goed idee om het Object te maken met het new trefwoord en telkens alle gegevens opnieuw uit de database te laden. De betere aanpak zou zijn om het bestaande object te klonen naar een nieuw object en vervolgens de gegevensmanipulatie uit te voeren. Het prototype ontwerppatroon vereist dat het Object dat u kopieert de kopieerfunctie moet bieden. Het mag niet door een andere klasse worden gedaan. Of echter een ondiepe of diepe kopie van de Objecteigenschappen moet worden gebruikt, hangt af van de vereisten en het is een ontwerpbeslissing. Hier is een voorbeeldprogramma dat het Prototype ontwerppatroon toont in Java. Employees.java

package com.journaldev.design.prototype;

import java.util.ArrayList;
import java.util.List;

public class Employees implements Cloneable{

	private List empList;
	
	public Employees(){
		empList = new ArrayList();
	}
	
	public Employees(List list){
		this.empList=list;
	}
	public void loadData(){
		//lees alle werknemers uit de database en plaats ze in de lijst
		empList.add("Pankaj");
		empList.add("Raj");
		empList.add("David");
		empList.add("Lisa");
	}
	
	public List getEmpList() {
		return empList;
	}

	@Override
	public Object clone() throws CloneNotSupportedException{
			List temp = new ArrayList();
			for(String s : this.getEmpList()){
				temp.add(s);
			}
			return new Employees(temp);
	}
	
}

Merk op dat de clone-methode is overschreven om een diepe kopie van de werknemerslijst te geven. Hier is het prototype ontwerppatroon voorbeeldtestprogramma dat het voordeel van het prototypepatroon zal tonen. PrototypePatternTest.java

package com.journaldev.design.test;

import java.util.List;

import com.journaldev.design.prototype.Employees;

public class PrototypePatternTest {

	public static void main(String[] args) throws CloneNotSupportedException {
		Employees emps = new Employees();
		emps.loadData();
		
		//Gebruik de clone-methode om het Employee-object te krijgen
		Employees empsNew = (Employees) emps.clone();
		Employees empsNew1 = (Employees) emps.clone();
		List list = empsNew.getEmpList();
		list.add("John");
		List list1 = empsNew1.getEmpList();
		list1.remove("Pankaj");
		
		System.out.println("emps List: "+emps.getEmpList());
		System.out.println("empsNew List: "+list);
		System.out.println("empsNew1 List: "+list1);
	}

}

De uitvoer van het bovenstaande voorbeeldprogramma voor het prototype ontwerppatroon is:

emps List: [Pankaj, Raj, David, Lisa]
empsNew List: [Pankaj, Raj, David, Lisa, John]
empsNew1 List: [Raj, David, Lisa]

Als het klonen van het object niet was voorzien, zouden we telkens een database-oproep moeten doen om de lijst met werknemers op te halen. Vervolgens zouden de manipulaties moeten worden uitgevoerd die veel middelen en tijd zouden kosten. Dat is alles voor het prototype ontwerppatroon in Java.