Patrones de Diseño Creacionales Parte 2

3. Factory Method: Es un patrón de diseño que define una interfaz para crear un objeto, pero deja que sean las subclases quienes decidan qué clase instanciar. Permite que una clase delegue en sus subclases la creación de objetos. El patrón Factory Method permite escrbir aplicaciones que son más flexibles respecto de los tipos a utilizar difiriendo la creación de las instancias en el sistema a subclases que pueden ser extendidas a medida que evoluciona el sistema. Permite también encapsular el conocimiento referente a la creación de objetos. Factory Method hace también que el diseño sea más adaptable a cambio de sólo un poco más  de complejidad. Se facilita futuras ampliaciones, se gana en flexibilidad.

Diagrama UML.

Ejemplo: Calcular el pago de electricidad.

Crear una clase abstracta de Plan.

1. import java.io.*;      
2. abstract class Plan{  
3.          protected double rate;  
4.          abstract void getRate();  
5.    
6.          public void calculateBill(int units){  
7.               System.out.println(units*rate);  
8.           }  
9. }//end of Plan class. 

 Crear las clases concretas que hereda la clase abstracta Plan.

1. class  DomesticPlan extends Plan{  
2.         //@override  
3.          public void getRate(){  
4.              rate=3.50;              
5.         }  
6.    }//end of DomesticPlan class.

1. class  CommercialPlan extends Plan{  
2.    //@override   
3.     public void getRate(){   
4.         rate=7.50;  
5.    }   
6. //end of CommercialPlan class

1. class  InstitutionalPlan extends Plan{
2.   //@override 
3. public void getRate(){   
4.         rate=5.50;  
5.    }   
6. // end of InstitutionalPlan class.

Crear una clase GetPlanFactory a generar objetos de las clases concretas basada en información dada.

1. class GetPlanFactory{ 
2. 
   
3. 
    //use getPlan method to get object of type Plan
4.  
5. public Plan getPlan(String planType){  
6.             if(planType == null){  
7.              return null;  
8.             }  
9.               
10.             if(planType.equalsIgnoreCase("DOMESTICPLAN")) {  
11.                  return new DomesticPlan();  
12.                }   
13.            else if(planType.equalsIgnoreCase("COMMERCIALPLAN")){  
14.                 return new CommercialPlan();  
15.             }   
16.           else if(planType.equalsIgnoreCase("INSTITUTIONALPLAN")) {  
17.                 return new InstitutionalPlan();  
18.           }
19.           
20.            return null;  
21.      }  
22.    }//end of GetPlanFactory class            

Generar las clase pago para usar el GetPlanFactory a obtener el objeto de clases concreta para pasar una información tal como tipo de DOMESTICPLAN or COMMERCIALPLAN or INSTITUTIONALPLAN.

1. import java.io.*; 
2.    
3. class GenerateBill{  
4.     public static void main(String args[])throws IOException{  
5.       GetPlanFactory planFactory = new GetPlanFactory();  
6.         
7.       System.out.print("Enter the name of plan for which the bill will be generated: ");  
8.       BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
9.  
10.      String planName=br.readLine();  
         System.out.print("Enter the number of units for bill will be calculated: ");  
         int units=Integer.parseInt(br.readLine());  
      
          Plan p = planFactory.getPlan(planName);  
          //call getRate() method and calculateBill()method of DomesticPaln.  
      
           System.out.print("Bill amount for "+planName+" of  "+units+" units is: ");  
           p.getRate();  
           p.calculateBill(units);  
                }  
        }//end of GenerateBill class.
    

4. Prototype: es un patrón de diseño creacional en el que los objetos se crean a partir de un instancia prototípica, que es clonada  para dar lugar a nuevos objetos y se usa para evitar las subclases de un objeto creador como hace el patrón AbstractFactory y para evitar el costo inherente a la creación de de un objeto nuevo mediante el operador new cuando esto es demasiado costoso para la aplicación. Para implementar este patrón, se decalara una clase abstracta que tiene un método clone(). Cualquier clase que necesite un constructor deriva de la clase abstracta e implementa el método clone.

Diagrama UML

 
Ejemplo

Juan queire comprar una bicicleta de color rojo y de rodado 22, pero luego cuando llega al lugar y la ve desea ver la bicicleta de color negra y que sea rodado 30.

  
Bicicleta

package ar.com.patronesdisenio.prototype;
/**
  * @author nconde
 */
public abstract class Bicicleta implements Cloneable {
 
 private String color;
 private String rodado;

 /**
  * Metodo clonador
  */
 public Bicicleta clone() throws CloneNotSupportedException {
  return (Bicicleta) super.clone();
 }
 
 public abstract String verBicleta();

    //Getters and Setters
 public String getColor() {
  return color;
 }

 public void setColor(String color) {
  this.color = color;
 }

 public String getRodado() {
  return rodado;
 }

 public void setRodado(String rodado) {
  this.rodado = rodado;
 }

}

BicicletaModificada

package ar.com.patronesdisenio.prototype.impl;

import ar.com.patronesdisenio.prototype.Bicicleta;

/**
  * @author usuario
 */
public class BicicletaModificada extends Bicicleta {

 @Override
 public String verBicleta() {
 
  return "Este es el color: " + this.getColor() + " El rodado es: " + this.getRodado();
 }


}

Cliente

package ar.com.patronesdisenio.prototype.impl;
import ar.com.patronesdisenio.prototype.Bicicleta;

/**
 * * @author usuario
 *
 */
public class Cliente {

 /**
  * @param args
  * @throws CloneNotSupportedException 
  */
 public static void main(String[] args) throws CloneNotSupportedException {
  Bicicleta bc = new BicicletaModificada();
  bc.setColor("Roja");
  bc.setRodado("22");
  System.out.println(bc.verBicleta());
  
  Bicicleta bc2 = bc.clone();
  bc2.setColor("Negro");
  bc2.setRodado("30");
  
  System.out.println(bc2.verBicleta());
  
 }
}

Todas las clases en java en Java heredan un método de la clase Object llamado clone. Un metodo clone de un objeto retorna una copia de ese objeto. Esto solamente se hace para instancias de clases  que dan permiso para que su instancia se clonada si, y solo si, ella implementa el interface  Cloneable, en el caso que la no clase no tenga permisos para se clonada lanzara una excepción CloneNotSupportedException.