Tema 6: Patrones de Diseño Diseño Software (614G01027

Tema 6: Patrones de DisenoDiseno Software (614G01027)

Eduardo Mosqueira Rey (Coordinador)David Alonso Rıos

Departamento de Computacion, Facultad de Informatica

Introduccion a los Patrones de DisenoPatrones Elementales

Disenos Adaptables a los CambiosPatrones y Colecciones de Objetos

Disenos Debilmente AcopladosPatrones Creacionales y Otros Principios

Indice

1 Introduccion a los Patrones de Diseno

2 Patrones Elementales

3 Disenos Adaptables a los Cambios

4 Patrones y Colecciones de Objetos

5 Disenos Debilmente Acoplados

6 Patrones Creacionales y Otros Principios

E. Mosqueira Rey (Coordinador), D. Alonso Rıos Tema 6: Patrones de Diseno 2




DefinicionHistoriaTipos de Patrones

Indice

1 Introduccion a los Patrones de DisenoDefinicionHistoriaTipos de Patrones





6 Patrones Creacionales y Otros PrincipiosE. Mosqueira Rey (Coordinador), D. Alonso Rıos Tema 6: Patrones de Diseno 3





Patrones de diseno






Patrones de diseno

Patrones de disenoSon soluciones efectivas y reusables a problemas tıpicos de diseno

Efectivas, en el sentido de que ya han resuelto el problema conanterioridad satisfactoriamenteReusables, en el sentido de que pueden aplicarse a un abanico deproblemas de diseno en distintas circunstanciasSu objetivo es crear una coleccion de literatura que ayude a resolverproblemas recurrentes encontrados durante el desarrollo del software






Historia

1977 - Christopher AlexanderEl termino patron deriva de los trabajos del arquitecto ChristopherAlexander sobre planificacion urbanıstica y arquitectura deedificaciones. Libro: “A Pattern Language”“Un patron es una regla con tres partes que expresa la relacion entreun determinado contexto, un problema y una solucion”

1987 – Ward Cunningham y Kent BeckDecidieron aplicar algunas de las ideas de Alexander para desarrollarun pequeno lenguaje compuesto por cinco patrones que sirviera deguıa para los desarrolladores novatos de Smalltalk.OOPSLA’87: “Using Pattern Languages for Object-OrientedPrograms”






Historia

1991 – Jim CoplienPublico: “Advanced C++ Programming Styles and Idioms” un librode patrones de programacion en C++

1995 – Gang of Four (GoF)Publicado por Erich Gamma, Richard Helm, Ralph Johnson y JohnVlissides, conocidos habitualmente como la banda de los cuatro(Gang of Four) o simplemente GoFEs la principal referencia sobre patrones de diseno y uno de los librosmas completos sobre el temaNo es un libro introductorio, sino avanzado. Los ejemplos estan enC++ y los diagramas en notacion OMT (bastante parecida al UML)






Tipos de patrones segun el nivel conceptualPatrones arquitectonicos

Expresa una organizacion estructural fundamental del softwareProvee de un conjunto de subsistemas predefinidos especificando susresponsabilidades y relacionesEjemplo: Modelo-Vista-Controlador

Patrones de disenoProvee un esquema para refinar los subsistemas o componentes deun sistema software, y las relaciones existentes entre ellosResuelven un problema general de diseno dentro de un contextoparticular.Ejemplo: La comunicacion entre el modelo y la vista se hace a travesdel patron Observador

IdiomasDescribe como implementar aspectos particulares de componentesutilizando las caracterısticas de un determinado lenguaje.Ejemplo: El patron Observador se implementa en Java haciendo usode las clases Observer y Observable






Antipatrones

AntipatronesSi los patrones representan practicas correctas existen tambien losantipatrones, que representan lecciones aprendidas en el desarrollo delsoftware

Describen una mala solucion a un determinado problema que nosconduce a una mala situacionEs util ya que nos permite identificar las malas soluciones a tiempo ynos permite apartarnos de ese camino y seguir el camino marcadopor los patrones apropiados para resolver el problemaEjemplo, Antipatron “Clase Dios”: Ocurre cuando casi todo elprocesamiento es monopolizado por una unica clase, actuando lasotras clases como meros repositorios de datos ⇒ Incumpliendo elPrincipio de Responsabilidad Unica






Tipos de patrones de diseno

Patrones creacionalesTratan sobre como crear instancias de objetos y sobre como hacer losprogramas mas flexibles y generales abstrayendo el proceso decreacion de instanciasEjemplo: Instancia Unica, Metodo Factorıa, etc.

Patrones estructuralesDescriben como las clases y los objetos pueden ser combinados paraformar estructuras mayoresEjemplo: Composicion, Adaptador, etc.

Patrones de comportamientoSon patrones que tratan de forma mas especıfica con aspectosrelacionados con la comunicacion entre objetosEjemplo: Estrategia, Observador, etc.





Principio “Favorece la Inmutabilidad”Patron InmutablePatron Instancia Unica

Indice


2 Patrones ElementalesPrincipio “Favorece la Inmutabilidad”Patron InmutablePatron Instancia Unica









Principio “Favorece la inmutabilidad”

Principio “Favorece la inmutabilidad”Debe tenderse a crear clases inmutables siempre que sea posible (unaclase inmutable es aquella en la que, una vez creada una instancia dedicha clase no puede modificarse)

Ventajas:Son objetos simples ya que no pueden cambiar de estado. Paraasegurar que las invariantes se cumplen solo hay que realizar losconstructores correctamente (ej. el radio del cırculo no puede sernegativo)Pueden compartirse abiertamente sin temor a modificaciones:comparar String (inmutable) con Date (mutable)No requieren sincronizacion al usarse en varios hilos de ejecucion deforma concurrenteSirven de bloques de construccion para objetos mas complejos






Patron Inmutable

Patron InmutableSe encarga de disenar clases que permiten crear cualquier numero deinstancias pero no permite la posterior modificacion de estas instancias

Elementos: Simplemente una clase que ha tomado precaucionespara evitar que pueda cambiarse su estadoEste patron no aparece incluido en el libro GoF, aunque sı en otroslibros de patrones como el de Grand






Reglas para hacer una clase inmutable1 No incluir metodos que modifiquen el estado del objeto

Conocidos como metodos de escritura o mutadores (set...)2 Asegurarse de que los metodos no pueden ser sobrescritos

De esa forma evitaremos que subclases descuidadas o directamentemaliciosas comprometan el comportamiento inmutableLa forma mas facil de hacerlo es definiendo la clase como final

3 Declarar todos los atributos como finalNos fuerza a darle un valor a dichos atributos en el constructor y aque dicho valor no pueda ser modificado (blank finals)

4 Declarar todos los atributos como privadosEvitando que puedan ser modificados directamente y encapsulando laestructura interna del objeto inmutable

5 Evitar el acceso a componentes internos mutablesSi la clase tiene atributos que son objetos mutables entonces hay queasegurarse que ningun cliente de la clase pueda obtener referencias aestos objetos (evitando inicializar estos objetos con referenciasobtenidas del cliente, haciendo copias defensivas, etc.)






Patron Inmutable

Clase Punto inmutable

public final class Punto {private final int x;private final int y;

public Punto(int x, int y) {this.x = x;this.y = y;

}

public int getX() {return x;

}

public int getY() {return y;

}

public Punto mover(int x, int y) {return new Punto(this.x + x, this.y + y);

}}

Clase definida como final

Atributos privados y finalesinicializados en el constructor

Metodos de lectura queno devuelven referen-

cias a objetos mutables

Metodos que “simulan” alterarel estado del objeto pero que

en realidad devuelven unanueva instancia de dicho objeto






Patron Inmutable

InconvenienteUna clase inmutable requiere un objeto distinto por cada posible valorSi es necesario crear muchos de estos valores (por ejemplooperaciones que se llevan a cabo en un bucle) la penalizacion en elrendimiento puede ser considerable.

SolucionDefinir clases mutables asociadas a clases inmutables y que puedanutilizarse para realizar las operaciones que resultan costosas en lasclases inmutablesEstas clases sı permiten cambios en el estado en aquellas operacionesen las que la clase inmutable simulaba alterar el estado del objetoTambien incluyen metodos para crear un objeto mutable a partir desu equivalente inmutable y viceversa






Patron Inmutable

Clase PuntoMutable

public class PuntoMutable {private int x;private int y;public int getX() { return x; }public int getY() { return y; }

public PuntoMutable(int x, int y) {this.x = x;this.y = y;

}public PuntoMutable mover(int x, int y) {

this.x += x;this.y += y;return this;

}public PuntoMutable(Punto p) {

this(p.getX(), p.getY());}public Punto getInmutable() {

return new Punto(x, y);} } }

La clase no es final

Los atributos son pri-vados pero no finales

El metodo mover sı quemodifica el estado del objeto

Podemos convertir un puntoinmutable en mutable (atraves de un constructor)y viceversa (a traves del

metodo getInmutable)






Patron Inmutable

Utilizacion de la clase asociada mutable

public static void main(String[] args) {// Modificacion realizada directamente sobre el objeto inmutablePunto p1 = new Punto(5, 7);for (int i = 1; i < 1000; i++) {

p1 = p1.mover(1, 2); // Se crean mil instancias de Punto}System.out.println(p1.getX() + " " + p1.getY());

// Modificacion realizada utilizando la clase mutable asociadaPunto p2 = new Punto(5, 7);PuntoMutable pm = new PuntoMutable(p2);for (int i = 1; i < 1000; i++) {

pm = pm.mover(1, 2); // No se crean nuevas instancias}p2 = pm.getInmutable();System.out.println(p2.getX() + " " + p2.getY());

}






Patron Inmutable

Ejemplos en el API de JavaLa clase String es inmutable y tiene a StringBuilder comoclase asociada mutableLas clases envoltorio como Integer o Double son inmutables, lostipos basicos (int, double, etc.) actuarıan como sus asociadosmutablesClases como BigDecimal o BigInteger son inmutables. Existenclases asociadas como MutableBigInteger. Curiosamente estasclases no fueron definidas como final lo que se considera un falloen su inmutabilidadEn general todas las clases que actuan como tipos basicos esrecomendable que sean inmutables, la notable excepcion es Date yes uno de los motivos de que en la version 8 de Java se incluya unnuevo API de fechas






Instancia Unica

Instancia UnicaSe utiliza para asegurarnos que una clase tiene solo una instancia yproporcionar un punto global de acceso a ella

Serıa algo similar al Type Safe Enum visto en el tema 2 perorestringido a una unica instanciaEjemplo: En un sistema pueden existir muchas impresoras pero solopuede existir una instancia del objeto que representa al gestor deimpresion






Elementos del Patron Instancia Unica

Instancia Unica: Clase que tiene un atributo del tipode la propia clase definido como estatico y privado

Un metodo de lecturaestatico nos permite ac-ceder a dicho atributo

El constructor se defineprivado para evitar quese creen mas instancias






Patron Instancia Unica

Clase Singleton (inicializacion temprana)

class Singleton {

private static final Singleton instancia = new Singleton();

private Singleton() { }

public static Singleton getInstancia() {return instancia;

}}

La instancia deSingleton se creaal cargar la clase enla maquina virtual

El codigo es thread-safe, todos los hi-los acceden a lamisma instancia

Tiene la sobrecarga de tener una ins-tancia creada aunque nunca se use






Patron Instancia Unica

Clase SingletonLazy (inicializacion tardıa)

class SingletonLazy {

private static SingletonLazy instancia = null;

private SingletonLazy() { }

public static SingletonLazy getInstancia() {if (instancia == null) {

instancia = new SingletonLazy();}return instancia;

}}

La instancia deSingletonLazy

se inicializa a nullpara evitar crearlasi no es necesario

La instancia secrea la primera

vez que se llamaa getInstancia

Puede ser problematico si usamos varios hilosde ejecucion (podemos crear una version

mas compleja que incluye sincronizaciones)






Problemas con el Patron Instancia Unica (1/3)

Varios autores consideran a los singleton un problema mas que unasolucion. Sugieren que pueden ser utiles en algunos contextos peropor lo general habrıa que evitarlosOfrecen un punto global de acceso a un servicio

Eso nos evita tener que andar pasando la referencia al servicio entredistintas clases. El problema es que crea una variable global, que usanmuchas clases de nuestro sistema y que constituye una dependenciaoculta no visible al analizar los interfaces de las clases y los metodos

Promueven el acoplamiento estrecho entre clasesLas clases que usan el singleton estan fuertemente acopladas a laclase del propio singleton. La alternativa de pasar una referencia a unservicio entre distintas clases permite usar polimorfismo para sustituirdicha clase por otra alternativa







Incumplen el principio de responsabilidad unicaUna clase no deberıa saber que es un singleton y deberıa solocentrarse en sus responsabilidades. Si queremos evitar la creacion deinstancias deberıan usarse otro tipo de patrones como son lasfactorıas

Llevan un estado con ellos que dura tanto como la ejecuciondel programa

Los estados persistentes son enemigos de las pruebas unitarias. Laspruebas unitarias requieren que los tests sean independientes y que elorden en que se ejecuten no afecte al resultado. Valores globales yestaticos como son los singleton pueden crear dependenciasindeseadas en los tests











Principio “Encapsula lo que Varıa”Patron EstrategiaPatron Metodo PlantillaPrincipio de HollywoodPatron Estado

Indice



3 Disenos Adaptables a los CambiosPrincipio “Encapsula lo que Varıa”Patron EstrategiaPatron Metodo PlantillaPrincipio de HollywoodPatron Estado








Principio “Encapsula lo que varıa”

Principio “Encapsula lo que varıa”Identifica los aspectos de tu aplicacion que varıan y separalos de aquellosque permanencen estables

No importa lo bien queeste disenada una aplicacion, con eltiempo una aplicacion debe crecer ycambiar o moriraSeparando las partes susceptibles devariar significa que podemoscambiarlas en el futuro sin afectar aotras partes del codigo






Patron Estrategia

Patron EstrategiaPatron de comportamiento que se utiliza para definir una familia dealgoritmos, encapsularlos y hacerlos intercambiables.






Elementos del Patron Estrategia

Estrategia: Declara unainterfaz comun para todoslos algoritmos soportados

Estrategia concreta: Implemen-ta el algoritmo utilizando el in-terfaz definido en la Estrategia

Contexto:Delega enel objeto Estrategia elcalculo del algoritmo






Ejemplo del Patron Estrategia

Tenemos una clase Vector que representa a un vector de enterosAparte de las operaciones propias de un vector queremos que existala posibilidad de ordenarloAlgoritmos de ordenacion existen muchos, y dependiendo delcontexto podemos requerir uno u otroAplicamos Estrategia para separar la parte que varıa (el algoritmode ordenacion) del contexto (el vector) y permitir cambiardinamicamente de algoritmo de ordenacion






Ejemplo del Patron Estrategia

AlgoritmoOrdenacion:Juega el rol de Estrategia

OrdenacionBurbuja juega elrol de Estrategia concreta

Vector juega el rol de Contexto






Patron Estrategia

Clase Vector (vector de enteros)

public class Vector {private List<Integer> datos = new ArrayList<>();

public Vector() { }

public Vector(int valores) {java.util.Random aleatorio = new java.util.Random();for (int i=0; i<valores; i++)

datos.add(aleatorio.nextInt(100));}public void introduceValor(int valor) {

datos.add(valor);}public void introduceValor(int posicion, int valor) {

datos.set(posicion, valor);}public int obtieneValor(int posicion) { return datos.get(posicion); }public int longitud () { return datos.size(); }// ...

Vector usa un ArrayListpara almacenar los datos

Podemos generarlo vacıoo con datos aleatorios

Usamos delegacionpara los metodos

basicos de Vector






Patron Estrategia


// ...private AlgoritmoOrdenacion algoritmo;

public AlgoritmoOrdenacion getAlgoritmo() {return algoritmo;

}

public void setAlgoritmo(AlgoritmoOrdenacion algoritmo) {this.algoritmo = algoritmo;

}

public void ordenaVector() {algoritmo.ordena(this);

}}

Favorece la composicionsobre la herencia: Vectorencapsula una instancia deAlgoritmoOrdenacion

Vector delega la or-denacion en el objeto

algoritmo pasandose ası mismo como parametro






Patron Estrategia


public interface AlgoritmoOrdenacion {void ordena(Vector vector);

}

public class OrdenacionBurbuja implements AlgoritmoOrdenacion {@Overridepublic void ordena(Vector v) {

int i, j, aux;for (i=0; i < v.longitud()-1; i++)

for (j = 0; j < v.longitud()-i-1; j++)if (v.obtieneValor(j + 1) < v.obtieneValor(j)) {

aux = v.obtieneValor(j + 1);v.introduceValor(j+1, v.obtieneValor(j));v.introduceValor(j, aux);

}}

}

Inversion de la dependencia:Programa sobre interfaces,no sobre implementaciones

Encapsula lo que varıa






Ventajas del Patron Estrategia

VentajasPermite representar de forma sencilla familias de algoritmosfactorizando sus partes comunes en una misma clase padrePodrıa hacerse realizando subclases del contexto, pero mezclarıamosalgoritmo y contexto complicando su comprension y/o modificacionEvita tener que utilizar multiples sentencias condicionales en elcontexto para elegir el algoritmo adecuado

InconvenientesTodos los algoritmos tienen que compartir un mismo interfaz, lo queen ocasiones obliga a pasar datos innecesarios (algun algoritmorequiere menos datos) sobrecargado la comunicacion entre contextoy algoritmoSi hay muchas alternativas se pueden llegar a crear muchos objetos.Algo que puede solucionarse implementando las estrategias comoobjetos sin estado que puedan compartirse entre distintos contextos






Metodo Plantilla

Metodo PlantillaDefine el esqueleto de un algoritmo en una operacion pero difiriendoalguno de los pasos a las subclases

Las subclases pueden cambiar ciertos aspectos del algoritmo, sincambiar su estructura generalDebe su nombre a que utilizarlo es como cubrir una plantilla o unformulario






Elementos del Patron Metodo PlantillaClase abstracta: Implementael metodo plantilla que define

el esqueleto del algoritmoy define las operacionesprimitivas que deberan

implementar las subclases

Clase concreta: Implementalas operaciones primitivas

que definen el compor-tamiento especıfico del

algoritmo para esta subclase






Ejemplo del Patron Metodo Plantilla

ViajeRoma juega el rolde Clase abstracta siendoviajeRoma el metodo

plantilla y dia2 y dia4las operaciones primitivas

RomaAntigua juega el rol deClase concreta implementando

las operaciones primitivas







Clase ViajeRoma (1/2)

public abstract class ViajeRoma {// Metodo plantillapublic final void viajeRoma() {

viajeDeIda();visitarColiseo();dia2(); // Operacion primitivavisitarSanPedro();dia4(); // Operacion primitivavisitarPlazaEspana();viajeDeVuelta();

}

public abstract void dia2();public abstract void dia4();

// ...

El metodo plantilla definela estructura basica de un

viaje a Roma y no se puedesobrescribir (es final)

Alguno de pasos son di-feridos a las subclases







Clase ViajeRoma (2/2)

// ...public void viajeDeIda() {

System.out.println("Viaje de ida...");}

public void visitarColiseo() {System.out.println("Visitando Coliseo");

}

public void visitarSanPedro() {System.out.println("Visitando San Pedro...");

}

public void visitarPlazaEspana() {System.out.println("Visitando Plaza Espana...");

}

public void viajeDeVuelta() {System.out.println("Viaje de vuelta...");

}}

El resto de metodos estanimplementados, aunque pueden

ser sobrescritos por las sub-clases (metodos de enganche)







Clase RomaReligiosa

public class RomaReligiosa extends ViajeRoma {@Overridepublic void dia2() {System.out.println("Visitando el Castillo de Sant’Angelo...");

}

@Overridepublic void dia4() {System.out.println("Visitando la Basilica de San Pablo Extramuros");

}

@Overridepublic void visitarPlazaEspana() {System.out.println("Visitando las iglesias de la Piazza del Popolo");

}}

Implementamos lasoperaciones primitivas

Un metodo de enganche puederedefinirse para darle una

implementacion mas adecuada







Clase RomaAntigua

public class RomaAntigua extends ViajeRoma {

@Overridepublic void dia2() {

System.out.println("Visitando el Foro Romano...");}

@Overridepublic void dia4() {

System.out.println("Visitando el Mercado de Trajano");}

}






Patron Metodo Plantilla vs. Patron Estrategia

SimilitudesSe utilizan para implementar distintos tipos de algoritmos similares

DiferenciasEl patron estrategia utiliza la delegacion (el contexto delega en laestrategia) para escoger entre las distintas variantes de un algoritmo(los algoritmos persiguen el mismo objetivo pero pueden sercompletamente diferentes)El patron metodo plantilla utiliza la herencia para variardeterminadas partes de un algoritmo dado (no se puede variar elesquema general del algoritmo)






Principio de Hollywood

Principio de Hollywood“No nos llame, ya le llamaremos”

El Patron Metodo Plantilla es un buen ejemplo de lo que se conocecomo “El Principio de Hollywood”Consiste en desacoplar elementos de alto nivel y de bajo nivel quepueden trabajar juntosEl elemento de alto nivel mantiene el control y es el encargado dellamar a los elementos de bajo nivel cuando lo considera necesarioUn ejemplo de este principio lo podemos ver en el funcionamiento delos metodos sort del API de colecciones de Java que delegan laparte de comparacion del algoritmo en los metodos compareTo delos propios objetos






Patron Estado

Patron EstadoPatron de comportamiento que permite a un objeto modificar suconducta al cambiar su estado interno






Ejemplo

Estados por los que pasa un libro en la biblioteca






Implementacion con sentencias condicionales

Clase Libro (1/3)

public class Libro {enum Estado {DISPONIBLE, PRESTADO, RESERVADO};Estado estado = DISPONIBLE;List<String> reservas = new ArrayList<>();String lectorActual;boolean unaSemanaReservado = false;// ...

Definimos los estados comoconstantes dentro de Libro

Libro mantendra unareferencia al estado actualası como otras propiedades

(por simplicidad se han obviadometodos de lectura y escritura)







Clase Libro (2/3)

public void solicitarPrestamo(String cliente) {if (estado == DISPONIBLE) {

estado = PRESTADO;lectorActual = cliente;System.out.println("Prestando libro a " + cliente);

} else if (estado == PRESTADO) {reservas.add(cliente);System.out.println("Reserva de " + cliente);

} else if (estado == RESERVADO) {if (cliente.equals(reservas.get(0))) {

estado = PRESTADO;lectorActual = cliente;System.out.println("Prestando libro reservado a " + cliente);reservas.remove(0);

} else {reservas.add(cliente);System.out.println("Nueva reserva de " + cliente);

}}

}

Definimos un metodo porcada operacion sobre el libro

Definimos sentencias condicionales paracada estado en el que puede estar el libro







Clase Libro (3/3)

public void devolver() {if (estado == PRESTADO) {

if (reservas.isEmpty()) {estado = DISPONIBLE;System.out.println("Libro disponible...");

} else {estado = RESERVADO;System.out.println("Libro en reserva de " + reservas.get(0));

}} else if (estado == RESERVADO) {

if (unaSemanaReservado) {reservas.remove(0);unaSemanaReservado = false;System.out.println("Caduca la reserva");if (reservas.isEmpty()) {

estado = DISPONIBLE;System.out.println("Libro disponible...");

} else {System.out.println("Libro reservado a " + reservas.get(0));

}} } }







Ventajas:Es una solucion sencilla y compacta (todo el comportamiento seencapsula en una unica clase)Es la solucion preferida si el numero de estados es pequeno, elnumero de metodos afectados por el estado son pocos y ambos sonestables (no variaran en el futuro)

Inconvenientes:Solucion confusa: demasiadas sentencias condicionales complican sulectura, es complejo saber el funcionamiento de un estado concretoPoco adaptable a cambios: cualquier cambio en los estados ometodos obliga a cambiar la clase Libro incumpliendo principioscomo el Abierto-CerradoPoco cohesiva: Libro tiene demasiadas responsabilidadesentremezcladas (recordemos el Principio de Responsabilidad Unica)Solucion ⇒ Patron Estado






Elementos del Patron Estado

Estado: Clase abstractaque encapsula el

comportamiento de losestados del contexto

Estado concreto: Implementael comportamiento asociadocon un estado del contexto

Contexto: Mantiene una instancia deun estado concreto y delega en ella el

funcionamiento dependiente del estado

¿De que me suenaesta estructura?






Ejemplo del Patron Estado

EstadoLibro juegael rol de Estado

Reservado juega el rolde Estado concreto

Libro juega el rol de Contexto







Clase Libro (Patron Estado)

public class Libro {EstadoLibro estado = Disponible.getInstancia();List<String> reservas = new ArrayList<>();String lectorActual;boolean unaSemanaReservado = false;

public void solicitarPrestamo(String cliente) {estado.solicitarPrestamo(this, cliente);

}public void devolver() {

estado.devolver(this);}

public EstadoLibro getEstado() {return estado;

}public void setEstado(EstadoLibro estado) {

this.estado = estado;}

}

Libro delega el funcionamien-to de solicitarPrestamo

y devolver en el estado

Libro ofrece meto-dos para leer y modi-ficar su estado interno







Clase EstadoLibro

public interface EstadoLibro {void solicitarPrestamo(Libro l, String cliente);void devolver(Libro l);

}

EstadoLibro es un in-terfaz que recoge todoslos metodos que se venafectados por el estado

Libro se pasa a si mismocomo parametro para que losestados puedan manipularlo







Clase Disponible

public class Disponible implements EstadoLibro {private static final Disponible instancia = new Disponible();private Disponible() { }public static Disponible getInstancia() { return instancia; }

@Overridepublic void solicitarPrestamo(Libro l, String cliente) {

l.setEstado(Prestado.getInstancia());l.lectorActual = cliente;System.out.println("Prestando libro a " + cliente);

}

@Overridepublic void devolver(Libro l) {

// Un libro disponible no se puede devolver}

}

Definimos los estados comosingletons para poderlos

compartir entre distintos libros

Cada posible estado se implementa comouna clase implementadora de EstadoLibro







Clase Prestado

public class Prestado implements EstadoLibro {private static final Prestado instancia = new Prestado();private Prestado() { }public static Prestado getInstancia() { return instancia; }

@Overridepublic void solicitarPrestamo(Libro l, String cliente) {

l.reservas.add(cliente);System.out.println("Reserva de " + cliente);

}@Overridepublic void devolver(Libro l) {

if (l.reservas.isEmpty()) {l.estado = Disponible.getInstancia();System.out.println("Libro disponible...");

} else {l.estado = Reservado.getInstancia();System.out.println("Libro en reserva de " + l.reservas.get(0));

}}

}







Secuencia al prestar un libro disponible






Patron Estado

Ventajas del patron estado:Localiza y separa el comportamiento especıfico de cada estadoPermite anadir nuevos estados de forma sencilla, simplementeanadiendo nuevas clasesLas transiciones entre estados y el comportamiento de los mismos esmas claroLos objetos que representan a los estados pueden compartirse,siempre y cuando no incluyan informacion en variables de instancia

Inconveniente:El codigo es menos compacto que la solucion basada en sentenciascondicionales





Patron ComposicionPatron Iterador

Indice




4 Patrones y Colecciones de ObjetosPatron ComposicionPatron Iterador


6 Patrones Creacionales y Otros Principios






Patron Composicion

Patron ComposicionEs un patron estructural que se utiliza para componer objetos enestructuras de arbol que representan jerarquıas todo-parte

Este patron permite tratar uniformemente a los objetos y a lascomposicionesEs un buen ejemplo de utilizacion conjunta de herencia ycomposicion






Elementos del Patron Composicion

Componente: Declara lainterfaz para los obje-tos en la composicion

Composicion: Define elcomportamiento de los

objetos compuestos (puedencontener otros objetos)

Componente concreto:Defineel comportamiento de los

objetos elementales dela composicion (aquellos

que no pueden tener hijos)






Ejemplo del Patron ComposicionSistemaDeFicheros juega elrol de Componente siendotamano() la operacion que

se delega a las subclases

Directorio juega elrol de Composicion

Fichero juega el rol deComponente concreto






Ejemplo del Patron Composicion

Clase SistemaDeFicheros

public abstract class SistemaDeFicheros {private String nombre;

public SistemaDeFicheros(String nombre) {this.nombre = nombre;

}

public String getNombre() {return nombre;

}

public void setNombre(String nombre) {this.nombre = nombre;

}

public abstract int tamano();}







Clase Fichero

public class Fichero extends SistemaDeFicheros {private int numBytes;

public Fichero(String nombre, int bytes) {super(nombre);numBytes = bytes;

}

public void setNumBytes(int numBytes) { this.numBytes = numBytes; }public int getNumBytes() { return numBytes; }

@Overridepublic int tamano() {

return numBytes;}

}Calcular el tamano de un

fichero es simplementedevolver su numero de bytes







Clase Directorio

public class Directorio extends SistemaDeFicheros {private List<SistemaDeFicheros> elementos = new ArrayList<>();

public Directorio(String nombre) { super(nombre); }public void insertar(SistemaDeFicheros sdf) { elementos.add(sdf); }public void eliminar(SistemaDeFicheros sdf) { elementos.remove(sdf); }public SistemaDeFicheros getElemento(int i){ return elementos.get(i);}

@Overridepublic int tamano() {

int suma = 0;for(SistemaDeFicheros sdf : elementos)

suma += sdf.tamano();return suma;

}}

El directorio incluye metodos pa-ra insertar y borrar nuevos elementos

Calcular el tamano de un directorio consisteen sumar el tamano de sus elementos (si

estos son directorios la operacion se repite)






Elementos del Patron Composicion Compleja

ComposicionAbstracta: Clase comun a todaslas composiciones que define el comporta-

miento basico de anadir/eliminar componentes

ComposicionConcreta:Ahora puede haber varios

tipos de composiciones

Componente concreto:Tambien puede

haber varios tiposde componentes






Ejemplo del Patron Composicion Compleja






Patron Composicion

Ventajas:Permite tratar a los objetos basicos y a los objetos compuestos demanera uniforme, facilitando la introduccion de nuevos componentes

Inconvenientes:Si queremos restringir que componentes concretos pueden ir en unadeterminada composicion es necesario anadir comprobaciones entiempo de ejecucion






Patron Composicion

Operaciones para insertar hijos en una composicionLo normal serıa situarlas en la clase Composicion (que es dondetienen sentido) ⇒ obligarıa a saber que nuestro Componente esuna ComposicionPodrıamos subir estas operaciones a Componente para tratar a losobjetos ComponenteConcreto y Composicion de formagenerica ⇒ puede llevar a situaciones problematicas al tratar deanadir componentes a los componentes concretosSe trata de un equilibrio entre la seguridad de tener los metodos enel sitio correcto de la jerarquıa y la transparencia que permitetrabajar con composiciones y componentes concretos sin saberrealmente con cual estamos trabajando






Patron Iterador

Patron IteradorProporciona un modo de acceder secuencialmente a los elementos de unobjeto agregado (coleccion de objetos) sin exponer su representacioninterna






Elementos del Patron IteradorAgregado: Define una interfazpara crear un objeto Iterador

Agregado concreto: Representaal objeto agregado que man-

tiene una coleccion de objetosy que puede crear iteradores

Iterador: Define una in-terfaz para recorrer los

elementos y acceder a ellos

Iterador concreto: Imple-menta el interfaz Iterador y

permite el recorrido del objetoagregado manteniendo laposicion actual del mismo






Ejemplo del Patron IteradorEl Patron Iterador en Java

Interfaz Iterable juega el rol de Agregado y define un metodoiterator que devuelve una instancia del iteradorInterfaz Iterator juega el rol de iterador y define tres metodos:

hasNext(): boolean: Indica si aun quedan elementos por recorrer(equivale a heTerminado())next(): Object: Devuelve siguiente elemento en la iteracion (serıauna combinacion de inicio(), siguiente() e itemActual())remove(): Elimina de la coleccion el ultimo elemento devuelto porel iterador (desde Java 8 tiene una implementacion por defecto quelanza una excepcion y no es obligatorio sobrescribirlo)






Ejemplo del Patron Iterador

Pila representa una pila de enteros yjuega el rol de Agregado concreto,

la coleccion que queremos iterar

Iterador pila juega el rol deIterador concreto recorriendo

la pila de forma secuencial







Clase Pila

public class Pila implements Iterable {private int[] datos;private int cima = -1;

public Pila(int maxValores) { datos = new int[maxValores]; }public void push(int valor) { datos[++cima] = valor; }public int peek() { return datos[cima]; }public int pop() { return datos[cima--]; }

@Overridepublic Iterator iterator() {

return new IteradorPila(datos, cima);}

}

Planteamos una pila sencillasin preocuparnos de las

posibles excepciones (sacarde una pila vacıa, etc.)

Lo habitual es pasar el objeto actual comoparametro al constructor del iterador, comoel interfaz de la pila solo permite acceder ala cima debemos pasar su estructura interna







Clase IteradorPila

class IteradorPila implements Iterator {private final int[] datos;private int cursor = 0; // Proxima posicion a leerprivate int cima; // Posicion de la cima

public IteradorPila(int[] datos, int cima) {this.datos = datos;this.cima = cima;

}

@Overridepublic boolean hasNext() { return cursor <= cima; }

@Overridepublic Object next() { return datos[cursor++]; }

@Overridepublic void remove() { throw new UnsupportedOperationException(); }

}

El iterador reci-be la estructura

interna de la pila

Y la recorre usando los metodos de Iterator






Iteradores como clases internas

El hecho de que el iterador de la pila sea una clase distinta de la pilaes una ventaja: las responsabilidades estan separadas de forma masclara, podemos tener varios iteradores recorriendo la estructura deforma simultanea, etc.El problema viene porque el interfaz de la pila no permite surecorrido secuencial, por lo que debemos pasar su estructura internacomo parametro al iteradorSolucion ⇒ Definir el iterador como una clase interna de Pila

Una instancia de una clase interna esta asociada a una instancia desu clase contenedoraAdemas tendra acceso a todos los elementos de la clase contenedora(incluso los privados)







Clase IteradorPila como clase interna de Pila

public class Pila implements Iterable {private int[] datos;private int cima = -1;public Pila(int maxValores) { datos = new int[maxValores]; }public void push(int valor) { datos[++cima] = valor; }public int peek() { return datos[cima]; }public int pop() { return datos[cima--]; }@Overridepublic Iterator iterator(){ return new IterablePila(); }class IterablePila implements Iterator {

private int cursor = 0;@Overridepublic boolean hasNext() { return cursor <= cima; }@Overridepublic Object next() { return datos[cursor++]; }@Overridepublic void remove() { throw new UnsupportedOperationException();}

}}

IterablePila es unaclase interna de Pila yaccede directamente asus elementos privados







Representacion en UMLde una clase interna







Java basa el funcionamiento delbucle for-each en las clasesIterable e IteratorCualquier clase como Pila queimplemente Iterable puede serrecorrida mediante un buclefor-each

Bucles for-each e iteradores

public static void main(String[] args) {Pila p = new Pila(10);p.push(2);p.push(4);p.push(6);p.push(8);for (Object o : p) {

System.out.print(o + " ");} // Imprime 2 4 6 8

}






Patron Iterador

VentajasSe puede acceder al contenido del objeto agregado sin exponer surepresentacion internaPermite implementar varios recorridos distintos sobre objetosagregadosProporciona una interfaz uniforme para recorrer diferentesestructuras agregadas

InconvenientesLa modificacion del agregado mientras se esta recorriendo con uniterador es una operacion peligrosa.Una posible y compleja solucion es disenar iteradores “robustos” quese adapten a estas modificaciones.Una solucion mas sencilla, aunque mas drastica, es disenar iteradoresfail-fast que lanzan un error si se produce una modificacion durantela iteracion (los iteradores del API de Java son fail-fast)





Principio de “Bajo Acoplamiento”Patron ObservadorPatron AdaptadorPrincipio de Mınimo Conocimiento (Ley de Demeter)Principio “Tell, Don’t Ask” (Dile, No preguntes)Patron Fachada

Indice





5 Disenos Debilmente AcopladosPrincipio de “Bajo Acoplamiento”Patron ObservadorPatron AdaptadorPrincipio de Mınimo Conocimiento (Ley de Demeter)Principio “Tell, Don’t Ask” (Dile, No preguntes)Patron Fachada






Principio de “Bajo Acoplamiento”

Principio de “Bajo Acoplamiento”Busca disenos debilmente acoplados entre objetos que interactuan

AcoplamientoMedida de la dependencia que tiene una determinada clase de otrasclases del sistema

Un codigo con bajo acoplamiento es un codigo mas robusto yadaptable, ya que los cambios en una clase no se propagan al restode clases del sistema, solo a unas pocas clases cercanas







Como reducir el acoplamiento:Haciendo que nuestra clase trabaje sobre objetos abstractos y noconcretos, haciendolos menos dependientes de una implementacionconcreta ⇒ Inversion de la DependenciaConectando a las clases con el menor numero posible de otras clases,usando clases que juegan el rol de intermediarias entre otras clasesdel sistema ⇒ Principio de Mınimo Conocimiento







Acoplamiento y CohesionEl objetivo es crear objetos cohesivos (centrados en resolver unaunica responsabilidad) con bajo acoplamiento (dependientes delmenor numero posible de clases)

Acoplamiento y clases inestablesEl acoplamiento alto es un problema cuando alguna de las clases esinestable y cambia frecuentemente, ya que eso provoca cambios enlos elementos dependientesSi las clases acopladas son estables, desacoplarlas lo unico que hacees anadir complejidad al sistema






Patron Observador

Patron ObservadorPermite definir una dependencia “uno a muchos” entre objetos de talforma que, cuando el objeto cambie de estado, todos sus objetosdependientes sean notificados y actualizados automaticamente

El patron desacopla al objeto observado de sus observadores, ya queel primero desconoce la clase a la que pertenecen los ultimos, solosabe que implementan un determinado interfazSe pueden anadir observadores en cualquier momento y no esnecesario modificar el subjeto observado al anadir nuevos tipos deobservadoresDe la misma forma cambios en el objeto observado no deberıanafectar a sus observadores






Elementos del Patron Observador Observador: Clase abstrac-ta que define un metodoactualizar utilizado

por el sujeto para notifi-car cambios en su estado

Observador concre-to: Mantiene una

referencia al sujetoconcreto e imple-

menta actualizar

Sujeto: Clase abstractaque esta siendo observa-da y que proporciona lainterfaz para mantener y

notificar a los observadores

Sujeto concreto: Mantiene elestado del sujeto y se encarga

de notificar a los observa-dores al cambiar su estado






Funcionamiento del Patron Observador






Funcionamiento del Patron Observador






El Patron Observador en Java

El patron Observador puede ser implementando de forma sencilla enJava haciendo uso de las clases Observable y Observerdisponibles en el APIObservable juega el rol de Sujeto mientras que Observerjuega el rol de ObservadorSon clases muy simples y el patron puede implementarse de formasencilla sin tener que usarlasUn ejemplo mas complejo del patron Observador lo encontramos enel mecanismo de delegacion de eventos usado en los interfacesgraficos Swing







Interface Observer

public interface Observer {void update(Observable o, Object arg);

}













Clase Observable (1/2)

public class Observable {private boolean changed = false;private Vector obs;public Observable() { obs = new Vector(); }

public synchronized void addObserver(Observer o) {if (o == null) throw new NullPointerException();if (!obs.contains(o)) { obs.addElement(o); }

}public synchronized void deleteObserver(Observer o) {

obs.removeElement(o);}public synchronized void deleteObservers() {

obs.removeAllElements();}public synchronized int countObservers() {

return obs.size();}// ...







Clase Observable (2/2)

// ...protected synchronized void setChanged() { changed = true; }protected synchronized void clearChanged() { changed = false; }public synchronized boolean hasChanged() { return changed; }

public void notifyObservers() { notifyObservers(null); }

public void notifyObservers(Object arg) {Object[] arrLocal;

synchronized (this) {if (!changed) return;arrLocal = obs.toArray();clearChanged();

}for (int i = arrLocal.length-1; i>=0; i--)

((Observer)arrLocal[i]).update(this, arg);}

}






Ejemplo del Patron Observador

Observer juega elrol de Observador

AlarmaPiscinajuega el rol de Ob-servador concreto

Observable juegael rol de Sujeto

Piscina juega el rolde Sujeto concreto







Clase Piscina

class Piscina extends Observable {public static final int MAX = 100;public static final int MIN = 50;public enum Limite{NIVEL_MAX, NIVEL_MIN}private int nivel;public Piscina(int valor) { nivel = valor; }public int getNivel() { return nivel; }

public void abreGrifo(int incremento) {nivel += incremento;if (nivel > MAX) {

setChanged();notifyObservers(Limite.NIVEL_MAX);

}}public void quitaTapon(int decremento) {

nivel -= decremento;if (nivel < MIN) {

setChanged();notifyObservers(Limite.NIVEL_MIN);

} } }

Cuando el nivel superael maximo o baja

del mınimo se avisaa los observadores

indicandoles el eventoque ha sucedido







Clase AlarmaPiscina

class AlarmaPiscina implements Observer {@Overridepublic void update(Observable o, Object arg) {

Piscina p = (Piscina)o;int cantidad;

System.out.println("El nivel de la piscina es: " + p.getNivel());if (arg.equals(Piscina.Limite.NIVEL_MAX)) {

cantidad = Piscina.MAX - p.getNivel();System.out.println("Hay que VACIAR la cantidad de "+cantidad);

} else if (arg.equals(Piscina.Limite.NIVEL_MIN)) {cantidad = Piscina.MIN - p.getNivel();System.out.println("Hay que LLENAR la cantidad de "+cantidad);

}}

}

La claseAlarmaPiscina

comprueba que eventorecibe y accede al

estado de Piscinapara calcular la can-tidad que necesita

para restaurar el nivel







Uso de Piscina y AlarmaPiscina

public static void main(String[] args) {Piscina casaDelAgua = new Piscina(75);AlarmaPiscina alarmaSocorrista = new AlarmaPiscina();AlarmaPiscina alarmaBomberos = new AlarmaPiscina();

casaDelAgua.addObserver(alarmaSocorrista);casaDelAgua.addObserver(alarmaBomberos);

System.out.println("Nivel de la piscina: " + casaDelAgua.getNivel());casaDelAgua.abreGrifo(10);System.out.println("Nivel de la piscina: " + casaDelAgua.getNivel());casaDelAgua.abreGrifo(30);System.out.println("Nivel de la piscina: " + casaDelAgua.getNivel());casaDelAgua.quitaTapon(100);

}

Registramos dos obser-vadores de la piscina

Al modificar el nivel delegamos enla piscina el avisar a sus observa-

dores si ocurre un evento resenable






Ventajas e inconvenientes del Patron Observador

VentajasAl desacoplar los observadores de la clase observable, esta ultima notiene por que conocer la clase concreta a la que pertenecen susobservadores, simplemente se limita a notificar los cambios a travesde un interfaz conocidoLa responsabilidad del objeto observado se acaba con la notificacion,son los observadores los que tienen que decidir que accion llevar acabo despues de la notificacion

InconvenientesLos observadores no tienen contacto entre si, esto puede dar lugar asituaciones difıciles de controlar cuando varios observadoresresponden simultaneamente ante un cambio. En el peor de los casospuede dar lugar a una cascada de actualizacionesLa comunicacion entre observado y observadores suele ser simple, loque fuerza a los observadores a deducir que ha cambiado en elobservado ⇒ pull model vs. push model






Modelo pull vs. modelo push

Modelo pullLos observadores “tiran” del sujetoEl sujeto manda a los observadores una mınima notificacionindicando que su estado ha cambiadoEs responsabilidad de los observadores descubrir que ha cambiado yactuar en consecuenciaVentaja: Enfatiza la ignorancia que tiene el sujeto observado de susobservadoresInconveniente: Puede ser ineficiente, ya que las clases observadorastienen la sobrecarga de descubrir que ha cambiado sin la ayuda delsujeto







Notificacion pull


setChanged();notifyObservers();

}}

Se manda a los observadoressimplemente una notificacion

de que ha sucedido un cambio,es responsabilidad suya

descubrir que ha cambiado







Modelo pushEl sujeto “empuja” a los observadoresEl sujeto manda a los observadores informacion detallada acerca delo que ha cambiadoImplica que el sujeto tiene un cierto conocimiento sobre lasnecesidades de los observadoresVentaja: La comunicacion puede ser mas eficiente ya que no sefuerza a descubrir a los observadores que es lo que ha cambiadoInconveniente: Sujeto y observadores no son tan independientescomo en el modelo pull







Notificacion push


setChanged();notifyObservers(new Notificacion(nivel,

Notificacion.Limite.NIVEL_MAX));}

}

Se manda a los observado-res informacion detallada de

lo que ha sucedido, estospodran actuar en conse-cuencia sin necesidad de

acceder al estado de Piscina






Patron Adaptador

Patron AdaptadorConvierte el interfaz de una clase en otro interfaz que es el esperado porlos clientes. De esta forma permite que cooperen clases con interfacesincompatibles

El patron asume que no se pueden hacer cambios ni en el interfazque esperan los clientes ni en el interfaz que provee la clase servidoraPuede ser debido a que es un API externo, son clases de las cualesno disponemos el codigo fuente o simplemente no se quieremodificar las clases para un determinado uso concreto y puntual






Patron Adaptador






Patron Adaptador






Patron Adaptador






Elementos del Patron Adaptador (Herencia multiple)Objetivo: Interfaz

que utiliza el cliente

Cliente: Colabora conotros objetos usandoel interfaz Objetivo

Adaptado:Define una

interfazexistente quenecesita ser

adaptada

Adaptador: Implementa el inter-faz Objetivo convirtiendolo en

el interfaz del adaptado del cualhereda ⇒ Herencia multiple






Elementos del Patron Adaptador (Composicion)

Adaptador: Implementa el inter-faz Objetivo convirtiendolo en elinterfaz del adaptado que forma

parte de su estado ⇒ Composicion






Diferencias entre Herencia Multiple y Composicion

Herencia Multiple (adaptador de clases)Solo permite adaptar a una clase, no a sus subclasesPermite que el adaptador sobreescriba parte de la conducta deladaptado (ya que es una subclase)Nos evitamos la indireccion que se produce en la composicionEn Java solo es posible realizarla si Objetivo es un interfaz y nouna clase abstracta

Composicion (adaptador de objetos)Permite que un unico adaptador trabaje sobre muchos adaptados(una clase y sus subclases)Introduce un nivel mas de indireccionComplica la sobreescritura de la conducta del adaptado (se necesitacrear una subclase del adaptado y que el adaptador se refiera a estasubclase)Objetivo puede ser una clase abstracta y no un interfaz






Ejemplo del Patron Adaptador

El API de Java define una clase Stack para implementar elcomportamiento de una pilaStack hereda de Vector (lo que hemos comentado que es unerror) e incluye los tıpicos metodos pop, push y peekEl nuevo API de colecciones de Java incluyo el interfaz Queue paradefinir el funcionamiento de colas. La cola no tiene que serextrictamente una cola FIFO (First In, First Out), ya que puedendefinirse colas de prioridad o incluso una pila LIFO (Last In, FirstOut)Si tenemos un cliente que usa un Queue pero le queremos pasar unobjeto de tipo Stack, al ser sus interfaces incompatibles (y serclases del API que no podemos modificar) necesitamos un adaptador







Metodos de Queue

Metodos de Stack






Ejemplo del Patron Adaptador (Herencia Multiple)

ClienteObjetivo Adaptado

Adaptador






Ejemplo del Patron Adaptador (Herencia Multiple)

Clase AdaptadorHerencia

public class AdaptadorHerencia extends Stack implements Queue {@Overridepublic boolean offer(Object e) {

push(e);return true;

}

@Overridepublic Object peek() {

if (empty()) return null;else return super.peek();

}

@Overridepublic Object poll() {

if (empty()) return null;else return pop();

}// Resto de metodos de Queue y Collection...

}

AdaptadorHerenciahereda del adaptado e im-

plementa el interfaz objetivo

El adaptador convierte lasllamadas al interfaz Queue

en llamadas a la clase Stackrealizando pequenos ajustes






Ejemplo del Patron Adaptador (Composicion)






Ejemplo del Patron Adaptador (Composicion)

Clase AdaptadorComposicion

public class AdaptadorComposicion implements Queue {private Stack stack = new Stack();

@Overridepublic boolean offer(Object e) {

stack.push(e);return true;

}@Overridepublic Object peek() {

if (stack.empty()) return null;else return stack.peek();

}@Overridepublic Object poll() {

if (stack.empty()) return null;else return stack.pop();

}// Resto de metodos de Queue y Collection...

}

AdaptadorComposicion im-plementa el interfaz objetivo eincluye un atributo privado quees una instancia del adaptado

El adaptador ahora dele-ga las llamadas al inter-faz Queue en su objetointerno de tipo Stack







Clase ClienteQueue

public class ClienteQueue {public static void usandoQueue(Queue q) {

q.offer("A");q.offer("B");q.offer("C");System.out.println(q.poll() + " " + q.poll() + " " + q.poll());

// Imprime C B ASystem.out.println(q.peek());// Imprime el objeto que ya estaba en

} // "q" on "null" si no habıa ninguno

public static void main(String[] args) {AdaptadorHerencia adaptadorH = new AdaptadorHerencia();ClienteQueue.usandoQueue(adaptadorH);

AdaptadorComposicion adaptadorC = new AdaptadorComposicion();ClienteQueue.usandoQueue(adaptadorC);

}}

ClienteQueue esperaun objeto de tipo Queue

Le pasamos un objeto deltipo del adaptador para quepueda trabajar con Stackcomo si fuera un Queue






Ejemplo en el API de Java (Wrapper classes)

Clase Integer

public final class Integer extends Number {private int value;

public Integer(int value) {this.value = value;

}

public int intValue() {return value;

}

// El resto se omite...}

El adaptador implementael interfaz objetivo, que ennuestro caso es Object.

Nuestro cliente sera p.ej. unArrayList que solo almacena

objetos, no tipos basicos

El adaptador mantiene unainstancia interna del adaptado,

en nuestro caso un int

Las operaciones se rediri-gen al adaptado, en este

caso delvolver el valor






Principio de Mınimo Conocimiento (Ley de Demeter)

Patrones como Observador y Adaptador tratan de reducir elacoplamiento entre dos clases que tienen que colaborar haciendo quese comuniquen a traves de interfaces o clases adaptadorasOtra forma de reducir el acoplamiento es reduciendo el numero deconexiones existentes entre objetos ⇒ Principio de MınimoConocimiento, Principio “Tell, Don’t Ask”, Patron Fachada







Clase Monedero

public class Monedero {private int valor;

public int obtenSaldo() {return valor;

}

public void insertaDinero(int deposito) {valor += deposito;

}

public int obtenDinero(int debito) {if (debito > valor)

debito = valor;valor -= debito;return debito;

}}

Clase Cliente

public class Cliente {private String nombre;private Monedero monedero;

public Cliente(String n, Monedero m) {this.nombre = n;this.monedero = m;

}


}

public Monedero getMonedero() {return monedero;

}}







¿Que problema tiene el siguiente codigo?

Clase Repartidor

public class Repartidor {public void obtenerPago(Cliente cliente, int pago) {

Monedero m = cliente.getMonedero();int cantidadPagada = m.obtenDinero(pago);

if (cantidadPagada >= pago)System.out.println("Gracias");

elseSystem.out.println("Volvere mas tarde");

}}

“Nunca hables con extranos... y mucho menos les des tu monedero”







Principio de Mınimo Conocimiento (Ley de Demeter)“No hables con extranos... habla solo con tus amigos inmediatos”

El objetivo de este principio es reducir las interacciones entre objetoshaciendo que “hablen” solo con otros pocos objetos cercanosDe esta forma se reduce el acoplamiento (numero de clases con lasque esta conectada otra clase)El nombre de “Ley de Demeter” viene del proyecto del cual surgio elprincipio







Principio de Mınimo Conocimiento (en la Orientacion a Objetos)Dentro de un metodo de un determinado objeto solo se pueden mandarmensajes a:

El propio objeto (this)Un parametro del metodoUn atributo del propio objetoUn elemento de una coleccion que es un atributo del propio objetoUn objeto creado dentro del metodo







Clase que cumple el principio

public class ClaseA {private ClaseC cc;private List<ClaseD> coleccion = new ArrayList<>();

public void metodoA1 (ClaseB cb) {this.metodoA2(); // Llamada a un metodo del propio objetocb.metodoB(); // Llamada a un metodo de un paremetrocc.metodoC(); // Llamada a un metodo de un atributocoleccion.get(0).metodoD(); // Llamada a un metodo de un elemento de

// una coleccion que es un atributoClaseE ce = new ClaseE();ce.metodoE(); // Llamada a un metodo de un objeto creado

}

public void metodoA2() { }}







Repartidor no cumple el principio al llamar a un metodo(obtenDinero) de un objeto (m), que no es un atributo,parametro, ni se ha creado en el metodo obtenerPago

Repartidor no cumple el principio

public class Repartidor {public void obtenerPago(Cliente cliente, int pago) {

Monedero m = cliente.getMonedero();int cantidadPagada = m.obtenDinero(pago);



}}

Incumple la Leyde Demeter







Clase Cliente

public class Cliente {private String nombre;private Monedero monedero;

public Cliente(String nombre, Monedero monedero) {this.nombre = nombre;this.monedero = monedero;

}


}

// public Monedero getMonedero() {// return monedero;// }

public int obtenPago(int pago) {return monedero.obtenDinero(pago);

}}

Eliminamos el meto-do getMonedero()

Incluimos un nuevo metodopara gestionar los pagos







Clase Repartidor

public class Repartidor {public void obtenerPago(Cliente cliente, int pago) {int cantidadPagada = cliente.obtenPago(pago);



}}

El Repartidor solo interactuacon Cliente y desconocela existencia de Monedero







VentajasEl acoplamiento entre clases es mas bajo con la nueva solucionRepartidor no se ve afectado por los cambios que puedanproducirse en MonederoSituamos el mecanismo de pago en Cliente haciendo queRepartidor solo conozca el resultado final pero no el mecanismo(podemos ir al monedero o pedir dinero prestado al vecino)Existe un reparto mas claro de responsabilidades entre las distintasclases







InconvenientesCliente se vuelve mas complejo al tener que incluir un nuevometodo (obtenPago), aunque a cambio hemos simplificado elfuncionamiento de RepartidorSi Cliente tuviera que repetir la misma operacion para otras clases(me piden un pago por tarjeta, me solicitan el numero de DNI)podrıa llegar a complicarse bastante






Principio “Tell, Don’t Ask” (Dile, No preguntes)

Principio “Tell, Don’t Ask” (Dile, No preguntes)Hay que decirle a los objetos lo que quieres que hagan, no preguntarlesacerca de su estado interno y tomar una decision en base a su respuesta

Preguntarle a un objeto por su estado y luego llamar a metodossobre ese objeto basandose en decisiones tomadas fuera de eseobjeto, significa que ese objeto es una leaky abstraction (abstraccioncon fugas)Parte del comportamiento del objeto se situa fuera del mismo y suestructura interna se expone (puede que innecesariamente) al mundoexterior






Principio “Tell, Don’t Ask” (Dile, No preguntes)

Este principio es similar a la Ley deDemeter, en el sentido en que ambosproponen reducir el acoplamiento entreobjetosSin embargo el principio “Tell, Don’t Ask”es mas general ya que intenta hacerrecordar que la orientacion a objetos tratade la encapsulacion conjunta de datos conlas funciones que operan sobre esos datos






Principio “Tell, Don’t Ask” - EjemploNumero racional: numero que puede representarse como elcociente de dos numeros enteros

Clase Racional

public class Racional {private int numerador;private int denominador;

public Racional(int numerador, int denominador) {if (denominador == 0)

throw new IllegalArgumentException();this.numerador = numerador;this.denominador = denominador;

}

public int getNumerador() { return numerador; }public int getDenominador() { return denominador; }

// ...}






Principio “Tell, Don’t Ask” - Ejemplo

Suponemos que dentro del codigo de otra clase (UsaRacional)queremos comprobar si un racional es igual a un valor dado (porejemplo 1/2)

Clase UsaRacional

public class UsaRacional {public static void main(String[] args) {

Racional r1;

// ...

if (r1.getNumerador() == 1 && r1.getDenominador() == 2)System.out.println("Tienes la mitad de la tarta...");

}}







ProblemasUsaRacional esta examinando el estado interno de Racionalpara tomar una decision.Estamos exponiendo innecesariamente la estructura interna deRacionalEstamos situando comportamiento propio de Racional fuera delmismo ⇒ la comparacion de dos valores racionales

SolucionDefinir un metodo equals en Racional que se encargue de hacerlas comparacionesEste metodo podrıa ser mas complejo incluso que lo esperadopermitiendo detectar fracciones equivalentes: 1/2 = 2/4







Metodo equals de Racional sencillo

@Overridepublic boolean equals(Object obj) {

if (obj == null) {return false;

}if (getClass() != obj.getClass()) {

return false;}final Racional other = (Racional) obj;if (this.numerador != other.numerador) {

return false;}if (this.denominador != other.denominador) {

return false;}return true;

}







Metodo equals de Racional usando equivalencias

@Overridepublic boolean equals(Object obj) {

if (obj == null) {return false;

}if (getClass() != obj.getClass()) {

return false;}final Racional other = (Racional) obj;// a/b y c/d, son equivalentes sı y solo sı a*d == b*cint valor1 = this.numerador * other.denominador;int valor2 = this.denominador * other.numerador;if (valor1 != valor2) {

return false;}return true;

}







Clase UsaRacional siguiendo el principio

public class UsaRacional {public static void main(String[] args) {

Racional r1 = new Racional(1,2);if (r1.equals(new Racional(1,2)))

System.out.println("Tienes la mitad de la tarta...");

Racional r2 = new Racional(2,4);if (r2.equals(new Racional(1,2)))

System.out.println("Tienes la mitad de la otra tarta...");}

}






Patron Fachada

Patron FachadaProvee de un interfaz unificado para un conjunto de clases en unsubsistema. La fachada actuarıa como un interfaz de alto nivel quehara que el subsistema sea mas facil de utilizar

Elementos:Fachada: Conoce que clases son las responsables de unadeterminada peticion y delega dicha peticion sobre esas clasesClases del subsistema: Implementan las funcionalidades delsubsistema y reciben las peticiones desde la fachada, aunquedesconocen su existencia






Elementos del Patron Fachada






Ejemplo del Patron FachadaClases para controlar un sistema de “cine en casa”






Ejemplo del Patron Fachada

Acciones a realizar al ver una pelıculaEncender la maquina de palomitasPonerla a hacer palomitasBajar las lucesBajar la pantallaEncender el proyectorPoner el proyector en el modo 16:9Encender el amplificador de sonidoIndicar que la entrada del amplificador es el DVDPoner el sonido envolvente en el amplificadorPoner el volumen del amplificador a la mitadEncender el DVDComenzar la reproduccion en el DVD






Ejemplo del Patron Fachada“cine en casa” usando una fachada

verPeliculasimplifica la interaccion

con el subsistemaal ver una pelicula

El acceso a las clasesdel subsistema evitando

la fachada es posible







Clase CineCasaFachada

public class CineEnCasaFachada {private Amplificador amplificador;private Radio radio;private ReproductorDVD reproductorDVD;private ReproductorCD reproductorCD;private Proyector proyector;private Pantalla pantalla;private Palomitero palomitero;private Luces luces;

public CineEnCasaFachada(Amplificador amplificador, Radio radio,ReproductorDVD reproductorDVD, ReproductorCD reproductorCD,Proyector proyector, Pantalla pantalla, Palomitero palomitero,Luces luces) {

// ...}// ...

} La fachada conoce los objetossobre los cuales trabaja







Metodo verPelicula de CineEnCasaFachada

public void verPelicula(String pelicula) {palomitero.encender();palomitero.hacerPalomitas();luces.atenuar();pantalla.bajar();proyector.encender();proyector.modoPantallaAncha();amplificador.encender();amplificador.setDVD(reproductorDVD);amplificador.setSonidoEnvolvente();amplificador.setVolumen(5);reproductorDVD.encender();reproductorDVD.reproducir(pelicula);

}






Patron Fachada

VentajasEl subsistema resulta mas facil de utilizar por parte de sus clientesBajo acoplamiento, la modificacion del subsistema no afecta a losclientes que lo utilizanLos clientes pueden seguir usando las clases del subsistema obviandola fachada si consideran que no corresponde con sus necesidades

Fachada vs. AdaptadorSe diferencian mas en la intencion que en su propia estructuraEl patron adaptador trata de alterar un interfaz para que coincidacon lo que el cliente se esperaEl patron fachada trata de ofrecer un interfaz simplificado sobre unsubsistema complejo






Fachadas y casos de uso

El proceso de analisis de requisitos nos permite identificarque actores van a usar el sistema y como lo van a hacerEstos casos de uso pueden usarse para extraer Diagramas deSecuencia del Sistema (diagramas de alto nivel que tratan deidentificar las acciones que ofrece un sistema a un determinadoactor)Estas acciones pueden ser luego el origen de una fachada que elsistema ofrece al actorEn realidad la fachada es entre capas de la aplicacion: son lasfunciones que el modelo ofrece al interfaz grafico manejado por elactor







Procesar una ventaen un supermercado

Flujo basico del caso de uso1 El Cliente llega al terminal con productos2 El Cajero comienza una nueva venta3 El Cajero introduce el identificador del producto4 El Sistema registra la venta y muestra la

descripcion del artıculo y el precio5 Se repiten los pasos 3-4 hasta que se indique el

final de la venta6 El Sistema presenta el total mas el IVA7 El Cajero le dice al Cliente el total y le pide que

pague8 El Cliente paga y el Sistema gestiona el pago9 El Sistema registra la venta10 El Sistema calcula el cambio y genera el recibo11 El Cliente recibe el recibo, el cambio y recoge

los productos







Diagrama de secuencia del sistema

Fachada para un Cajero





Patron Metodo FactorıaPatron ConstructorPrincipios KISS y YAGNI

Indice






6 Patrones Creacionales y Otros PrincipiosPatron Metodo FactorıaPatron ConstructorPrincipios KISS y YAGNI






Metodo Factorıa

Metodo FactorıaDefine un interfaz para crear un objeto pero permitiendo que lassubclases sean las que decidan que objeto hay que crear

Despues de una instruccion new siempre tiene que ir una claseconcreta, no puede ir una clase abstracta o un interfazSi queremos abstraer el proceso de creacion de los objetos ydelegarlo en las subclases necesitamos crear objetos dentro demetodos especiales denominados metodos factorıa






Elementos del Patron Metodo Factorıa

Producto: Define el inter-faz de los objetos creados

por el metodo factorıa

Producto concreto: Implemen-ta el interfaz de los productos

Creador: Declara el metodofactorıa, que devuelve unobjeto de tipo Producto

Creador concreto: Sobreescribeel metodo factorıa para

devolver una instancia deun ProductoConcreto






Ejemplo del Patron Metodo Factorıa

Nuestra entidad financiera invierte el dinero de nuestros clientes endistintos tipos de fondosEn nivel creciente de riesgo (pero tambien de posibles beneficios)tenemos:

Fondos Garantizados: Nuestra companıa garantiza un interes dadoen un plazo de inversion determinadoFondos en Renta Fija: Invierten en obligaciones, bonos, letras,pagares, etc.Fondos Mixtos: Mezclan inversiones en renta fija y renta variableFondos en Renta Variable: Invierten en accionesFondos de Capital Riesgo: Invierten en empresas que no cotizan enbolsa (por ejemplo, startups)

Segun el perfil del inversor (conservador, arriesgado, etc.)invertiremos el dinero en un tipo de producto determinado






Ejemplo del Patron Metodo FactorıaFondoInversion jue-

ga el rol de Producto

Los distintos tipos defondo juegam el rol

de Producto concreto

FactoriaFondo jue-ga el rol de Creador

Las distintas factorıasconcretas juegan el rolde Creador concreto







Clase FondoInversion

public abstract class FondoInversion {private int saldo;private final String nombre;

public FondoInversion(String nombre) {this.nombre = nombre;

}public FondoInversion(String nombre, int saldo) {

this.nombre = nombre;this.saldo = saldo;

}@Overridepublic String toString() {

return nombre + ": " + saldo + " EUR";}public int getSaldo() { return saldo; }public void setSaldo(int saldo) { this.saldo = saldo; }

}







Clase FondoGarantizado

public class FondoGarantizado extends FondoInversion {public FondoGarantizado(int saldo) {

super("Fondo Garantizado", saldo);

// Invierte el dinero en activos garantizados}

}

Clase FondoRentaFija

public class FondoRentaFija extends FondoInversion {public FondoRentaFija(int saldo) {

super("Fondo Renta Fija", saldo);

// Invierte el dinero en renta fija}

}







Clase FactoriaFondo

public abstract class FactoriaFondo {public abstract FondoInversion creaFondoInversion(int saldo);

}

Clase FactoriaFondoGarantizado

public class FactoriaFondoGarantizado extends FactoriaFondo {@Overridepublic FondoInversion creaFondoInversion(int saldo) {

return new FondoGarantizado(saldo);}

}







Clase GestorCartera

public class GestorCartera {FactoriaFondo factoria;

public FondoInversion invertir(int cantidad) {if (factoria == null)factoria = obtenerFactoria();

return factoria.creaFondoInversion(cantidad);}

private FactoriaFondo obtenerFactoria() {int nivelRiesgo = calcularNivelRiesgo();if (nivelRiesgo < 20) return new FactoriaFondoGarantizado();else if (nivelRiesgo < 40) return new FactoriaFondoRentaFija();else if (nivelRiesgo < 60) return new FactoriaFondoMixto();else if (nivelRiesgo < 80) return new FactoriaFondoRentaVariable();else return new FactoriaFondoCapitalRiesgo();

}private int calcularNivelRiesgo() {// hacer encuesta...

}}

invertir dele-ga la creacion de

fondos a la factorıa

La factorıa se obtienesegun el nivel de riesgo






Patron Metodo Factorıa

Posibles implementacionesFactorıa como metodo abstracto: El metodo factorıa se declaraabstracto en la superclase y debe ser redefinido por las subclases (nohay implementacion por defecto). Es el ejemplo visto hasta ahora.Factorıa como metodo concreto: El metodo factorıa no esabstracto (incluye una implementacion por defecto)Factorıa parametrizada: Los objetos se crean segun un parametroque se le pasa a la factorıa







Factorıa como metodo concretoHabitualmente la superclase tampoco es abstractaNo es necesario utilizar las subclases si no se quiere. Pero se abre laposibilidad a definir una subclase especializada

Clase FactorıaFondo como metodo concreto

class FactoriaFondo {public FondoInversion creaFondoInversion(int saldo) {

// Por defecto creamos el mas conservadorreturn new FondoGarantizado(saldo);

}}







Clase GestorCartera con factorıa en metodo concreto

public class GestorCartera {

// ...

private FactoriaFondo obtenerFactoria() {// Si no hay un nivel de riesgo determinado// devolvemos el fondo por defectoif (nivelRiesgo < 0)return new FactoriaFondo();

else if (nivelRiesgo < 20) return new FactoriaFondoGarantizado();else if (nivelRiesgo < 40) return new FactoriaFondoRentaFija();else if (nivelRiesgo < 60) return new FactoriaFondoMixto();else if (nivelRiesgo < 80) return new FactoriaFondoRentaVariable();else return new FactoriaFondoCapitalRiesgo();

}

// ...}







Esta version del metodo factorıa obliga a tener dos jerarquıasparalelas, una para los productos y otra para las factorıasEsto puede evitarse con una version parametrizada de la factorıa enla cual solo existe una clase factorıa que crea un producto u otrosegun un parametro que se le pasaDe esta forma eliminamos la necesidad de las subclases aunque elproceso de creacion es menos abstracto (a la factorıa le indicamos loque tiene que crear)Sigue siendo posible crear subclases de la factorıa que alteren elcomportamiento predeterminado







Clase FactoriaFondo parametrizada usando switch

class FactoriaFondo {public FondoInversion creaFondoInversion(String tipo, int saldo) {

switch (tipo) {case "FondoGarantizado":

return new FondoGarantizado(saldo);case "FondoRentaFija":

return new FondoRentaFija(saldo);case "FondoMixto":

return new FondoMixto(saldo);case "FondoRentaVariable":

return new FondoRentaVariable(saldo);case "FondoCapitalRiesgo":

return new FondoCapitalRiesgo(saldo);default:

return new FondoGarantizado(saldo);}

}}







Para evitar tener que crear una nueva entrada cada vez que se creaun nuevo producto (incumpliendo el principio abierto-cerrado)podemos usar otras estrategias para crear la factorıa parametrizada:Reflexion:

Usa la informacion de tipos en tiempo de ejecucion para crearobjetos a partir del String que representa su nombre

Genericidad:La factorıa usa la genericidad para crear objetos a partir de unareferencia a su clase







Clase FactoriaFondo parametrizada usando reflexion

class FactoriaFondo {public FondoInversion creaFondoInversion(String tipo, int saldo) {

FondoInversion fondo = null;try {

fondo = (FondoInversion) Class.forName("fondos_inversion."+ tipo).newInstance();

fondo.setSaldo(saldo);} catch (Exception e) {

throw new IllegalArgumentException();}return fondo;

}}







Clase FactoriaFondo parametrizada usando genericidad

class FactoriaFondo {public <T extends FondoInversion> T creaFondoInversion(Class<T> tipo,

int saldo) {T fondo = null;try {

fondo = tipo.newInstance();fondo.setSaldo(saldo);

} catch (Exception e) {throw new IllegalArgumentException();

}return fondo;

}}






Patron constructor (builder)

Patron constructor (builder)Separa la construccion de un objeto complejo de su representacion, deforma que un mismo proceso de construccion pueda crear diferentesrepresentaciones

En esta definicion, incluida en el libro GoF, se enfatiza la posibilidadde usar polimorfismo para crear distintos tipos de objetosEn la actualidad el patron constructor se utiliza principalmente pararesolver el antipatron denominado Constructor Telescopico






Antipatron constructor telescopico

Constructor telescopicoUn constructor telescopico es aquel constructor que tiene una version conlos parametros requeridos, luego otra version con los parametrosrequeridos y un parametro opcional, luego otra version con losparametros requeridos y dos parametros opcionales, etc.

Imaginemos una clase que representa los aspectos nutricionales deun producto denominada NutritionFacts

Esta clase tendra dos parametros obligatorios: tamano en el que sesirve (servingSize) y numero de raciones o servicios que incluye(servings)Los parametros optativos seran las calorıas (calories), la grasa(fat), el sodio (sodium) y los carbohidratos (carbohydrate)







clase NutritionFacts (1/2)

public class NutritionFacts {private final int servingSize; // (mL) requiredprivate final int servings; // (per container) requiredprivate final int calories; // optionalprivate final int fat; // (g) optionalprivate final int sodium; // (mg) optionalprivate final int carbohydrate; // (g) optional

public NutritionFacts(int servingSize, int servings) {this(servingSize, servings, 0);

}public NutritionFacts(int servingSize, int servings, int calories) {

this(servingSize, servings, calories, 0);}public NutritionFacts(int servingSize,int servings,int calories,int fat) {

this(servingSize, servings, calories, fat, 0);}public NutritionFacts(int servingSize, int servings, int calories,int fat,

int sodium) {this(servingSize, servings, calories, fat, sodium, 0);

}







clase NutritionFacts (2/2)

public NutritionFacts(int servingSize, int servings, int calories,int fat, int sodium, int carbohydrate) {

this.servingSize = servingSize;this.servings = servings;this.calories = calories;this.fat = fat;this.sodium = sodium;this.carbohydrate = carbohydrate;

}}







Construir un objeto NutritionFacts

public static void main(String[] args) {NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);

}

ProblemasNo queda muy claro que representan los parametros que estamospasando por parametroA pesar de tener 5 constructores, no existe la opcion de dejar elparametro fat por defecto pero si incluir sodium ycarbohydrateLa solucion de poner aun mas constructores no parece razonableEn conclusion: el codigo funciona pero es complicado escribir codigoque lo use que sea sencillo y facil de leer






Solucion: Usar el patron JavaBeans

Los JavaBeans son los componentes JavaBasicamente son objetos normales que se caracterizan por:

Tener un constructor sin parametrosSus atributos son privados.Estos atributos son accedidos mediante metodos de lectura y deescritura que siguen la nomenclatura estandar (get/set)







clase NutritionFacts como JavaBean

public class NutritionFacts {private int servingSize = -1; // Required; no default valueprivate int servings = -1; // " " " "private int calories = 0;private int fat = 0;private int sodium = 0;private int carbohydrate = 0;public NutritionFacts() { }

public void setServingSize(int val) { servingSize = val; }public void setServings(int val) { servings = val; }public void setCalories(int val) { calories = val; }public void setFat(int val) { fat = val; }public void setSodium(int val) { sodium = val; }public void setCarbohydrate(int val) { carbohydrate = val; }

}







Construir un JavaBean NutritionFacts

public static void main(String[] args) {NutritionFacts cocaCola = new NutritionFacts();cocaCola.setServingSize(240);cocaCola.setServings(8);cocaCola.setCalories(100);cocaCola.setSodium(35);cocaCola.setCarbohydrate(27);

}







ProblemasCrear instancias se hace mas pesado (mas codigo a teclear)El constructor sin parametros nos obliga a crear un objeto que puedeser utilizado sin estar en un estado consistenteLos objetos creados de esta forma no pueden ser inmutables

SolucionUsar el patron constructor (builder)






Elementos del Patron ConstructorDirector: Construye un

objeto usando el in-terfaz del Constructor

Constructor: Especificauna interfaz abstracta para

crear las partes de un objeto

Constructor concreto: Im-plementa el interfaz delconstructor para crearun objeto determinado Producto: Representa el

objeto en construccion






Ejemplo del Patron Constructor

El ejemplo de la clase NutritionFacts es una aplicacion delpatron concreta que trata de resolver el problema de losconstructores telescopicosEn dicho ejemplo no existe un constructor abstracto, el producto esNutritionFacts y el constructor es la clase Builder que esuna clase interna de NutritionFactsLa clase Director sera cualquier clase que crea el objeto dadousando el constructor






Solucion: Usar el Patron Constructor

Clase NutritionFacts (1/2)

public class NutritionFacts {

private final int servingSize;private final int servings;private final int calories;private final int fat;private final int sodium;private final int carbohydrate;

private NutritionFacts(Builder builder) { // privadoservingSize = builder.servingSize;servings = builder.servings;calories = builder.calories;fat = builder.fat;sodium = builder.sodium;carbohydrate = builder.carbohydrate;

}

//...







Clase Builder interna de NutritionFacts (2/2)

public Builder(int servingSize, int servings) { // Clase internathis.servingSize = servingSize;this.servings = servings;

}public Builder calories(int val) { // Juegan el rol de

calories = val; return this; // construir parte}public Builder fat(int val) {

fat = val; return this;}public Builder sodium(int val) {

sodium = val; return this;}public Builder carbohydrate(int val) {

carbohydrate = val; return this;}public NutritionFacts build() { // Juega el rol de obtener resultado

return new NutritionFacts(this);}

}







Clase Director

public class Director {public static void main(String[] args) {

NutritionFacts cocaCola = new NutritionFacts.Builder(240,8).calories(100).sodium(35).carbohydrate(27).build();

System.out.println(cocaCola);}

}






Principios KISS y YAGNI

Fuente: xkcd.com


xkcd.com






Principio KISS “Keep It Simple, Stupid” (Mantenlo sencillo, estupido)La simplicidad debe ser mantenida como un objetivo clave del diseno, ycualquier complejidad innecesaria debe ser evitada

Principio YAGNI “You Aren’t Gonna Need It” (No vas a necesitarlo)Implementar los cambios cuando realmente se necesiten, no cuando solose prevea que se necesitaran

Ambos principios son propios de las metodologıas agiles e intentanque no caigamos en la sobreingenierıa







Sobre-Ingenierıa (Over-Engineering)Hacer el codigo mas flexible o sofisticadode lo necesarioSe hace para anticipar futuras necesidades,pero predecir el futuro es una tareaarriesgadaSi las predicciones no son correctasperdemos un tiempo valioso en hacercodigo innecesarioSiguiendo la norma “no arregles lo que noesta roto” este codigo nuncasera eliminado, lo que podrıa complicarfuturas modificaciones no previstas







Como implementar el Hola Mundo usando los patronesEstrategia, Factorıa e Instancia Unica

Clase HelloWorld

class HelloWorld {public static void main(String[] args) {

MessageBody mb = new MessageBody();mb.configure("Hello World!");AbstractStrategyFactory asf

= DefaultFactory.getInstance();MessageStrategy strategy = asf.createStrategy(mb);mb.send(strategy);

}}







Clase MessageBody

class MessageBody {private Object payload;public Object getPayload() { return payload; }public void configure(Object obj) { payload = obj; }public void send(MessageStrategy ms) { ms.sendMessage(); }

}

Clase MessageStrategy

interface MessageStrategy { public void sendMessage(); }

Clase AbstractStrategyFactory

abstract class AbstractStrategyFactory {public abstract MessageStrategy createStrategy(MessageBody mb);

}







Clase DefaultFactory

class DefaultFactory extends AbstractStrategyFactory {private static DefaultFactory instance;private DefaultFactory() {}

public static AbstractStrategyFactory getInstance() {if (instance == null) { instance = new DefaultFactory(); }return instance;

}@Overridepublic MessageStrategy createStrategy(final MessageBody mb) {

return new MessageStrategy() {MessageBody body = mb;

@Overridepublic void sendMessage() {

Object obj = body.getPayload();System.out.println((String) obj);

}};

}}







Infra-Ingenierıa (Under-Engineering)Se refiere a codigo pobremente disenado y es problema mas comunque afecta al disenoLos disenos incorrectos surgen por diversas causas: No ha habidotiempo suficiente, no tenemos los conocimientos necesarios, etc.Un diseno incorrecto que funcione correctamente nuncasera modificado aplicando la norma “no arregles lo que no esta roto”A medida que el proyecto va avanzando y se anade mas codigo, mascomplicado se hace poder corregir el codigo pobremente disenado.Al final puede llegarse a la necesidad de realizar una completareescritura para adaptarse a las nuevas necesidades.


Tema 6: Patrones de DisenoDiseno Software (614G01027)

Eduardo Mosqueira Rey (Coordinador)David Alonso Rıos

Departamento de Computacion, Facultad de Informatica

Documents

Tema 6: Patrones de Diseño Diseño Software (614G01027