PATRONES DE DISEÑO EN JAVA
En esta serie vamos a hacer un repaso sobre los diferentes patrones de diseños para eso tomare como referencia el libro de Laurent Debrauwer “Patrones de diseño en java”
En la literatura de ingeniería de software se define los patrones como una solución ya probada a un problema en específico
“Un design pattern o patrón de diseño consiste en un diagrama de objetos que forma una solución a un problema conocido y frecuente”
Los patrones que veremos en esta ocasión se dividirán en tres tipos:
Patrones de creación: Este tipo de patrones nos permite la creación de objectos.
Patrones de estructura: Los patrones de estructura permiten facilitan la organización de la estructuras de clases y sus relaciones.
Patrones de comportamiento: Estos proporcionan soluciones para organizar las interacciones y repartir procesamiento entre objectos.
ABSTRACT FACTORY
El objetivo de este patrón de diseño es la creación de objectos agrupados en familias, sin tener que conocer las clase concretas destinada a la creación de objetos.
Supongamos que un concesionario de vehículos, tiene una categorías que son Automóviles, Scooter y dentro de esas dos categorías tendríamos que pueden ser Agasolina o Eléctricos.
Como lo solucionaríamos sin utilizar el patrón:
Lo primero que pensaríamos seria crear cada una de las clases por cada tipo elementos, estas clases la relacionaríamos con una clase catalogo que se encargaría de instanciarlas. Nos quedaría algo como esto:
Ahora vamos replantearnos el problema utilizando el patrón abstract factory los participante en este modelo serian los siguientes:
Fabrica abstracta: Esta seria una interfaz la cual tendría los métodos que crea los diferentes tipos de objectos en este caso los diferentes tipos de vehículos.
Fabrica concreta: Estas son clases que implementan los métodos para cada familia concreta.
Clase abstract: Son a las clases de los vehículos independientes de su familia
Clase cliente: Esta se encargara de utilizar la fábrica abstracta.
PASO UNO
Lo primero que vamos a hacer es crea nuestras clases abstractas, como vimos en los elementos que interactúan en este patrón son clases que son independientes de la familia. Nos basaremos en el diagrama UML y en cada paso vamos añadir los componentes asta lograr el diagrama completo del patrón .
Clase Abstrata Automovil
package abstracts;
public abstract class Automovil {
protected String model;
protected String color;
protected int potencia;
protected double espacio;
public Automovil(String model, String color, int potencia, double espacio) {
this.model = model;
this.color = color;
this.potencia = potencia;
this.espacio = espacio;
}
public abstract void mostrarCarateristicas();
}Clase Automovil Electrico
package vehiculos;
import abstracts.Automovil;
public class AutomovilElectrico extends Automovil {
StringBuffer salida = new StringBuffer();
public AutomovilElectrico(String model, String color, int potencia, double espacio) {
super(model, color, potencia, espacio);
}
@Override
public void mostrarCarateristicas() {
salida.append("Automovil electrico modelo");
salida.append(model);
salida.append("de color");
salida.append(color);
salida.append("de potencia");
salida.append(potencia);
salida.append("de espacio");
salida.append(espacio);
}
}Clase Automovil Gasolina
package vehiculos;
import abstracts.Automovil;
public class AutomovilGasolina extends Automovil {
StringBuffer salida = new StringBuffer();
public AutomovilGasolina(String model, String color, int potencia, double espacio) {
super(model, color, potencia, espacio);
}
@Override
public void mostrarCarateristicas() {
salida.append("Automovil electrico modelo");
salida.append(model);
salida.append("de color");
salida.append(color);
salida.append("de potencia");
salida.append(potencia);
salida.append("de espacio");
salida.append(espacio);
}
}Clase Abstrata Scooter
package abstracts;
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 void mostrarCarateristicas();
}Clase Scooter Electrico
package vehiculos;
import abstracts.Scooter;
public class ScooterElectrica extends Scooter {
StringBuffer salida = new StringBuffer();
public ScooterElectrica(String modelo, String color, int potencia) {
super(modelo, color, potencia);
}
@Override
public void mostrarCarateristicas() {
salida.append("Scooter electrico modelo");
salida.append(modelo);
salida.append("de color");
salida.append(color);
salida.append("de potencia");
salida.append(potencia);
System.out.println(salida);
}
}Clase Scooter Gasolina
package vehiculos;
import abstracts.Scooter;
public class ScooterGasolina extends Scooter {
StringBuffer salida = new StringBuffer();
public ScooterGasolina(String modelo, String color, int potencia) {
super(modelo, color, potencia);
}
@Override
public void mostrarCarateristicas() {
salida.append("Scooter electrico modelo");
salida.append(modelo);
salida.append("de color");
salida.append(color);
salida.append("de potencia");
salida.append(potencia);
System.out.println(salida);
}
}PASO DOS
En este paso vamos a crear la fabrica concreta añadiremos los nuevos componentes a nuestro diagrama.
Interfaz Fabrica Vehiculo
package interfaces;
import abstracts.Automovil;
import abstracts.Scooter;
public interface FabricaVehiculo {
Automovil createAutomovil( String model,String color, int potencia, double espacio);
Scooter createScooter( String model, String color,int potencia);
}Clase concreata Fabrica Vehiculo Electrico
package factorys;
import abstracts.Automovil;
import abstracts.Scooter;
import interfaces.FabricaVehiculo;
import vehiculos.AutomovilElectrico;
import vehiculos.ScooterElectrica;
public class FabricaVehiculosElectricos implements FabricaVehiculo {
@Override
public Automovil createAutomovil(String model, String color, int potencia, double espacio) {
return new AutomovilElectrico( model, color, potencia, espacio);
}
@Override
public Scooter createScooter(String model, String color, int potencia) {
return new ScooterElectrica( model, color, potencia);
}
}Clase concreata Fabrica Vehiculo Gasolina
package factorys;
import abstracts.Automovil;
import abstracts.Scooter;
import interfaces.FabricaVehiculo;
import vehiculos.AutomovilGasolina;
import vehiculos.ScooterGasolina;
public class FabricaVehiculosGasolina implements FabricaVehiculo {
@Override
public Automovil createAutomovil(String model, String color, int potencia, double espacio) {
return new AutomovilGasolina( model, color, potencia,espacio);
}
@Override
public Scooter createScooter(String model, String color, int potencia) {
return new ScooterGasolina( model, color,potencia );
}
}Fabrica vehículo es una interface que tiene una dependencia con la clase scooter y automóvil que son las clases generales de cada uno de los objeto.
Como tenemos diferentes familias de objectos creamos lo que son las dos clases concretas que son FabricaVehiculoElectrico Y FabricaVehiculoGasolina que implementa la interfaz fabrica vehículo e implementamos los métodos para cada uno de los tipos concretos.
Con esto ya casi tenemos listo nuestro diseño utilizando el patrón abstract factory.
PASO TRES
Procedemos utilizarlo para lo cual nuestra clase cliente seria la clase principal de nuestra aplicación. lo que hacemos es crear un objecto en este caso un vehículo de tipo gasolina y como podemos ver utilizamos alguno de sus métodos para crear un vehículo a gasolina o un scooter a gasolina
import factorys.FabricaVehiculosGasolina;
public class Main {
public static void main(String[] args) {
FabricaVehiculosGasolina fabricaVehiculosGasolina = new FabricaVehiculosGasolina();
fabricaVehiculosGasolina.createAutomovil("EF201","Negro",240,4);
}
}En pocas palabras el patrón abstracta Factory nos sirve para crear objectos agrupados en familia hacer nuestra aplicación mas mantenible en el tiempo pueden descargar el código desde este enlace.
