Este documento describe el patrón de diseño Factory. Explica que Factory centraliza la creación de objetos, normalmente de una misma familia, y que delega la responsabilidad de crearlos a una clase factoría. Proporciona ejemplos de cómo usar Factory para crear figuras geométricas, vehículos y determinar si estos son eléctricos o de gasolina.

1. PROGRAMACIÓN
ORIENTADA A
OBJETOS
Patrones de diseño

2. Agenda
 Patrones de diseño
 Definición
 Tipos
 MVC
 Antecedentes
 Definiciones
 Patrón de diseño
 Ventajas y Desventajas

3. Patrones de diseño

5. Patrón de diseño: Definición
 Un patrón de diseño:
 es una solución a un problema en un contexto
particular
 es recurrente (lo que hace la solución relevante a
otras situaciones)
 enseña (permite entender cómo adaptarlo a la
variante particular del problema donde se quiere
aplicar)
 tiene un nombre para referirse al patrón
 Los patrones facilitan la reutilización de diseños y
arquitecturas software que han tenido éxito
 están basados en las buenas práctica de POO

6. Patrones de
Creación
Patrones de
Comportamiento
Patrones
estructurales
Patrón de diseño: Tipos

7. Patrón de diseño: Tipos

8. Patrones de
Creación
Patrones de
Comportamiento
Patrones
estructurales
Patrón de diseño: Tipos

9. Patrón de diseño: Tipos
 Patrones de Creación
 Abstraen la forma en la que se crean los objetos,
permitiendo la creación de las clases de forma genérica
dejando para más tarde la decisión de qué clases crear o
cómo crearlas
 Ejemplos
 Factory
 Singleton
 Prototype
 Clasificación
 Patrones de creación de clase: la decisión se toma en los
constructores de las clases y usan la herencia para determinar
la creación de las instancias
 Patrones de creación de objeto: se modifica la clase desde el
objeto

10. Patrones de
Creación
Patrones de
Comportamiento
Patrones
estructurales
Patrón de diseño: Tipos

11. Patrón de diseño: Tipos
 Patrones de Comportamiento
 Estudian las relaciones entre llamadas entre los
diferentes objetos, normalmente ligados con la
dimensión temporal.
 Ejemplos
 Observador
 Estrategia

12. Patrones de
Creación
Patrones de
Comportamiento
Patrones
estructurales
Patrón de diseño: Tipos

13. Patrón de diseño: Tipos
 Patrones Estructurales
 Hacen relación a como las clases y los objetos se
combinan para dar lugar a estructuras más
complejas.
 Ejemplos
 Adapter: Patrones estructurales asociados a clases y
utilizan la herencia.
 Composite, Decorator, Facade: Patrones estructurales
asociados a objetos y utilizan la composición.

14. Patrón de diseño: Singleton
 Un singleton es una clase que tiene una lógica que
solamente le permite instanciarse una vez en un
objeto, es decir, que solamente se podrá llamar a su
constructor una sola vez.
 Es importante para algunas clases tener exactamente
una sola instancia. Por ejemplo:
 Aunque puede haber muchas impresoras en un sistema,
debe haber solo una cola de impresora.
 Deberá haber sólo un sistema de archivos y un manejador
de ventanas.
 Una cuenta de sistema estará dedicada a servir a una
compañía
Patrones
de
Creación

15. Patrón de diseño: Singleton
 Ejemplo
public class Singleton {
/**
*Para permitir la extensión de la clase, el *constructor se define
como protegido.
*/
protected Singleton() {
// ...
}
/**
*Acceso privado al único objeto de la clase
*/
static private Singleton instance = null;
static public Singleton getInstance() {
if(null == instance) {
instance = new Singleton();
}
return instance;
}
Patrones
de
Creación

16. Patrón de diseño: Factory
 Problema
 ¿Quién debe ser el responsable para la creación
de objetos, se desea separar las
responsabilidades de creación para mejorar la
cohesión?
 Solución
 Crear un objeto factoría que maneje la creación
de objetos.
Patrones
de
Creación

17. Patrón de diseño: Factory
 La idea que se esconde detrás de este patrón
es la de centralizar el sitio donde se crean
los objetos, normalmente donde se crean
objetos de una misma "familia", como podría
ser componentes visuales, componentes de la
lógica del negocio, o objetos concurrentes en
el tiempo.
Patrones
de
Creación

18. Patrón de diseño: Factory
 Ejemplo
 Suponiendo la clase base figura para un conjunto de
figuras geométricas:
public abstract class Figura {
int lado = 0
public figura (int lado) {
this.lado = lado;
}
public abstract int getArea ();
public abstract void dibujar (Graphics g, int x, int y);
}
Patrones
de
Creación

19. Patrón de diseño: Factory
public Cuadrado extends Figura{
public Cuadrado (int lado) {
super (lado);
}
public int getArea () {
return (lado x lado);
}
public void dibujar (Graphics g, int x, int y){
g.setColor (Color.black);
g.setDrawRect (x, y, lado, lado);
}
}
public Circulo extends Figura{
public Circulo (int lado) {
super (lado);
}
public int getArea () {
return (Math.PI x lado x lado);
}
public void dibujar (Graphics g, int x, int y){
g.setColor (Color.black);
g.setDrawArc (x, y, lado, lado, 0, 360);
}
}
Clase hija cuadrado Clase hija círculo

20. Patrón de diseño: Factory

Esta factoría funciona recibiendo un argumento que
determina que clase de figura crear:
public class FactoriaDeFiguras {
public static final int CUADRADO = 0
public static final int CIRCULO = 1
public Figura getFigura (int tipo, int lado) {
if (tipo == this.CUADRADO) {
return (new Cuadrado (lado))
}
else {
return (new Circulo (lado))
}
}
}
Patrones
de
Creación
Que figura
crear
Factoría

21. Patrón de diseño: Factory
public abstract class Automovil {
protected String modelo;
protected String color;
protected int potencia;
protected double espacio;
public Automovil(String modelo, String color,
int potencia, double espacio) {
this.modelo = modelo;
this.color = color;
this.potencia = potencia;
this.espacio = espacio;
}
public abstract String
mostrarCaracteristicas();
}
public class AutomovilElectricidad extends
Automovil{
public AutomovilElectricidad(String modelo,
String color, int potencia, double espacio) {
super(modelo, color, potencia, espacio);
}
@Override
public String mostrarCaracteristicas() {
return "Automovil electrico{" + "modelo="
+ modelo + ", color=" + color + ", potencia=" +
potencia + ", espacio=" + espacio + '}';
}
}

22. Patrón de diseño: Factory
public class AutomovilGasolina extends
Automovil{
public AutomovilGasolina(String
modelo, String color, int potencia, double
espacio) {
super(modelo, color, potencia,
espacio);
}
@Override
public String mostrarCaracteristicas() {
return "Automovil gasolina{" +
"modelo=" + modelo + ", color=" + color
+ ", potencia=" + potencia + ", espacio="
+ espacio + '}';
}
}
public abstract class Scooter {
protected String modelo;
protected String color;
protected int potencia;
public Scooter(String modelo, String
color, int potencia) {
this.modelo = modelo;
this.color = color;
this.potencia = potencia;
}
public abstract String
mostrarCaracteristicas();
}

23. Patrón de diseño: Factory
public class ScooterElectricidad extends
Scooter{
public ScooterElectricidad(String
modelo, String color, int potencia) {
super(modelo, color, potencia);
}
@Override
public String mostrarCaracteristicas() {
return "Scooter electrico{" +
"modelo=" + modelo + ", color=" + color
+ ", potencia=" + potencia + '}';
}
}
public class ScooterGasolina extends
Scooter{
public ScooterGasolina(String modelo,
String color, int potencia) {
super(modelo, color, potencia);
}
@Override
public String mostrarCaracteristicas() {
return "Scooter gasolina{" +
"modelo=" + modelo + ", color=" + color
+ ", potencia=" + potencia + '}';
}
}

24. Patrón de diseño: Factory
public interface FabricaVehiculo {
public Automovil crearAutomovil(String modelo, String color,
int potencia, double espacio);
public Scooter crearScooter(String modelo, String color, int
potencia);
}
public class FabricaVehiculoGasolina implements
FabricaVehiculo{
@Override
public Automovil crearAutomovil(String modelo, String color,
int potencia, double espacio){
return new AutomovilGasolina(modelo, color, potencia,
espacio);
}
@Override
public Scooter crearScooter(String modelo, String color, int
potencia){
return new ScooterGasolina(modelo, color, potencia);
}
}
public class FabricaVehiculoElectricidad implements
FabricaVehiculo{
@Override
public Automovil crearAutomovil(String modelo, String color,
int potencia, double espacio){
return new AutomovilElectricidad(modelo, color, potencia,
espacio);
}
@Override
public Scooter crearScooter(String modelo, String color, int
potencia){
return new ScooterElectricidad(modelo, color, potencia);
}
}

25. Patrón de diseño: Factory
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
FabricaVehiculo fabrica;
Automovil [] autos = new Automovil[nAutos];
Scooter [] scooters = new Scooter[nScooters];
System.out.println("Desea utilizar: 1. Vehículos eléctricos 2. Vehículos de gasolina");
String eleccion = reader.next();
if(eleccion.equals("1")){
fabrica = new FabricaVehiculoElectricidad();
}
else{
fabrica = new FabricaVehiculoGasolina();
}
System.out.println("----- Creando Automóviles -----");
for(int i = 0; i < nAutos; i++){
System.out.println("Digite el modelo");
String modelo = reader.next();
System.out.println("Digite el color");
String color = reader.next();
System.out.println("Digite la potencia");
String potencia = reader.next();
System.out.println("Digite el espacio");
String espacio = reader.next();
autos[i] = fabrica.crearAutomovil(modelo, color, Integer.parseInt(potencia),
Integer.parseInt(espacio));
}
System.out.println("----- Creando Scooters -----");
for(int i = 0; i < nScooters; i++){
System.out.println("Digite el modelo");
String modelo = reader.next();
System.out.println("Digite el color");
String color = reader.next();
System.out.println("Digite la potencia");
String potencia = reader.next();
scooters[i] = fabrica.crearScooter(modelo, color, Integer.parseInt(potencia)
}
System.out.println("----- Información Automóviles -----");
for(Automovil auto : autos){
System.out.println(auto.mostrarCaracteristicas());
}
System.out.println("----- Información Scooters -----");
for(Scooter scooter : scooters){
System.out.println(scooter.mostrarCaracteristicas());
}
}