Vamos de a poco. En primer lugar, cada patron tiene su intención. ¿Que quiero decir con esto? Que tiene una función, algo para lo que sirve, y de ahí su nombre.
Seguro habrás notado que todos los patrones son iguales :P. Una superclase o interfaz con muchas subclases y un tercer objeto que usa todas esas implementaciones polimorficamente. Bueno, con ese criterio son todos stategies :P.
El factory method es un método fábrica :). Sirve para construir cosas. Para encapsular la construccion de un objeto en un método, olvidándote de su implementación interna, y de la clase concreta de ese objeto.
Por ejemplo, si tenemos un pedido, que puede ser mayorista o minorista (para lo que optamos por un strategy), podriamos encapsular la construccion de esos strategies en factory methods. Por ejemplo:
//TipoPedido es la clase abstracta del strategy, que contiene los factory //methods getMayorista y getMinorista();
Código:
public class Pedido{
TipoPedido tipoPedido;
Collection<Producto> productos;
public void setMayorista(){
this.tipoPedido = TipoPedido.getMayorista();
}
public void setMinorista(){
this.tipoPedido = TipoPedido.getMinorista();
}
}
Código:
public class TipoPedido{
//Cosas...
/**
* Factory method
*
**/
public TipoPedido getMayorista(){
return new PedidoMayorista();
}
/**
* Factory method
*
**/
public TipoPedido getMinorista(){
return new PedidoMinorista();
}
//Mas cosas...
}
El factory method esta bueno cuando los patrones Abstract Factory o Builder quedan "grandes" y complican mas de lo que ayudan.
----------------------------------------------------------------------------------------------------
El prototype es más raro de usar... Basicamente se crea un objeto clonándolo de otro. Seria de utilidad cuando tienes que duplicar algo, por ejemplo... Si haces una factura, con productos, seria razonable que en el historial quede el precio original del producto, por mas que ese precio haya cambiado con el tiempo. En ese caso seria bueno que la factura conozca un clon del producto original en vez de a él.
La clonación ayuda en varios sentidos: El único objeto que crea al clon es el mismo objeto, por lo que el acoplamiento se minimiza. La interfaz para clonarlo es tan simple como decirle clone(). A su vez, ese clon puede delegar en builders, factorys(abstract factories o factory methods) u otros objetos bleh para la creacion.
----------------------------------------------------------------------------------------------------
El decorator no es otra cosa que "decorar a un objeto". Le pones adornos, le agregas cosas. La idea básica es esa, agregarle responsabilidades, pero que el que lo use no se de cuenta. Polimorfismo :).
Un ejemplo podria ser(podria ser, es muy especial el caso del decorator tambien, y podria calzar otro patron aqui... ) decorar a un cliente con el "cliente promocion bleh" y cuando ese cliente compra algo, además de hacer lo que hace siempre, hace algo x la promocion y luego hace lo de siempre. Por ejemplo:
Código:
public class Cliente{
public void comprar(Producto unProducto){
//Hace esas cosas
}
}
public class ClienteConPromocionBleh extends Cliente{
private Cliente cliente;
private PromocionLoca promocion;
public void comprar(Producto unProducto){
promocion.seHaComprado(unProducto);
cliente.comprar(unProducto);
}
}
----------------------------------------------------------------------------------------------------
Espero te sirva :)