Prototype

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa

Prototype, na ciência da computação, é um padrão de projeto de software (design pattern, em inglês) que permite a criação de objetos a partir de um modelo original, ou protótipo.

Estrutura[editar | editar código-fonte]

Diagrama UML da estrutura do padrão Prototype

O padrão Prototype, da forma como foi descrito no livro Design Patterns: Elements of Reusable Object-Oriented Software, contém os seguintes elementos:

  • prototype — uma classe que declara uma interface para objetos capazes de clonar a si mesmo.
  • prototype concreto — implementação de um prototype;
  • cliente — cria um novo objeto através de um prototype que é capaz de clonar a si mesmo.

Efetivamente, cada objeto é, ele próprio, um factory especializado em construir objetos iguais a si mesmo. O padrão Prototype é utilizado freqüentemente em linguagens estaticamente tipadas como C++ e Java, e menos freqüentemente utilizadas em linguagens dinamicamente tipadas como Smalltalk.

O padrão Prototype exige a implementação de uma operação de clonagem em cada uma das classes concretas do protótipo. Esta tarefa pode ser inconveniente, no caso do reaproveitamento de classes pré-existentes que não possuem tal operação, ou mesmo complexa, se for considerada a possibilidade de existirem referências circulares nos atributos de um objeto (um objeto possui um atributo que referência um objeto que, por sua vez, referência o objeto original).

Utilização[editar | editar código-fonte]

O padrão Prototype pode ser utilizado em sistemas que precisam ser independentes da forma como os seus componentes são criados, compostos e representados. O padrão Prototype pode ser útil em sistemas com as seguintes características:

  • sistemas que utilizam classes definidas em tempo de execução;
  • sistemas que utilizam o padrão Abstract Factory para criação de objetos. Neste caso, a hierarquia de classes pode se tornar muito complexa e o padrão Prototype pode ser uma alternativa mais simples, por realizar a mesma tarefa com um número reduzido de classes;
  • sistemas que possuem componentes cujo estado inicial possui poucas variações e onde é conveniente disponibilizar um conjunto pré-estabelecido de protótipos que dão origem aos objetos que compõem o sistema.

Quando utiliza o framework Spring, por exemplo, um desenvolvedor pode configurar um JavaBean como "prototype". Esta configuração faz com que cada uma das referências a um JavaBean aponte para uma instância diferente. O comportamento padrão, ou singleton, define que todas as referências a um JavaBean apontem para a mesma instância de uma classe.[1]

Exemplo[editar | editar código-fonte]

Neste exemplo é mostrado uma hierarquia de classes representando documentos de formato ASCII e PDF que são criados através da classe Cliente. A partir de duas instâncias prototípicas, ascii e pdf, o método criarDocumento cria clones de documentos de acordo com o tipo desejado. A tarefa de realizar a criação da instância é implementada na classe Documento e herdada por suas classes filhas, ASCII e PDF.

Diagrama[editar | editar código-fonte]

Exemplo de Diagrama em UML para o Padrão Prototype.

Código[editar | editar código-fonte]

Este código, escrito na linguagem Java, mostra a implementação do diagrama mostrado acima.

 
 
public interface ICloneable {
        public void clone();
}
 
abstract class Documento implements ICloneable {
 
	protected Documento clone() {
		Object clone = null;
		try {
			clone = super.clone();
		} catch (CloneNotSupportedException ex) {
			ex.printStackTrace();
		}
		return (Documento) clone;
	}
 
}
 
class ASCII extends Documento {
 
}
 
class PDF extends Documento {
 
}
 
class Cliente {
 
	static final int DOCUMENTO_TIPO_ASCII = 0;
 
	static final int DOCUMENTO_TIPO_PDF = 1;
 
	private Documento ascii = new ASCII();
 
	private Documento pdf = new PDF();
 
	public Documento criarDocumento(int tipo) {
		if (tipo==Cliente.DOCUMENTO_TIPO_ASCII) {
			return ascii.clone();
		} else {
			return pdf.clone();
		}
 
	}
}

Observação: Na linguagem Java, a interface Cloneable não possui métodos e é utilizada apenas para indicar que o método Object.clone() pode realizar uma cópia, atributo por atributo, das instâncias de uma classe. [2]

Neste exemplo, a implementação da cópia da instância é delegada ao método clone da super classe Object (A classe raiz da hierarquia de classes da linguagem Java). Se fosse necessário, as classes Documento, ASCII ou PDF implementariam esse método para refletir algum comportamento específico.

Padrões relacionados[editar | editar código-fonte]

Referências

  1. Rod Johnson, Juergen Hoeller, Alef Arendsen, Colin Sampaleanu, Rob Harrop, Thomas Risberg, Darren Davison, Dmitriy Kopylenko, Mark Pollack, Thierry Templier, Erwin Vervaet, Portia Tung, Ben Hale, Adrian Colyer, John Lewis, Costin Leau, Rick Evans. The Spring Framework - Reference Documentation (em Inglês). Página visitada em 13 de junho de 2007.
  2. Sun Microsystems. JavaTM 2 Platform Std. Ed. (em inglês). Página visitada em 13 de junho de 2007.

Bibliografia[editar | editar código-fonte]