Design Patterns
239 pág.

Design Patterns


DisciplinaEngenharia de Software I4.685 materiais52.003 seguidores
Pré-visualização50 páginas
html)
Prototype pattern 59
Prototype pattern
The prototype pattern is a creational design pattern used in software development when the type of objects to
create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used to:
\u2022 avoid subclasses of an object creator in the client application, like the abstract factory pattern does.
\u2022 avoid the inherent cost of creating a new object in the standard way (e.g., using the 'new' keyword) when it is
prohibitively expensive for a given application.
To implement the pattern, declare an abstract base class that specifies a pure virtual clone() method. Any class that
needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone()
operation.
The client, instead of writing code that invokes the "new" operator on a hard-coded class name, calls the clone()
method on the prototype, calls a factory method with a parameter designating the particular concrete derived class
desired, or invokes the clone() method through some mechanism provided by another design pattern.
Structure
UML class diagram describing the Prototype design pattern
Example
The Prototype pattern specifies the kind of objects to create using a prototypical instance. Prototypes of new
products are often built prior to full production, but in this example, the prototype is passive and does not participate
in copying itself. The mitotic division of a cell - resulting in two identical cells - is an example of a prototype that
plays an active role in copying itself and thus, demonstrates the Prototype pattern. When a cell splits, two cells of
identical genotype result. In other words, the cell clones itself.[1]
Java
/**
 * Prototype class
 */
abstract class Prototype implements Cloneable {
 @Override
Prototype pattern 60
 public Prototype clone() throws CloneNotSupportedException {
 return (Prototype)super.clone();
 }
 
 public abstract void setX(int x);
 
 public abstract void printX();
 
 public abstract int getX();
}
/**
 * Implementation of prototype class
 */
class PrototypeImpl extends Prototype {
 int x;
 
 public PrototypeImpl(int x) {
 this.x = x;
 }
 
 public void setX(int x) {
 this.x = x;
 }
 
 public void printX() {
 System.out.println("Value :" + x);
 }
 
 public int getX() {
 return x;
 }
}
/**
 * Client code
 */
public class PrototypeTest {
 public static void main(String args[]) throws 
CloneNotSupportedException {
 Prototype prototype = new PrototypeImpl(1000);
 
 for (int i = 1; i < 10; i++) {
 Prototype tempotype = prototype.clone();
 
 // Usage of values in prototype to derive a new 
value.
Prototype pattern 61
 tempotype.setX( tempotype.getX() * i);
 tempotype.printX();
 }
 }
}
/*
**Code output**
Value :1000
Value :2000
Value :3000
Value :4000
Value :5000
Value :6000
Value :7000
Value :8000
Value :9000
*/
C#
//Note: In this example ICloneable interface (defined in .Net 
Framework) acts as Prototype
class ConcretePrototype : ICloneable
{
 public int X { get; set; }
 public ConcretePrototype(int x)
 {
 this.X = x;
 }
 public void PrintX()
 {
 Console.WriteLine(&quot;Value :&quot; + X);
 }
 public object Clone()
 {
 return this.MemberwiseClone();
 }
}
/**
* Client code
*/
Prototype pattern 62
public class PrototypeTest
{
 public static void Main()
 {
 var prototype = new ConcretePrototype(1000);
 for (int i = 1; i < 10; i++)
 {
 ConcretePrototype tempotype = prototype.Clone() as 
ConcretePrototype;
 // Usage of values in prototype to derive a new value.
 tempotype.X *= i;
 tempotype.PrintX();
 }
 Console.ReadKey();
 }
}
/*
**Code output**
Value :1000
Value :2000
Value :3000
Value :4000
Value :5000
Value :6000
Value :7000
Value :8000
Value :9000
*/
PHP
<?php
class ConcretePrototype
{
 private $x;
 
 public function __construct($p_valueX)
 {
 $this->x = (int) $p_valueX;
 }
 
 public function printX()
 {
 print sprintf('Value: %5d' . PHP_EOL, $this->x);
Prototype pattern 63
 }
 
 public function setX($p_valueX)
 {
 $this->x *= (int) $p_valueX;
 }
 public function __clone()
 {
 /*
 * This method is not required for cloning, although when 
implemented,
 * PHP will trigger it after the process in order to permit you 
some
 * change in the cloned object.
 *
 * Reference: http://php.net/manual/en/language.oop5.cloning.php
 */
 // $this->x = 1;
 }
}
/**
* Client code
*/
$prototype = new ConcretePrototype(1000);
 
foreach (range(1, 10) as $i) {
 $tempotype = clone $prototype;
 $tempotype->setX($i);
 $tempotype->printX();
}
/*
**Code output**
Value: 1000
Value: 2000
Value: 3000
Value: 4000
Value: 5000
Value: 6000
Value: 7000
Value: 8000
Value: 9000
Value: 10000
*/
Prototype pattern 64
Rules of thumb
Sometimes creational patterns overlap - there are cases when either Prototype or Abstract Factory would be
appropriate. At other times they complement each other: Abstract Factory might store a set of Prototypes from which
to clone and return product objects (GoF, p126). Abstract Factory, Builder, and Prototype can use Singleton in their
implementations. (GoF, p81, 134). Abstract Factory classes are often implemented with Factory Methods (creation
through inheritance), but they can be implemented using Prototype (creation through delegation). (GoF, p95)
Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and
evolve toward Abstract Factory, Prototype, or Builder (more flexible, more complex) as the designer discovers
where more flexibility is needed. (GoF, p136)
Prototype doesn't require subclassing, but it does require an &quot;initialize&quot; operation. Factory Method requires
subclassing, but doesn't require initialization. (GoF, p116)
Designs that make heavy use of the Composite and Decorator patterns often can benefit from Prototype as well.
(GoF, p126)
The rule of thumb could be that you would need to clone() an Object when you want to create another Object at
runtime which is a true copy of the Object you are cloning. True copy means all the attributes of the newly created
Object should be the same as the Object you are cloning. If you could have instantiated the class by using new
instead, you would get an Object with all attributes as their initial values. For example, if you are designing a system
for performing bank account transactions, then you would want to make a copy of the Object which holds your
account information, perform transactions on it, and then replace the original Object with the modified one. In such
cases, you would want to use clone() instead of new.
References
[1][1] Michael Duell, &quot;Non-software examples of software design patterns&quot;, Object Magazine, Jul 97, p. 54
\u2022 Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994). Design Patterns: Elements of Reusable
Object-Oriented Software.