PROGRAMACION II

ENSAYO DE CICLO

Docente:
Ing. Milton Campoverde
Alumno:
Paul Sebastian Saguay Puente
Fecha:
23 de Junio del 2017
Contenido
INTRODUCCION....................................................................................................................2
1. Bloque N1.......................................................................................................................3
1.1 Gestin de Archivos ....................................................................................................3
1.2 Serializacion Binaria .................................................................................................. 12
1.3 Serializacion XML ...................................................................................................... 16
2. Bloque N2..................................................................................................................... 20
2.1 Componentes Grficos .............................................................................................. 20
2.2 Layouts..................................................................................................................... 29
2.3 Eventos .................................................................................................................... 31
3. Bloque N3..................................................................................................................... 33
3.1 Introduccin a Patrones de Diseo ............................................................................. 33
3.2 Catalogo de Patrones de Diseo................................................................................. 34
3.3 Patrones Creacionales ............................................................................................... 34
3.4 Patrones Estructurales............................................................................................... 35
3.5 Patrones de Comportamiento .................................................................................... 37
Conclusiones...................................................................................................................... 41
 PROGRAMACION II

INTRODUCCION
En el presente ciclo con la asignatura de Programacin II, en el presente ensayo vamos a hacer una
recapitulacin de los conocimientos adquiridos en la programacin orientada a objetos en el manejo e
implementacin de Interfaces, Polimorfismo, Enumeraciones, asociaciones y multiplicidad entre objetos,
aplicaciones de escritorio y streams, as como la aplicacin prctica inmediata de los conocimientos
adquiridos en problemas de la vida real.
 1. Bloque N1
1.1 Gestin de Archivos
El procesamiento de archivos es un subconjunto de las herramientas para procesar flujos de Java, las
cuales permiten a un programa leer y escribir datos en memoria, en archivos y a travs de conexiones de
red. Los flujos de archivos se pueden utilizar para la entrada y salida de datos, ya s ea como caracteres o
bytes.

Los archivos que se crean usando flujos basados en caracteres se conocen como archivos de texto. Los
archivos de texto se pueden leer con editores de texto, mientras que los archivos que se crean usando flujos
basados en bytes se conocen como archivos binarios.

Para el manejo de archivos en Java utilizamos clases de paquete java.io, estas clases nos permitirn lo
siguiente:

FileInputStream (para la entrada basada en bytes desde un archivo).

FileOutputStream (para la salida bas ada en bytes hacia un archivo).

FileReader (para la entrada basada en caracteres desde un archivo).

FileWriter (para la salida basada en caracteres hacia un archivo

Los archivos se abren creando objetos de estas clases de flujos, que heredan de las clases
InputStream, OutputStream, Reader y Writer.

Tambin revisamos que La clase File, que es especialmente til para recuperar informacin acerca de un
archivo o directorio de un disco.

A continuacin, revisemos un ejemplo realizado en clases:

Tenemos a continuacin el siguiente ejercicio de Gestin de Archivos de Texto que tiene el siguiente
aspecto:
Revisaremos como funciona cada Botn, empecemos por el botn INGRESAR REGISTROS:

Llenaremos los campos que tenemos a la izquierda con los atributos correctos, estos se irn ingresando
a nuestra rea en Blanco que podemos revisar en el formulario (como extra le hemos aadido que nos
calcule el promedio automticamente).
Seguiremos con el Botn Guardar Registros:

Al darle click en este botn, se nos abrir una ventana emergente dndonos a escoger la ubicacin del
computador que queremos que se nos guarde el archivo, pero hay una condicin al guardar, esta es que
el archivo para ser guardado DEBE SER: NombredelArchivo.txt o en caso contrario el documento no se
nos guardara a continuacin veremos que sucede.
El archivo de nombre Trabajo aqu no le hemos puesto .txt y nos arroja el mensaje El archivo debe
tener formato .txt

Ac le pusimos de nombre Trabajo.txt y cmo podemos revisar el archivo se guard correctamente.

El Botn Abrir Archivo los que nos hace en abrir una ventana emergente para buscar el documento
anteriormente guardado, debemos tener en cuenta que para abrir el archivo debe ser .txt sino nos saldr
el mensaje que seleccionemos el formato correcto, una vez encontrado el archivo correcto abrimos y
enseguida se nos cargaran los datos en nuestra rea para poder modificar, actualizar algn dato o ingresar
a su vez algn otro campo de otra persona como podemos visualizar a continuacin:
En el ltimo botn LISTAR REGISTROS lo que este botn nos abre una ventana emergente para poder
ingresar nuestros datos a nuestra tabla y as poder visualizar de una mejor forma ordenadamente.
1.2 Serializacion Binaria
Consiste en obtener una secuencia de bytes que represente el estado de dicho objeto. Esta secuencia
puede utilizarse de varias maneras (puede enviarse a travs de la red, guardarse en un fichero para su uso
posterior, utilizarse para recomponer el objeto original, etc.).
Simplemente s e usa para 'marcar' aquellas clases cuyas instancias pueden ser convertidas a secuencias
de bytes (y posteriormente reconstruidas). Objetos tan comunes como String, Vector o ArrayList
implementan Serializable, de modo que pueden ser serializados y reconstruidos ms tarde .

Para que un objeto sea serializable, debe implementar la interfaz j ava.io.Serializable.

Por ejemplo:

Seguidamente veremos un ejercicio propuesto en clases que tiene el siguiente aspecto y de igual manera
daremos a conocer la funcionalidad de cada uno de sus botones.
Empezaremos revisando el botn GUARDAR BINARIO.
Llenaremos los campos con sus respectivos atributos y lo que este botn har es crear un archivo .bin, al
igual que el ejercicio realizado en el taller de Gestin de Archivos, se nos abrir una ventana emergente
pidindonos el nombre del archivo; el cual debemos colocar NombreArchivo.bin o caso contrario nos
mandara una alerta que el formato NO es correcto, le pondremos de nombre Autor.bin.
Ahora veremos el botn Abrir Archivo:
En esta seccin abriremos el archivo anteriormente guardado lo que pasara es que internamente en el
programa se abrir el proyecto en el cual podemos ir agregando nuestros datos con los campos llenados .
(Cab e mencionar que no nos salta ningn mensaje que la ventana interna est ab ierta deb emos ser
precavidos con esta informacin).

El archivo se encuentra abierto en una ventana interna.

A continuacin revisaremos el Botn Agregar Registros:

Como tenemos la ventana del archivo Autor.bin abierta lo que el botn hace es ir ingresando los datos que
vamos llenando y guardndolos.
El penltimo botn a revisar es el CERRAR:
Aqu lo que vamos a cerrar es la ventana interna que hemos abierto previamente, es decir ya no
ingresaremos ms datos y acabaremos con los datos que hemos ingresado; debemos estar atentos ya que
NO nos manda ningn mensaje que ha sido cerrado internamente, nosotros debemos estar pendientes de
aquello.

Finalmente el botn Cargar Datos:

Aqu lo que haremos es llamar a nuestro Autor.bin y cargarlo en nuestra tabla.
1.3 Serializacion XML
Para la serializacion utilizamos la librera SIMPLE
Consiste en un proceso de codificacin de un objeto en un medio de almacenamiento (como puede ser un
archivo, o un buffer de memoria) con el fin de transmitirlo a travs de una conexin en red como una serie
de bytes o en un formato humanamente ms legible como XML o JSON, entre otros.

Serializar un objeto en un documento XML es un proceso simple. Se trata de dos pasos:

1. Crear los objetos con sus apropiadas anotaciones, estas anotaciones le dicen a persister como debe
serializar el objeto.
2. Crear un procedimiento en consola que permita realizar el proceso de serializar para los cual se requiere
un Persister. A continuacin, el objeto persister recibe una instancia del objeto anotado y un resultado de
salida, que es un archivo de este ejemplo.

Por ejemplo:

Veremos un ejemplo que tuvimos de prueba en el presente ciclo que tiene la siguiente estructura
Tendremos que identificar cules son los elementos y atributos para poder asignarles las correspondientes
anotaciones .
Entendamos mejor que son atributos y elementos o en que se diferencian con un ejemplo de msica.

Elementos
Los elementos son los componentes bsicos que estructuran los datos. Cada elemento tiene una etiqueta
de inicio (como <MSICA>) y la etiqueta final (</ MSICA>). Cada archivo XML contiene un elemento raz
(<MSICA>), y todas las vidas de contenido de archivos dentro del elemento raz. Dentro del archivo, los
elementos se describen como miembros de la familia. Cada elemento puede ser un padre, hijo o hermano.
El elemento PISTAS es un hijo del elemento LBUM, padre del elemento TRACK y un hermano del
elemento TITLE. Cada una de estas relaciones permite que el desarrollador, as como el programa que lee
o escribe los datos, para entender cmo los elementos de datos se relacionan entre s. Sabemos que los
datos describe un lbum realizado por The Eagles con varias pistas de msica.

Atributos
Los atributos son los descriptores colocados dentro de las etiquetas. En el ejemplo, los elementos TRACK
cada uno tienen atributos nombre y la hora. Los datos tampoco se puede n encapsular dentro de un elemento
o aparecen como atributos. La eleccin depende de la promotora y no hay manera correcta o incorrecta de
hacer esto.

Una vez identificados los elementos y atributos vmonos a crear el archivo XML propuesto, hemos visto y
construido sus campos con 2 botones que analizaremos enseguida.

Botn GENERAR XML:

Este boton nos guarda el archivo en la forma propuesta que mencionamos arriba, arrojandonos un mensaje
que guardemos en la extension correcta .xml

Para serializar una instancia del objeto anterior se requiere un Persister. A continuacin, el objeto persister
recibe una instancia del objeto anotado y un resultado de salida, que es un archivo de este ejemplo. Otros
formatos de salida son posibles con el objeto persister.
El proceso de deserializacin XML se describe en el fragmento de cdigo que se muestra a continuacin.
Como se va observar, el proceso de deserializacin es igualmente sencillo. El persister recibe la clase
que representa el objeto serializado y la fuente del documento XML. Para deserializar el objeto se utiliza
el mtodo de lectura, que produce una instancia del objeto anotado. Adems, tenga en cuenta que no es
necesario emitir el valor de retorno del mtodo de lectura como el mtodo es genrico.
El segundo y ltimo botn ABRIR XML:

Este botn nos permite recoger todos los datos de sus respectivas clases en orden en las que fueron
llamadas, nos lista los datos en nuestra rea en blanco de la siguiente manera:

2. Bloque N2
2.1 Componentes Grficos
En este tema hemos retroalimentado temas como:

Diseo de Formularios desde Cdigo(Este tema fue nuevo e interesante ya que aprendimos ms
sob re el desarrollo interno y como funciona cada elemento dentro de un formulario desde una
 etiqueta o el tamao de la tab la hasta poder copilar un programa entero de clculo de horas en
minutos)

Este cdigo hace lo siguiente:

- Usa el mtodo setTitle de la ventana para definir el texto de la b arra de ttulo.
- Usa el mtodo setSize de la ventana para definir un tamao de 500x300.
- Usa el mtodo setLocation de la ventana para definir la posicin de la ventana en la posicin
(100,100) de la pantalla.

Importacin de la lib rera para el ob jeto JLab el,JButton,JTextField que define las
etiquetas,b otones y campos de textos.

En l cdigo a continuacin se construye la etiqueta declarada antes con el nomb re etiNum2 por ejemplo..
Luego se le asigna el texto Nmero 2:, luego se usa el mtodo setBounds para situarla en la posicin (10,
60) y asignarle un ancho de 100 y un alto de 20. Finalmente se aade la etiqueta al panel de contenidos de
la ventana.
Podemos decir que es posible prescindir de la ventana de diseo y realizar todo el diseo de la ventana
programando.
El diseo de la ventana se tiene que hacer en el constructor de la clase.
Los componentes de una ventana son variables globales cuyo tipo se correspo nde a distintas clases de
objetos: JLabel, JTextField, JButton, etc...
Para construir un objeto hay que declararlo como una variable global:
TipoObjeto NombreObjeto; y luego, dentro de la clase, construirlo, usando la siguiente sintaxis:
NombreObjeto = new TipoObjeto();
Luego se pueden usar distintos mtodos del objeto para trabajar con l.

Cuadros de Verificacin
Los cuadros de verificacin (JCheckBox) se usan cuando quieres seleccionar varias op ciones.

a. Se crea una variable de cadena llamada mensaje.

b. En esa variable se introduce el texto Animales elegidos:
c. Luego, compruebo si est seleccionada la casilla de verificacin chkPerro. Si es as concateno a la
cadena mensaje la palabra Perro.
d. Luego compruebo si est seleccionada la casilla de verificacin chkGato y hago lo mismo.
e. Lo mismo con la casilla chkRaton.
f. Finalmente presento la cadena mensaje en la etiqueta etiResultado.

Botones de Opcin:
-Los botones de opcin, tambin llamados botones de radio (JRadioButton) se usan cuando
quieres que el usuario pueda elegir una opcin de entre varias.
-Es interesante que los botones de radio aparezcan dentro de un panel JPanel. Se recomienda
colocar un borde al panel.
-Es totalmente necesario aadir un objeto del tipo ButtonGroup, y hacer que los botones de radio
pertenezcan a dicho grupo. En caso contrario, ser posibl e activar varios botones de opcin a la
vez.
a. Se crea una variable de cadena llamada mensaje.
b. En esa variable se introduce el texto Color elegido:
c. Luego se comprueba que opcin est seleccionada, usando el mtodo isSelected de los botones de
opcin. Este mtodo te dice si un botn est seleccionado o no.
d. Segn la opcin que est seleccionada, se aade un texto u otro a la c adena mensaje.
e. Finalmente se muestra la cadena mensaje en la etiqueta etiResultado.

Cuadros de Lista
El objeto JList permite crear cuadros de lista. Estos objetos contienen una serie de elementos que
pueden ser seleccionados.

a. El mtodo getSelectedIndex me dice el ndice del elemento que est seleccionado.

b. Por ejemplo, si est seleccionado el primero el ndice es 0, si est seleccionado el segundo el
ndice es 1, etc.
c. Si este mtodo devuelve -1, entonces es seal de que no hay ningn elemento seleccionado.
d. Aprovecho esto para mostrar un mensaje indicando lo sucedido.
 Cuadros Combinados
Los combos son listas desplegables donde se puede elegir una de l as opciones propuestas.
Los combos pueden funcionar tambin como cuadros de textos, si se activa la opcin editable.

a. Crea una variable de cadena.

b. Concatena dentro de ella el mensaje El color elegido es con el color seleccionado.
c. Observa el mtodo getSelectedItem, se usa para saber el elemento seleccionado del combo. Es
necesario convertirlo a texto con toString.
d. Finalmente se coloca el mensaje en la etiqueta.

Modelos de Cuadros de Lista

a. Lo que hace cada botn es rellenar el cuadro de lista con una serie de nombres. En el caso del
botn Curso 1, la lista se rellena con los nombres Juan, Mara y Luis, mientras que en el cas o del
botn Curso 2, la lista se rellena con los nombres Ana, Marta y Jose.

b. El contenido de un cuadro de lista es lo que se denomina un modelo. El modelo es un objeto

que contiene el listado de elementos de la lista.

c. Los modelos de las listas son objetos del tipo DefaultListModel.

d. Lo que hace el programa es crear un modelo. Luego rellena el modelo con datos, y finalmente
asocia el modelo al cuadro de lista. Veamos cmo se hace todo esto.
e. Primero se crea el modelo, a travs de la siguiente instruccin.

f. El modelo tiene un mtodo llamado addElement que permite introducir datos dentro de l. As
pues, usamos este mtodo para aadir los datos al modelo.
g. Finalmente asociamos el modelo.
 ToggleButtons

a. Primero se crean variables doubles (ya que se admitirn decimales) para poder hacer los clculos.

b. Se extraern los datos de la ventana y se almacenarn en dichas variables. Para ello, hay que convertir
desde cadena a double:
c. Una vez obtenidos los datos en forma numrica, ya se pueden hacer clculos con ellos. El programa
declara una nueva variable precio_total donde se introducir el resultado. En primer lugar, se introduce en
esta variable el precio base.
d. A continuacin, se le suma al precio_total los precios de los extras si el botn correspondiente est
seleccionado. Esto se hace a travs de if.
Esto significa: Si el botn instalacin est seleccionado, aade al precio total el precio por instalacin
Observa el uso del mtodo isSelected para saber si el botn tbtnInstalacion ha sido seleccionado.
e. Finalmente, el resultado s e muestra en la etiqueta de total.
 Mens Emergentes

El evento mouseClicked
El evento mouseClicked es capaz de capturar un clic del ratn sobre un determinado elemento de
la ventana.
Este evento recibe como parmetro un objeto del tipo MouseEvent, y gracias a l se puede
conseguir informacin como la siguiente:
- Qu botn del ratn fue pulsado.
- Cuantas veces (clic, doble clic, etc)
- En qu coordenadas fue pulsado el botn.
- Etc.

Se puede usar esta informacin para saber por ejemplo si se puls el botn derecho del ratn, y
sacar en este caso un men contextual en pantalla.

Este cdigo significa lo siguiente:

- El mtodo show le da la orden al menuEmergente para que se muestre.

- El mtodo show recibe tres elementos: por un lado, la ventana donde acta (this)
- Por otro lado, la posicin x donde debe mostrarse el men. Esta posicin es aquella donde se puls
el ratn, y se puede conseguir gracias al mtodo getX del objeto evt.
- Por ltimo, se necesita la posicin y. Esta posicin se puede conseguir gracias al mtodo getY del
objeto evt.
Es decir, decidimos mostrar el men emergente justo en l as coordenadas donde se hizo clic.
2.2 Layouts
En este tema veremos a mayor profundidad Para disear ms cmodamente las ventanas, Java
proporciona una serie de objetos denominados Layouts, que definen la forma que tendrn los elementos
de situarse en las ventanas.

As pues, un Layout define de qu forma se colocarn las etiquetas, botones, cuadros de textos y dems
componentes en la ventana que diseamos.

Diseo Libre

Con un GridLayout los elementos aparecen zonas.

Siempre aparecen dentro de la ventana aunque el tamao de esta cambie.
El diseo de la ventana viene definido por los Layouts o distribuciones.
Diseo Libre Esta distribucin viene activada por defecto en el NetBeans, y define una distribucin de
componentes en la que se respetan las distancias entre ellos cuando la ventana cambia de tamao.
AbsoluteLayout En esta distribucin el programador puede colocar cada elemento en la posicin que
desee de la ventana. Los distintos elementos mantienen su posicin, aunque la ventana cambie de tamao,
lo que puede hacer que si la ventana se reduce de tamao algunos elementos no se vean.
FlowLayout En esta distribucin los elementos se colocan uno detrs de otro. Los elementos intentarn
estar dentro de la ventana, aunque esta se reduzca de tamao.
GridLayout Esta distribucin coloca a los elementos en filas y columnas. Los elementos siempre estarn
dentro de la ventana, aunque esta se reduzca de tamao.
BorderLayout Esta distribucin coloca a los elementos en zonas. Los elementos siempre estarn dentro
de la ventana, aunque esta se reduzca de tamao.

Layouts y Paneles

-Para el diseo de ventanas muy complejas, ser suelen definir layouts que dividan en zonas el
JFrame, como por ejemplo el BorderLayout o el GridLayout.
-Dentro de cada una de dichas zonas se aade un JPanel, al que se le asigna un AbsoluteLayout,
un FlowLayout o se mantiene el Diseo Libre.
-Es posible asignar a un panel un layout de zonas, como el GridLayout, y, a su vez, introducir en
l nuevos paneles, y as sucesivamente.

Dilogos

Los Cuadros de Dilogo son ventanas simplificadas que muestran distintas opciones al usuario.
Los objetos JDialog son los que permiten la creacin y uso de cuadros de dilogo en un proyecto java.
Para visualizar un JDialog s er necesario llamar a su mtodo setVisible. Tambin son interesantes los
mtodos setSize para asignarles un tamao y setLocation para situar el cuadro de dilogo en la pantalla.
Para cerrar un JDialog ser necesario invocar a su mtodo dispose.
Existen dos tipos de cuadros de dilogo: los modales y no modales.
Los cuadros de dilogo modales no permiten que se active otra ventana hasta que el cuadro de dilogo no
se haya cerrado.
Los cuadros de dilogo no modales permiten trabajar
2.3 Eventos
Para programar eventos hay que tener en cuenta lo siguiente:

- Un evento pertenece a un objeto Oyente (Listener) o a un objeto Adaptador (Adapter)

- El objeto oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento.
Estos son los Eventos mas usados:
Veremos unos ejemplos concisos de eventos generados mediante cdigo:
Aqu hacemos una suma/resta sencilla:

Para el Botn Sumar :

a. Primero hemos creado el evento actionPerformed y se lo hemos asignado al botn. Esto lo hemos
hecho dentro del mtodo CreacionVentana. Este evento hace una llamada al procedimiento donde se
programar la respuesta al evento.

b. Luego hemos creado ese procedimiento y hemos programado en l el cdigo correspondiente a la

pulsacin del botn.
 3. Bloque N3
3.1 Introduccin a Patrones de Diseo
Los patrones de diseo son la base para la bsqueda de soluciones a problemas comunes en el desarrollo de software
y otros mbitos referentes al diseo de interaccin o interfaces.
Existen infinidad de casos en que el problema sigue el mismo patrn, solo cambia el contexto; un patrn de
diseo te propone una solucin a este tipo de problemas.

Objetivos:

Proporcionar catlogos de elementos reusables en el diseo de sistemas software.

Evitar la reiteracin en la bsqueda de soluciones a problemas ya conocid os y solucionados
anteriormente.
Formalizar un vocabulario comn entre diseadores.
Estandarizar el modo en que se realiza el diseo.
Facilitar el aprendizaje de las nuevas generaciones de diseadores condensando conocimiento ya
existente.
Asimismo, no pretenden:
Imponer ciertas alternativas de diseo frente a otras.
Eliminar la creatividad inherente al proceso de diseo.

No es obligatorio utilizar los patrones, solo es aconsejable en el caso de tener el mismo problema o similar
que soluciona el patrn, siempre teniendo en cuenta que en un caso particular puede no ser aplicable.
"Abusar o forzar el uso de los patrones puede ser un error".

Plantilla de Patrones:

Nombre del patrn: nombre estndar del patrn por el cual ser reconocido en la
comunidad (normalmente se expresan en ingls).
Clasificacin del patrn: creacional, estructural o de comportamiento.
Intencin: Qu problema pretende resolver el patrn?
Tambin conocido como: Otros nombres de uso comn para el patrn.
Motivacin: Escenario de ejemplo para la aplicacin del patrn.
Aplicabilidad: Usos comunes y criterios de aplicabilidad del patrn.
Estructura: Diagramas de clases oportunos para describir las clases que intervienen en
el patrn.
Participantes: Enumeracin y descripcin de las entidades abstractas (y sus roles) que
participan en el patrn.
Colaboraciones: Explicacin de las interrelaciones que se dan entre los participantes.
Consecuencias: Consecuencias positivas y negativas en el diseo derivadas de la
aplicacin del patrn.
 Implementacin: Tcnicas o comentarios oportunos de cara a la implementacin del
patrn.
Cdigo de ejemplo: Cdigo fuente ejemplo de implementacin del patrn.
Usos conocidos: Ejemplos de sistemas reales que usan el patrn.
Patrones relacionados: Referencias cruzadas con otros patrones.
3.2 Catalogo de Patrones de Diseo

3.3 Patrones Creacionales

Corresponden a patrones de diseo software que solucionan problemas de creacin de instancias. Nos
ayudan a encapsular y abstraer dicha creacin:

Object Pool (no pertenece a los patrones especificados por GoF): se obtienen objetos
nuevos a travs de la clonacin. Utilizado cuando el costo de crear una clase es mayor
que el de clonarla. Especialmente con objetos muy complejos. Se especifica un tipo de
objeto a crear y se utiliza una interfaz del prototipo para crear un nuevo objeto por
clonacin. El proceso de clonacin se inicia instanciando un tipo de objeto de la clase que
queremos clonar.
Abstract Factory (fbrica abstracta): permite trabajar con objetos de disti ntas familias de
manera que las familias no se mezclen entre s y haciendo transparente el tipo de familia
concreta que se est usando. El problema a solucionar por este patrn es el de crear
diferentes familias de objetos, como por ejemplo, la creacin de interfaces grficas de
distintos tipos (ventana, men, botn, etc.).
Builder (constructor virtual): abstrae el proceso de creacin de un obj eto complejo,
centralizando dicho proceso en un nico punto.
Factory Method (mtodo de fabricacin): centraliza en una clase constructora la creacin
de objetos de un subtipo de un tipo determinado, ocultando al usuario la casustica, es
decir, la diversidad de casos particulares que se pueden prever, para elegir el subtipoque
crear. Parte del principio de que las subclases determinan la clase a implementar.
Prototype (prototipo): crea nuevos objetos clonndolos de una instancia ya existente.
Singleton (instancia nica): garantiza la existencia de una nica instancia para una clase
y la creacin de un mecanismo de acceso global a dicha instancia. Restringe la
instanciacin de una clase o valor de un tipo a un solo objeto.
Model View Controller (MVC) En espaol: Modelo Vista Controlador. Es un patrn
de arquitectura de software que separa los datos y la lgica de negocio de una aplicacin
de la interfaz de usuario y el mdulo encargado de gestionar los eventos y las
comunicaciones. Este patrn plantea la separacin del problema en tres capas: la
capa model, que representa la realidad; la capa controller , que conoce los mtodos y
atributos del modelo, recibe y realiza lo que el usuario quiere hacer; y la capa vista, que
muestra un aspecto del modelo y es utilizada por la capa anterior para interactuar con el
usuario.
Veamos un ejemplo con Abstract Factory:

Escenario: nuestra empresa se dedica a darle un formato esttico especfico a los televisores LCD y
Plasma. Se ha decidido que todos los LCD que saldrn al mercado sern azules y los plasmas sern
amarillos. Una solucin simple sera en la clase Azul colocar el LCD y en la clase Amarillo colocar el Plasma
y todo funcionara correctamente. El problema radica en que el hecho de que los LCD sean azules y los
plasmas amarillos es una decisin del negocio y, como tal, puede variar (y de hecho el negocio vara
constantemente).
Por ejemplo, que pasa si maana Se agrega otro color o me cambian el color del LCD o mucho peor, qu
pasa si se crea otro producto LED y tambin se lo quiere pintar de Azul?
Para evitar un dolor de cabeza conviene separar estas familias y utilizar el Abstract Factory:

Hagamos de cuenta que tenemos dos familias de objetos:

1) La clase TV, que tiene dos hijas: Plasma y LCD.
2) La clase Color, que tiene dos hijas: Amarillo y Azul.
Ms all de todos los atributos/mtodos que puedan tener la clase Color y TV, lo importante es destacar
que Color define un mtodo abstracto:

pub lic ab stract void colorea(TV tv);

Este mtodo es la relacin que une las dos familias de productos. Dado que es un mtodo abstracto,
Azul debe redefinirlo:
pub lic void colorea(TV tv) {
System.out.println("Pintando de azul el "+ tv.getDescripcion());
}
Lo mismo ocurre con Amarillo:
pub lic void colorea(TV tv) {
System.out.println("Pintando de amarillo el "+ tv.getDescripcion());
}

Resultado:

3.4 Patrones Estructurales

Son los patrones de diseo software que solucionan problemas de composicin (agregacin) de clases y
objetos:

Adapter o Wrapper (Adaptador o Envoltorio): Adapta una interfaz para que pueda ser utilizada por una
clase que de otro modo no podra utilizarla.
Bridge (Puente): Desacopla una abstraccin de su implementacin.
Composite (Objeto compuesto): Permite tratar objetos compuestos como si de uno simple se tratase.
 Decorator (Decorador): Aade funcionalidad a una clase dinmicamente.
Facade (Fachada): Provee de una interfaz unificada simple para acce der a una interfaz o grupo de
interfaces de un subsistema.
Flyweight (Peso ligero): Reduce la redundancia cuando gran cantidad de objetos poseen idntica
informacin.
Proxy: Proporciona un intermediario de un objeto para controlar su acceso.
Module: Agrupa varios elementos relacionados, como clases, singletons, y mtodos, utilizados
globalmente, en una entidad nica.

Revisaremos el Patrn Decorator:

Tomemos el caso de venta de automviles y el cliente puede opcionalmente adicionar ciertos componentes
(aire acondicionado, mp3 player, etc.). Por cada componente que se adiciona, el precio vara.

Bueno hemos creado clases Ford y Fiat hasta aqu clases comunes de negocio: una interface que
implementa la clase Auto y dos tipos de Auto (Ford y Fiat). Ahora veremos en qu consiste el Decorator y
los decoradores:

Esta decoracin repetimos en Mp3,Aire Acondicionado,Gasoil,etc.

Resultado:

3.5 Patrones de Comportamiento

Se definen como patrones de diseo software que ofrecen soluciones respecto a la interaccin y
responsabilidades entre clases y objetos, as como los algoritmos que encapsulan:

Chain of Responsibility (Cadena de responsabilidad): Permite establecer la lnea que deben llevar los
mensajes para que los objetos realicen la tarea indicada.
Command (Orden): Encapsula una operacin en un objeto, permitiendo ejecutar dicha operacin sin
necesidad de conocer el contenido de la misma.
Interpreter (Intrprete): Dado un lenguaje, define una gramtica para dicho lengua je, as como las
herramientas necesarias para interpretarlo.
Iterator (Iterador): Permite realizar recorridos sobre objetos compuestos inde pendientemente de la
implementacin de estos.
Mediator (Mediador): Define un objeto que coordine la comunicacin entre objetos de distintas clases,
pero que funcionan como un conjunto.
Memento (Recuerdo): Permite volver a estados anteriores del sistema.
Observer (Observador): Define una dependencia de uno-a-muchos entre objetos, de forma que cuando
un objeto cambie de estado se notifique y actualicen automticamente todos los objetos que dependen
de l.
State (Estado): Permite que un objeto modifique su comportamiento cada vez que cambie su estado
interno.
Strategy (Estrategia): Permite disponer de varios mtodos para resolver un problema y elegir cul
utilizar en tiempo de ejecucin.
Template Method (Mtodo plantilla): Define en una operacin el esqueleto de un algoritmo, delegando
en las subclases algunos de sus pasos, esto permite que las subclases redefinan ciertos pasos de un
algoritmo sin cambiar su estructura.
Visitor (Visitante): Permite definir nuevas operaciones sobre una jerarqua de clases sin modificar las
clases sobre las que opera.

Revisaremos el patrn Iterador a continuacin:

Resultado:
EXPLICACIN:

Al inicio del programa creamos un objeto de tipo AgregadoConcreto (que contiene el vector que
deseamos recorrer) para luego obtener una instancia de IteradorConcreto (en la que se
encuentran definidos los mtodos que utilizaremos para ello).

A continuacin nos situamos en el primer elemento del vector, nos desplazamos do s posiciones
ms adelante y volvemos al primero para finalmente recorrerlo por completo mientras mostramos
los elementos en cada una de sus posiciones.

Observa que cada vez que se llama al mtodo siguiente() de IteradorConcreto devuelve realmente
el valor en la posicin actual y luego incrementa el ndice de la posicin actual (las posiciones
comienzan desde cero).

Conclusiones
En este ciclo he aprendido todo lo revisado en este ensayo de una manera fuerte y concisa y me ha
ayudado mucho en mis metas personales y profesionales gracias al Docente que con su mtodo de estudio
que realmente dan sus frutos.
Mediante la tcnica aprendida en el presente curso podemos establecer una solucin primitiva de un
problema real, tan solo con relacionarlo con objetos lgicos que sern us ados para el desarrollo del
software.
Tenemos los conocimientos necesarios como para enfrentar un problema real, sabemos las formas de
lograr un mejor rendimiento del equipo a controlar y aplicar soluciones sencillas, de manera que sea
fcilmente digeribles para el usuario y/o destinatario del trabajo final.