Definição
O padrão Prototype é basicamente a criação de novas instâncias através da clonagem de instâncias existentes. Ao criar um prototype, novos objetos são criados copiando este prototype.
Quando usar
• Quando um sistema precisa ser independente de como seus objetos são criados,compostos e representados.
• Quando a adição e remoção de objetos em tempo de execução.
• Ao especificar novos objetos, alterando uma estrutura de objetos existentes.
• Quando configurar uma aplicação dinamicamente com classes.
• Ao manter um número mínimo de classes em um sistema.
• Quando a população do Estado é um processo caro e exclusivo.
Benefícios
• Redução da subclasse.
Desvantagens / consequências
Cada subclasse de prototype deve implementar a operação Clone. Poderia ser
difícil para as classes existentes, para os objetos internos de referências circulares ou que não suportam a cópia.
Estrurura
Você pode usar um PrototypeManager para manter o controle sobre os diferentes tipos de prototypes. O PrototypeManager mantém uma lista dos tipos de clones e suas chaves.
Exemplo
import java.util.Hashtable;
public class PrototypeExample {
Hashtable<String, Product> productMap =
new Hashtable<String, Product>();
public Product getProduct(String productCode) {
Product cachedProduct= (Product)productMap.get(productCode);
return (Product)cachedProduct.clone();
}
public void loadCache() {
// Declarada uma interface para a própria clonagem.
/ / ProductMap.put produto (ProductKey, produto);
/ / Para exemplificação, nós adicionamos apenas dois produtos
/ / ProductMap.put produto (ProductKey, produto);
/ / Para exemplificação, nós adicionamos apenas dois produtos
Book b1 = new Book();
b1.setDescription("Oliver Twist");
b1.setSKU("B1");
b1.setNumberOfPages(100);
productMap.put(b1.getSKU(), b1);
DVD d1 = new DVD();
d1.setDescription("Superman");
d1.setSKU("D1");
d1.setDuration(180);
productMap.put(d1.getSKU(), d1);
}
public static void main(String[] args) {
PrototypeExample pe = new PrototypeExample();
pe.loadCache();
Book clonedBook = (Book)pe.getProduct("B1");
System.out.println("SKU = " + clonedBook.getSKU());
System.out.println("SKU = " + clonedBook.getDescription());
System.out.println("SKU = " + clonedBook.getNumberOfPages());
DVD clonedDVD = (DVD)pe.getProduct("D1");
System.out.println("SKU = " + clonedDVD.getSKU());
System.out.println("SKU = " + clonedDVD.getDescription());
System.out.println("SKU = " + clonedDVD.getDuration());
}
}
/** Classe Prototype * */
public abstract class Product implements Cloneable {
private String SKU;
private String description;
public Object clone() {
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
public String getDescription() {
return description;
}
public String getSKU() {
return SKU;
}
public void setDescription(String string) {
description = string;
}
public void setSKU(String string) {
SKU = string;
}
}
/** Concrete Prototypes para clone * */
public class Book extends Product {
private int numberOfPages;
public int getNumberOfPages() {
return numberOfPages;
}
public void setNumberOfPages(int i) {
numberOfPages = i;
}
}
/** Concrete Prototypes to clone * */
public class DVD extends Product {
private int duration;
public int getDuration() {
return duration;
}
public void setDuration(int i) {
duration = i;
}
}
Quando PrototypeExample é executado o resultado é:
SKU B1 =
SKU Oliver Twist =
SKU = 100
SKU D1 =
SKU Superman =
SKU = 180
SKU B1 =
SKU Oliver Twist =
SKU = 100
SKU D1 =
SKU Superman =
SKU = 180
Exemplo de uso
Se você está projetando um sistema para realizar transações de contas bancárias, e em seguida, você gostaria de fazer uma cópia do objeto que detém as informações da sua conta, e realizar transações nele, substituindo o objeto original com o modificado. Nesses casos, você iria querer usar o clone().
Nenhum comentário:
Postar um comentário