Introducción
El tema que vamos a tratar, es sobre los patrones de diseño en Java, un patrón de diseño es una solución generalizable para un problema específico en el diseño de software. Estos patrones encapsulan las mejores prácticas y experiencias acumuladas a lo largo del tiempo, proporcionando un enfoque estructurado para abordar desafíos comunes. Al emplear patrones de diseño, los desarrolladores pueden sortear obstáculos, mejorar la coherencia y construir sistemas que se adapten a cambios y evolucionen con mayor solidez.
Los patrones de creación juegan un papel esencial al abordar la instanciación de objetos de manera eficiente y estructurada. Dos patrones destacados en este dominio son Singleton y Abstract Factory.
A continuación, se detallan estos patrones junto con ejemplos concretos de su aplicación en Java.
Singleton
El patrón Singleton garantiza que una clase tenga una única instancia y proporciona un punto global de acceso a ella. Este enfoque es útil cuando se desea una única instancia para coordinar acciones en toda la aplicación.
Uso:
public class DataBaseConnectionManager(
//La unica estancia de la clase
private static DatabaseConnectionManager instance;
public ErCenMedidasEmer connect;
// Constructor privado para evitar instanciación directa.
private DatabaseConnectionManager() {
}
// Método para obtener la instancia única.
public static synchronized DatabaseConnectionManager getInstance() {
if (instance == null) {
instance = new DatabaseConnectionManager();
}
return instance;
}
}
public class MyApp {
public static void main(String[] args) {
DatabaseConnectionManager connectionManager = DatabaseConnectionManager.getInstance();
// Ahora, podemos usar connectionManager para gestionar conexiones a la base de datos.
// Por ejemplo:
ErCenMedidasEmer connection = connectionManager.connect;
connection.executeQuery("SELECT * FROM tabla");
}
}En este ejemplo, la clase DatabaseConnectionManager se implementa como un Singleton. El método getInstance() garantiza que solo haya una instancia de la clase en toda la aplicación. Al utilizar esta instancia única, podemos gestionar de manera centralizada las conexiones a la base de datos, evitando la creación innecesaria de múltiples instancias y asegurando la coherencia en la gestión de las conexiones. Este enfoque es especialmente útil en situaciones donde tener múltiples instancias de la clase podría conducir a problemas de sincronización o recursos compartidos.
Abstract Factory
El patrón Abstract Factory proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas. Este patrón es útil cuando se necesita garantizar que los objetos creados sean compatibles entre sí.
Uso:
public class MyApp {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory();
ProductA productA = factory.createProductA();
ProductB productB = factory.createProductB();
}
}
// Interfaz para productos de tipo A
interface ProductA {
void operationA();
}
// Implementación concreta de ProductA
class ConcreteProductA implements ProductA {
@Override
public void operationA() {
System.out.println("Operation A in ConcreteProductA");
}
}
// Interfaz para productos de tipo B
interface ProductB {
void operationB();
}
// Implementación concreta de ProductB
class ConcreteProductB implements ProductB {
@Override
public void operationB() {
System.out.println("Operation B in ConcreteProductB");
}
}
// Interfaz para la fábrica abstracta
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// Implementación concreta de la fábrica abstracta
class ConcreteFactory implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB();
}
}
Estos ejemplos ilustran cómo aplicar los patrones Singleton y Abstract Factory para abordar situaciones específicas en el diseño de software, brindando estructura y eficiencia a la creación de objetos en sus respectivos contextos. La aplicación consciente de estos patrones contribuye a sistemas más flexibles y mantenibles.
Composite
El patrón Composite se utiliza cuando se desea tratar tanto a objetos individuales como a composiciones de objetos de manera uniforme.
Define una jerarquía de objetos, donde los objetos individuales y las composiciones de objetos son tratados de la misma manera. Esto permite a los clientes tratar a los objetos individuales y a las composiciones de objetos de manera uniforme.
Uso:
// Interfaz base para todos los componentes (hojas y compuestos)
interface DocumentComponent {
void display();
}
// Implementación de hoja (leaf) que representa un elemento individual (por ejemplo, texto)
class Text implements DocumentComponent {
private String content;
public Text(String content) {
this.content = content;
}
@Override
public void display() {
System.out.println("Texto: " + content);
}
}
import java.util.ArrayList;
import java.util.List;
// Implementación de compuesto que representa una sección que puede contener otros elementos
class Section implements DocumentComponent {
private List<DocumentComponent> components = new ArrayList<>();
public void addComponent(DocumentComponent component) {
components.add(component);
}
@Override
public void display() {
System.out.println("Sección:");
for (DocumentComponent component : components) {
component.display();
}
}
}
public class DocumentApp {
public static void main(String[] args) {
// Crear componentes individuales (hojas)
DocumentComponent heading = new Text("Título del Documento");
DocumentComponent paragraph1 = new Text("Este es un párrafo.");
// Crear una sección compuesta que contiene componentes individuales y otras secciones
Section section = new Section();
section.addComponent(heading);
section.addComponent(paragraph1);
// Crear otra sección compuesta
Section anotherSection = new Section();
DocumentComponent paragraph2 = new Text("Este es otro párrafo.");
anotherSection.addComponent(paragraph2);
// Agregar la segunda sección a la primera sección
section.addComponent(anotherSection);
// Mostrar el documento completo
section.display();
}
}
En este ejemplo, el patrón Composite permite representar tanto elementos individuales (Text) como composiciones de elementos (Section) de manera uniforme a través de la interfaz común DocumentComponent.
Esto facilita la construcción de estructuras jerárquicas de documentos y su manipulación de manera eficiente. La recursividad del patrón Composite es evidente cuando una sección compuesta puede contener otras secciones, creando así una estructura jerárquica compleja.
Observer
El patrón Observer se utiliza para establecer una relación uno a muchos entre objetos, de modo que cuando un objeto cambia su estado, todos los objetos dependientes son notificados y actualizados automáticamente.
Este patrón es útil en situaciones donde un cambio en un objeto debe provocar cambios en otros objetos sin acoplarlos de manera directa.
Uso:
// Interfaz que define al sujeto (objeto observado)
interface PriceSubject {
void addObserver(PriceObserver observer);
void removeObserver(PriceObserver observer);
void notifyObservers();
}
// Interfaz que define al observador
interface PriceObserver {
void update(float newPrice);
}
import java.util.ArrayList;
import java.util.List;
// Implementación de sujeto que representa un producto con precio cambiante
class Product implements PriceSubject {
private List<PriceObserver> observers = new ArrayList<>();
private float price;
public void setPrice(float newPrice) {
this.price = newPrice;
notifyObservers();
}
@Override
public void addObserver(PriceObserver observer) {
observers.add(observer);
}
@Override
public void removeObserver(PriceObserver observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (PriceObserver observer : observers) {
observer.update(price);
}
}
}
// Implementación de observador que representa un cliente que recibe notificaciones de cambios de precio
class Customer implements PriceObserver {
private String name;
public Customer(String name) {
this.name = name;
}
@Override
public void update(float newPrice) {
System.out.println(name + " recibió una notificación: El nuevo precio es " + newPrice);
}
}
public class ECommerceApp {
public static void main(String[] args) {
// Crear un producto observable
Product product = new Product();
// Crear clientes observadores
PriceObserver customer1 = new Customer("Cliente1");
PriceObserver customer2 = new Customer("Cliente2");
// Registrar clientes como observadores del producto
product.addObserver(customer1);
product.addObserver(customer2);
// Establecer un nuevo precio para el producto (esto notificará a los observadores)
product.setPrice(49.99f);
}
}
Este ejemplo refleja cómo el patrón Observer permite la desacoplación entre el objeto que cambia (en este caso, el producto) y los objetos que reaccionan a esos cambios (los clientes). Los clientes no necesitan conocer los detalles internos del producto; simplemente se registran como observadores y reciben notificaciones cuando algo relevante para ellos (en este caso, el cambio de precio) sucede. Esto promueve un diseño más flexible y mantenible.
Conclusión
Los patrones de diseño en Java, y en el desarrollo de software en general, son herramientas poderosas que permiten a los desarrolladores construir sistemas más sólidos y sostenibles. Siguiendo principios de diseño probados, los patrones proporcionan una guía que lleva a la creación de software robusto, flexible y fácil de mantener a lo largo del ciclo de vida del proyecto.
