1

Programación orientada a Objetos

Módulo 1: Desarrollo programacional
Autor: Mauricio Vergara
 2

INTRODUCCIÓN

Este segundo módulo del curso de programación orientada a objetos, tiene como objetivo
principal extender los conceptos vistos en el primer módulo del curso y ver de forma más
cercana y detallada los elementos de programación orientada a objetos.

Para ello haremos un recorrido por algunos de los elementos claves del lenguaje Java que
permiten desarrollar e implementar una aplicación con base en el paradigma de la
programación orientada por objetos. Dividiremos el modulo en tres secciones. La primera
de ella discutirá algunos elementos metodológicos para poder definir y diseñar una
aplicación orientada por objetos, deteniéndonos especialmente en el enfoque UML
desarrollado en la mitad de la década de los 90’s y cuyo uso ha adquirido dimensiones
importantes en el mundo del desarrollo de software. La segunda sección la dedicaremos a
revisar algunos de los cuadros referenciales para desarrollo de interfaces utilizando librerías
tales como JWT y SWT. Para ello continuaremos con el desarrollo de nuestro ejemplo del
módulo 1 (Aplicación de tablero mágico), no sin antes revisar algunas de las clases
pertenecientes al cuadro referencial SWT (Standard Widget Toolkit) equiparables a
aquellas utilizadas en la construcción de nuestra aplicación pero pertenecientes al cuadro
referencial JWT (Java Web Toolkit).

En la última sección dedicaremos nuestra atención a la explicación un poco más detallada

de algunas clases que nos permiten manejar los datos dentro de nuestras aplicaciones a
través del uso de archivos o con elementos básicos de bases de datos.

Este segundo módulo nos permitirá adentrarnos de forma práctica en el desarrollo de

aplicaciones usando los conceptos del enfoque de orientación a objetos.

Se espera que las actividades diseñadas soporten y brinden la oportunidad al estudiante de

afianzar su comprensión y facilitar el uso práctico de las clases básicas de java y de las
librerías graficas tales como: JWT y SWT. Esto prepara el terreno para el desarrollo de
aplicaciones más complejas en el módulo 3.

COMPETENCIAS DE LA ASIGNATURA

Competencias de la asignatura

➢ Entender los conceptos fundamentales de encapsulamiento, herencia y polimorfismo

➢ Identificar algunas técnicas de modelamiento para el desarrollo con orientación a
objetos
➢ Comprender el uso de librerías graficas para el desarrollo de interfaces (JWT, SWT)
 3

➢ Desarrollar las competencias para la utilización de las clases pertenecientes a la

librería GWT

IDEOGRAMA ................................................................................................................................................................ 3
1. TÉCNICAS DE DISEÑO PARA PROGRAMACIÓN ORIENTADA A OBJETOS ............................................................. 4
1.1 CICLOS DE DESARROLLO DE INGENIERÍA DE SOFTWARE .............................................................................................................................. 4
1.2 TARJETAS DE RESPONSABILIDAD DE CLASES .................................................................................................................................................. 5
1.3 LENGUAJE DE MODELADO UNIFICADO (UML) .......................................................................................................... 6
2. DISEÑO DE INTERFACES DE USUARIO USANDO POO ....................................................................................... 12
2.1 USO DE LIBRERÍAS GRAFICAS (SWING Y SWT).......................................................................................................... 12
2.2 IMPLEMENTACIONES Y EJEMPLOS ................................................................................................................................................................ 14
1.3 USO DE LIBRERÍAS GRÁFICAS PARA WEB (GWT) ....................................................................................................... 26
3. DISEÑO DE APLICACIONES DE NEGOCIOS ........................................................................................................ 30
3.1 APLICACIONES CON USO DE BASES DE DATOS ............................................................................................................................................. 31
 4

Ideograma
Ciclos de
desarrollo de
Ingenieria de
Software

Tarjetas de
Responsabilidad
de Clases

Lenguaje de
Modelado Unificado
(UML)

Uso de librerias
gráficas

Implementacion y
Ejemplos

Uso de Librerias
para Web GWT
 5

1. Técnicas de diseño para Programación Orientada a Objetos

A lo largo de la historia del desarrollo de software aquellas personas dedicadas a estas

labores han visto unas veces como artistas, otras como artesanos sin muchas veces haber
aplicado principios rigurosos de Ingeniería. Solamente hasta finales de la década de los
sesenta y principios de los setenta, se comenzó a discutir seriamente el uso de los
métodos formales de la matemática y la ingeniería al desarrollo de software. Algunos
intentaron sistematizar y formalizar la difícil tarea de la escritura de software, mientras que
otros intentaron aplicar las técnicas de gerencia de proyectos para organizar y encuadrar
las actividades de desarrollo de software. Paulatinamente se forjó un cuadro referencial de
prácticas que permiten ahora considerar el desarrollo de software como una aplicación
sistemática de principios y reglas para el mismo. Con su aplicación, se asegura en buena
medida la entrega de los proyectos de desarrollo de software oportunamente, de acuerdo
con los presupuestos fijados previamente y en gran manera con la calidad adecuada.

1.1 Ciclos de desarrollo de Ingeniería de Software

La ingeniería de software requiere ejecutar muchas tareas, de las cuales las más
importantes son:

Análisis de requerimientos: consiste en definir claramente y sin ambigüedades los

requerimientos del software a construir. Esta actividad, se refleja en una serie de
documentos, que permiten o facilitan las etapas posteriores de diseño, construcción
y pruebas de software.

Especificación: es la tarea que permite describir el software a ser escrito,

usualmente de una forma matemática rigurosa. En efecto, las especificaciones
exitosas se escriben para entender y refinar las aplicaciones, tanto en sus interfaces
de usuario como en las interfaces que permiten que las aplicaciones puedan
interactuar con otros sistemas
.
Diseño y arquitectura: Se refiere a determinar cómo va a funcionar el software de
manera general. Usualmente se definen dos subfases: la codificación y las
pruebas.

Documentación: La más importante; pero en la práctica la más descuidada de las

actividades. Está enfocada a documentar el diseño interno de una aplicación para
facilitar el mantenimiento y la mejora futura del software.

Mantenimiento: El mantenimiento consiste, en la solución diaria de los problemas

del software construido y sus posibles mejoras. Cerca de las 2 terceras partes del
trabajo de ingeniería de software, consiste en el mantenimiento del mismo. Una parte
consiste en el arreglar fallas y otra en extender y mejorar las funcionalidades del
mismo a lo largo de su ciclo de vida.
 6

1.2 Tarjetas de responsabilidad de clases

Las tarjetas de responsabilidad de clases, son una herramienta similar a la tormenta de

ideas utilizadas en otras disciplinas la cual es usada en el diseño de software orientado por
objetos. Su conceptualización y uso, fue propuesto inicialmente por Ward Cunnigham. Se
usan específicamente, para determinar cuáles clases serán necesarias y como estarán
relacionadas.

Las tarjetas de responsabilidad de clases (CRC) se crean generalmente usando tarjetas

de índices (index cards) en las cuales se escriben:

El nombre de la clase.
El nombre del paquete (si es aplicable).
Las responsabilidades de la clase.
Los nombres de otras clases con las cuales la clase colaborará para cumplir sus
responsabilidades.

Por ejemplo consideremos la tarjeta de responsabilidades de la clase Carta de Poker en

un juego de póker:

Carta de Poker
Conocer su nivel o numero Baraja
Conocer su signo o palo (corazones, picas…) Graphics
Conocer si está destapada
Seleccionar la carta
Descubrir
Pintar

Las responsabilidades se listan a la izquierda. Las clases con las cuales la clase tiene
alguna relacion se listan a la derecha. El principio basico de esta tecnica es que el diseño
de clases se ejecute por un conjunto de desarrolladores. El equipo trata de determinar todas
las clases y sus responsabilidades que seran necesarias por la aplicación. El equipo
atravesará por varios escenarios de la misma. Por ejemplo, un escenario para el juego de
cartas puede ser aquel en que el jugador, selecciona una carta de la baraja y la sostiene
en su mano. El equipo utilizará las tarjetas CRC para constatar si el escenario puede ser
manejado por las responsabilidades asignadas a las clases. De esta manera, el diseño se
refina hasta que el equipo esté de acuerdo en un conjunto de clases y sus correspondientes
responsabilidades. Si se usa una cantidad pequeña de cartas se mantiene la complejidad
del diseño al minimo. Se pretende puntualizar en lo esencial de la clase y prevenir que entre
en el detalle que en esta fase puede ser improductivo. Tambien evita, que el diseñador
otorgue muchas responsabilidades a la clase.
 7

1.3 Lenguaje de Modelado Unificado (UML).

El lenguaje unificado de modelamiento (UML) , es un lenguaje de diagramación o notación

para especificar visualizar y documentar modelos de sistemas orientados por objetos. UML
no es un método de desarrollo, lo cual significa que no nos dice, qué actividades se deben
realizar ni en qué orden. Sin embargo, UML ayuda a visualizar el diseño y comunicarse con
los demás. Actualmente UML es controlado por el Object Management Group (OMG) y es
un estándar internacional de la industria para describir gráficamente el software.

Figura 1. Historia del Lenguaje de Modelado Unificado (UML)

Tomado de
http://upload.wikimedia.org/wikipedia/commons/thumb/d/d1/OO_Modeling_languages_history.jpg/
1024px-OO_Modeling_languages_history.jpg

La figura 1 ilustra la historia y evolución de UML.

Como se mencionó anteriormente, UML no es una metodología de desarrollo, sino una de

las técnicas de notación grafica para facilitar el diseño de un sistema orientado por objetos.
Forma parte de un proceso de ingeniería de software completo llamado Rational Unified
Process (RUP). Este, provee y guía todos los aspectos de las actividades de desarrollo de
software con el objetivo de asegurar software de alta calidad que satisfaga
 8

las necesidades de los usuarios finales dentro de un presupuesto y cronograma

disponible. Los aspectos claves de RUP son:

❖ Desarrollo de software interactivamente.

❖ Recolección, organización y gestión de requerimientos y cambios de forma
sistemática.
❖ Arquitectura orientada a componentes.
❖ Utilización de UML.
❖ Proceso de verificación continúa de software.
❖ Control de cambios de software.

En UML, se distinguen tres componentes principales del modelo del sistema:

 Modelo Funcional.
 El modelo funcional incluye muestras del funcionamiento del sistema desde el punto
de vista del usuario. El principal tipo de diagrama utilizado es el diagrama de caso
de uso (Use Case Diagram).
 Modelo de Objetos.
Consiste en un conjunto de diagramas que describe la estructura y sub- estructura
del sistema utilizando objetos, atributos, operaciones y asociaciones. Uno de los
principales diagramas utilizados es el Diagrama de clases (Class Diagram).

 Modelo dinámico.
Consiste en la descripción del comportamiento interno del sistema: Incluye diagrama
de secuencia, diagrama de actividades y diagrama de máquina de estados.

UML, se compone de diferentes elementos que representan las diferentes partes de una
aplicación o un sistema de software: En UML 2.0 existen 13 tipos de diagramas. Algunos de
los más importantes son:

❖ Diagrama de casos de uso: muestra los actores (las personas u otros usuarios del
sistema), los escenarios y sus relaciones (figura 2).
 9

Figura 2. Ejemplo del diagrama de caso de uso

Tomado de: http://es.wikipedia.org/wiki/Diagrama_de_casos_de_uso

❖ Diagramas de clase: Muestra las clases y sus relaciones entre ellas (figura. 3).

Figura 3. Ejemplo del diagrama de clases

Tomado de: https://www.google.ca/
 1
0
❖ Diagrama de secuencia: Muestra los objetos y una secuencia de las llamadas que
los métodos hacen a otros métodos (figura 4).

Figura 4. Ejemplo de diagrama de secuencia

Tomado de: https://www.google.ca/search?q=diagramas+de+secuencia

❖ Diagrama de colaboración: Muestra los objetos y sus relaciones, haciendo énfasis

en los objetos que participan en el intercambio de mensajes (Figura 5).
 10

Figura 5. Ejemplo de diagrama de colaboración

Tomado de:
https://www.google.ca/search?q=diagramas+de+colaboracion&tbm=isch&tbo=u&source=univ&sa=X&ei=-
ZrCU5XXL421yATwpIEY&ved=0CB4QsAQ&biw=1366&bih=660

❖ Diagrama de actividad: Muestra las actividades y los cambios de una actividad a

otra con los eventos que ocurren en una parte del sistema (Figura . 6).
 11

Figura 6. Ejemplo de diagrama de actividad

Tomado de: https://www.google.ca/search?q=diagramas+de+actividad

❖ Diagrama de componentes: es un diagrama que muestra los componentes de alto

nivel de un sistema (figura 7).
 12

Figura 7. Ejemplo del Diagrama de componentes

Tomado de:
https://www.google.ca/search?q=diagramas+de+componente

2. Diseño de interfaces de usuario usando POO

Después de haber examinado brevemente algunas técnicas que facilitan el desarrollo del
software orientado por objetos, enseguida se comenzará el recorrido de la programación
orientada por objetos examinando el diseño y desarrollo de las interfaces de usuario que
permiten la gestión e interacción con las aplicaciones de software construidas. Revisaremos
algunos de los cuadros referenciales que facilitan el desarrollo de interfaces y que en
último término dan la flexibilidad y posibilidad para la interacción del usuario con las
aplicaciones.

2.1 Uso de librerías graficas (Swing y SWT).

En la construcción de interfaces en java, se utilizan diferentes conjuntos de clases

denominadas comúnmente librerías. Inicialmente Java ofrecía una librería de clases para
desarrollo de interfaces llamada AWT (Abstract Window Toolkit). La estructura de la librería
se puede apreciar en la figura 8.
 13

Figura 8. Diagrama General de la estructura de clases de la librería de gráficos AWT

Tomado de: http://doc.sumy.ua/prog/java/exp/ch13_01.htm
(Por: Flanagan, David O’Reilly 2nd Edition, May 1997).

Algunas de estas clases fueron utilizadas en los ejemplos revisados en el módulo 1, por
ejemplo Canvas, FileDialog, Dialog.

Enseguida vamos a revisar, una librería que resuelve algunos problemas de compatibilidad
derivados del uso de AWT y que ha permitido la construcción de innumerables interfaces
para diferentes dominios de aplicaciones de software. En la figura 9, se muestra su
estructura general de clases.
 14

Figura 9. Estructura de clases de la librería SWT

Tomado de:
https://www.google.ca/search?q=swt+class+hierarchy

A continuación, se ilustra el uso de algunas de las clases que componen SWT y cada uno
de los estudiosos tendrá la oportunidad, a través de las actividades propuestas en este
módulo y en el siguiente de utilizarlas para la construcción de algunas sencillas aplicaciones.

2.2 Implementaciones y ejemplos

El primer ejemplo será la construcción de una ventana, en la cual se podrá utilizar

posteriormente para otros propósitos en cualquiera de nuestras aplicaciones. El listado del
código fuente se puede observar en la figura 10.
 15

Figura 10. Listado fuente del programa java para construir una ventana básica.

En este ejemplo se construye una ventana de 250pixels por 200 pixels en el centro de la
pantalla. En toda aplicación que utilice la librería grafica SWT, existen dos clases muy
importantes: Display y Shell. La clase Display brinda la conexión entre SWT y el sistema
operativo de la máquina. Ella implementa un evento cíclico y provee información acerca
 16

del sistema operativo. La clase Shell, por su parte, representa la ventana. Existen shells de
alto nivel, los cuales toman el display como su padre, mientras que otros pueden jugar el
papel de shells secundarios.

La línea 18
Shell shell = new Shell(display);

Permite crear una ventana.

La Línea 19
shell.setText(“Ejemplo de construcción de una ventana”);

Permite definir el título de la ventana.

Mientras que la línea 20

shell.setSize(250,200);

Permite determinar el tamaño de la ventana, usando el método setSize con dos

parámetros enteros que definen el ancho y el alto (Width y Heigth)

Así mismo , lo más importante del código se resume a continuación:

La ventana se muestra en la pantalla (líneas 26 a 30).
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) {
display.sleep();
}
}
Se comienza el ciclo principal. (línea 36).
org.eclipse.swt.graphics .Rectangle bds = shell.getDisplay().getBounds();
Se define la resolución de la pantalla usando el método getDisplay() Si se trabaja con
más de una pantalla, necesitara llamar el método getMonitor en vez del método
getDisplay.
 17

Se calculan las coordinadas superior e izquierda de la ventana (línea 40-41).

int nLeft = (bds.width - p.x) / 2;
int nTop = (bds.height - p.y) / 2;
Se definen los límites del shell (linea 43).
shell.setBounds(nLeft, nTop, p.x, p.y);

Se crea la pantalla (línea 53 )

Display display = new Display();

Se instancia el programa principal (línea 54)

new SWTApp(display);

y por último la línea 55 permite retornar los recursos al sistema operativo

display.dispose();

Figura 11. Pantallazo de la aplicación ejemplo de construcción de una ventana

El siguiente ejemplo, muestra la manera como se puede adicionar un tipo tool text asociado
a la ventana. Tal como se observa en la línea 21, se incluye la llamada al método
setToolTipText, el cual recibe un String como entrada. Esto permite adicionar un mecanismo
tal que al acercar o pasar el mouse por encima de la ventana aparecerá el tip text asociado
previamente definido.
 18

Figura 12. Ejemplo de la implementación de un tool tip text para una ventana.

En la figura 13 se ilustra el pantallazo con el tip tool text desplegado.

Figura 13. Ejemplo del pantallazo del uso de un tip tool text.

Enseguida se revisará la inclusión de un botón que permita salir de la aplicación. Para ello
utilizaremos la clase Button de la librería SWT. Como se puede observar en el listado del
código fuente correspondiente (Figura. 14), se incluye la implementación de un botón, el
cual se coloca en el Shell (líneas 54 y 56). Luego se invoca el método setVisible de la clase
para hacerlo visible y se adiciona un listener, el cual le da la capacidad de estar atento al
evento de click (líneas 69 – 76) del botón y responder ejecutando el código de salida (línea
73). Como se aprecia la programación orientada
 19

por objetos, permite ir adicionando diversos comportamientos, los cuales se reflejan en la

inclusión de nuevos métodos o la modificación de los ya existentes.

Figura 14. Código fuente para incluir un botón de salida de la aplicación

Fuente: Pantalla tomada directamente de Eclipse

En la figura 15, podemos apreciar la interfaz modificada incluyendo el nuevo botón de salida.

Figura 15 – Interfaz con botón de salida

Fuente: Pantalla directamente tomada de Eclipse

El siguiente ejemplo, muestra cómo implementar un dialogo para manejo de archivos

utilizando varios elementos de la librería SWT. En el primer módulo se tuvo la oportunidad
de estudiar un ejemplo que involucraba el manejo básico de archivos en cuanto era
necesario guardar el rastro de las acciones efectuadas con en la aplicación del Tablero
Mágico. Allí utilizábamos clases FileOutputstream, FileInputStream para manejar de manera
básica la escritura de las mismas y poder guardar el estado de la aplicación.

En esta corta pieza de código, se ilustra el uso de la clase DirectoryDialog, la cual permite
abrir de manera transparente un dialogo y manejar o gestionar los archivos. El
 20

listado fuente de la aplicación se ilustra en la figura 16. Utilizamos los elementos ya vistos,
como el uso de la clase Shell y Display. Al interior del Shell, estamos incluyendo un botón
llamado status, el cual tiene un listener asociado que permite detectar las acciones
efectuadas con el mouse, específicamente la acción MouseDown (click). Al ser accionado
el mouse (click o doble-click), se ejecuta el código del listener, el cual es sencillamente la
instanciación de un objeto de tipo DirectoryDialog, que abre una ventana mostrando la
jerarquía de directorios del equipo donde esté siendo ejecutada la aplicación. Se aprecia
que, esta clase va a permitir al usuario seleccionar un directorio o definir uno nuevo y al
interior del código se actualiza la propiedad Text del botón status, o dejarla intacta si el
usuario prefiere darle clic a la opción cancel. Esta pieza de código puede ser de mucha
utilidad en diversas aplicaciones donde la selección de archivos es usada frecuentemente.
Figura 16. Listado fuente de una aplicación para manejo de directorios.
 21

Pantalla directamente tomada de Eclipse

La figura 17, muestra la interfaz principal de esta sencilla aplicación, mientras que la figura
18 muestra el diálogo abierto cuando el usuario da clic en el botón. Es necesario hacer notar
el uso de una imagen asociada con el botón status. Las líneas 56 a 58 del programa definen
y determinan dónde reside el recurso de la clase Image que finalmente será asociado en la
línea 70. Con este procedimiento el programador podrá asociar no importa que recurso
grafico (iconos, archivos jpg , gif etc) a un objeto tal como un botón , un label, una ventana,
un menú de aplicación etc.
 22

Figura 17. Interfaz de una aplicación con un botón para manejo de directorios.

Fuente: pantalla tomada directamente de Eclipse

Figura 18. Interfaz para el manejo de directorios utilizando la clase SWT DirectoryDialog
 23

Fuente: pantalla directamente tomada de Eclipse

Un ejemplo complementario que ser revisará a continuación, consiste en el manejo de

archivos. En la librería de clases de SWT, existe la clase FileDialog, que a diferencia de la
clase DirectoryDialog, pretende facilitar la selección de un archivo específico dentro de
una carpeta o un folder dado. La figura 19, muestra el código fuente de la pieza de software,
que permite implementar este tipo de manejo de archivo. En este caso, se ha incluido una
etiqueta (class Label) para mostrar un título de la aplicación (línea 55), y luego se incluye
un listener directamente enlazado o asociado con el Shell, de ahí que el usuario solamente
tendrá que dar clic dentro de la ventana de la aplicación para poder acceder a la selección
del archivo. Como se puede apreciar, al interior del listener se instancia un objeto de la clase
FileDialog y un arreglo de objetos String que servirán de comodín para filtrar el tipo de
archivos a seleccionar. Como se aprecia el listener permite disparar la apertura de una
ventana de dialogo para seleccionar un archivo. El usuario podrá escoger un archivo o dar
cancel y quedar en el mismo estado previo al clic en la ventana principal. En este caso se
puede hacer uso de dos tipos de filtros, uno para los nombres de archivo y otro para filtrar
el tipo de extensión que la ventana muestra por omisión. Evidentemente, en una aplicación
compleja todos estos pueden ser parámetros que dependerán de las especificaciones de
las interfaces a diseñar.

Figura 19. Listado de código fuente para la implementación de manejo de archivos utilizando la
clase FileDialog de la librería SWT
 24

Fuente: Listado tomado directamente de la aplicación Eclipse

 25

Las Figuras 20 y 21 ilustran el comportamiento de la aplicación en su ventana principal y su

ventana secundaria cuando el usuario da clic para seleccionar un archivo en un computador.
Figura 20. Ventana principal de la aplicación para manejo de archivos

Fuente: Pantalla tomada directamente de Eclipse

Figura 21. Interfaz para el manejo de archivos utilizando la clase SWT FileDialog

Fuente: Pantalla tomada directamente de Eclipse

 26

En el módulo 3 se incluirán más ejemplos y se continuará con el ejemplo del módulo 1, pero
incluyendo algunas complejidades en el modelo de objetos y obviamente en el
comportamiento de la aplicación del Tablero Mágico. En la siguiente sección se enfocará la
atención en describir brevemente la librería GWT y sus aplicaciones, para finalmente tocar
el desarrollo de aplicaciones comerciales que manejen el concepto de bases de datos.

1.3 Uso de librerías gráficas para web (GWT).

La aparición de Internet y su desarrollo vertiginoso en los últimos años ha llevado los

desafíos en el desarrollo de software a sobrepasar nuevos limites. Nuevos jugadores claves
han aparecido en la industria. Ya no son compañías tradicionales como IBM, SUN,
ORACLE etc., las que lideran la industria del desarrollo de software sino son nuevos
gigantes que allegan nuevas corrientes tecnológicas y nuevas formas de generación de
valor agregado en torno a la construcción y desarrollo de software para diversos ámbitos y
terrenos. Compañías como Google, Facebook, Amazon, Twitter plantean nuevos
paradigmas y llevan discusiones en torno a temas tales como: Big Data, Web Semánticas,
Relocalización, Bases de datos NoSql, computación en la nube etc.
Estas y otras compañías, han comprendido la necesidad de crear nuevos cuadros
referenciales y nuevas herramientas para facilitar el desarrollo a la comunidad tecnológica.
En este marco, surgen necesidades de herramientas para desarrollar interfaces orientadas
a la Web y allí se localiza Google Web Toolkit como un entorno de desarrollo Java, basado
en Software libre que permite escribir aplicaciones utilizando la tecnología AJAX de manera
mucho más eficiente.

A continuación revisaremos los primeros pasos para crear un ejemplo sencillo de una
aplicación que utilice la librería GWT.

En primera instancia se debe descargar y configurar el plugin de GWT: Eclipse. Vease:

http://www.vogella.com/tutorials/GWT/article.html#overview_gwt para el proceso de
instalación), luego se crea un proyecto de tipo GWT. Para ello estando en Eclipse, utilice la
secuencia File->New->Project y seleccione el tipo de proyecto Google – Web Aplication
Project , tal como aparece ilustrado en la figura 22.
 27

Figura. 22 Uso de eclipse para crear un proyecto usando GWT

Luego, de clic en la opción next y diligencie el nombre del proyecto y el nombre del
paquete según su necesidad. (Figura 23)

Figura 23. Pantalla de selección del nombre del proyecto y nombre del paquete para la creación
de un proyecto de tipo GWT.
 28

Fuente: Pantalla tomada directamente de la aplicación Eclipse

Una vez este seguro de su información, de clic en finish para ejecutar la creación del
proyecto.

Figura 24. Estructura de archivos para el proyecto GWT-ejemplo que utiliza la librería GWT.

Fuente: pantalla tomada directamente de Eclipse

Al finalizar la ejecución de las tareas al interior de eclipse, se generaran una serie de

archivos que tendrán la estructura como se ilustra en la Figura 24. Fundamentalmente,
Eclipse genera un conjunto de archivos fuente java, tal como se ilustra en la figura 25.
 29

Figura 25. Archivos fuente .java y archivos de configuración generados al crear el proyecto GWT-
ejemplo usando Eclipse y la librería GWT.

Fuente: pantalla tomada directamente de Eclipse

Como se puede apreciar, se trata de algunos archivos localizados en un paquete test.client,

otros localizados en test.server y los archivos de configuración de la aplicación situados
en el folder META-INF.

La forma cómo funciona el desarrollo de interfaces usando GWT consiste básicamente en

la escritura de código usando el lenguaje java convencional, que en instante de ejecución
(runtime) es traducido a Javascript y HTML, el cual finalmente es el contenido que se publica
y aloja en el servidor web que ejecutara la aplicación. Si bien el mecanismo es algo
complejo y de tipo caja negra, facilita a aquellos desarrolladores java escribir interfaces
utilizando el lenguaje convencional tal como si fuera una aplicación convencional, pero con
la particularidad de poder ser ejecutada en un ambiente web utilizando cualquier tipo de
navegador. En cursos posteriores de desarrollo Web, los estudiosos profundizaran en el
uso de este cuadro referencial para desarrollar aplicaciones y sistemas para Internet.

Al ejecutar la aplicación, esta será ejecutad directa o indirectamente en un browser tal como
Internet Explorer, Firefox etc. y se visualizará como se ilustra en la figura 26.
 30

Figura 26. Ejecución de la aplicación ejemplo GWT- Ejemplo1

Fuente: pantalla tomada directamente de Eclipse

El estudioso notará que la aplicación utiliza un browser y evidentemente el protocolo http

propio de las aplicaciones web convencionales. Sin embargo, el esfuerzo de codificación,
sobre todo para las fases iniciales de un proyecto, puede llegar a reducirse
considerablemente. Esto redundara en el hecho que el equipo de desarrollo de software,
puede destinar mucho mayor tiempo al análisis y concepción de la aplicación que a la
escritura misma de código.

3. Diseño de aplicaciones de negocios

A continuación vamos a revisar el proceso de desarrollo de aplicaciones OO enfocadas a

solucionar problemas de negocios usando el concepto de persistencia de datos (bases de
datos). Para ello, vamos a pensar en una aplicación sencilla, que nos permita de manera
muy rudimentaria acceder a tres tablas de un sistema de registro académico también muy
incipiente. Cuando se habla de tablas la referencia es hacia un conjunto de filas y columnas
de datos que nos permiten representar la información. Para este caso, se tratará de las
tablas course, student y la relación entre ellas student_course. En la figura 27, se encontrará
el listado de dichas tablas, que han sido creadas utilizando la herramienta DbVisualizer.
 31

Figura 27. Listado de las tablas para una aplicación OO ejemplo que use persistencia de datos.

3.1 Aplicaciones con uso de bases de datos.

El objetivo de esta aplicación, será simplemente poder crear registros para las tablas curso
y estudiante, así como crear la relación que determine quién (estudiante) está registrado en
cual curso.
 32

Figura 28. Estructura de clases de la aplicación ejemplo para manejar de forma básica la
creación de estudiantes

Para facilitar la comprensión, en este modulo solamente se revisará aquello que compete
a la creación de los registros en la tabla de estudiantes, para posteriormente en el modulo
3 ampliar nuestro ejemplo y poder mirar de manera más detallada la creación de cursos y
el registro de un estudiante para un curso.

Tal como se muestra en la figura 28, se han creado dos componentes básicos (paquetes)
, uno que comprende todas las clases que permiten hacer la conexión con la base de datos,
seleccionar alguna de las tablas (ConnectionManager, ConnectionManagerImplementer,
DataAccessHelper, SqlExecutor y
SqlExecutorInterface ), crear un mecanismo de auditoría de la aplicación
(LoggerHelper.java) y otro que propiamente permitirá manejar la interfaz con el usuario para
poder capturar la información y actualizarla adecuadamente en el sistema.
 33

Figura 29. Listado fuente de la clase EmalisTestSuiteServices que maneja la gestión de inserción
de estudiantes para la aplicación ejemplo.
 34

Fuente: pantalla tomada directamente de la aplicación Eclipse

El listado fuente de la interfaz (emalisTesSuiteServices.java), que permite gestionar la

creación y consulta de estudiantes se ilustra en la Figura 29. Como se aprecia nuestra clase
posee cuatro atributos: conection, daoGeneralCalls, DataOperationsDriver y LoggerHelper,
así como 4 métodos: el constructor de la clase, el método createStudent, el método
getTableNextId y el método getStudentName. A su vez, cada atributo es una clase
especifica que participa de forma específica en alguna de las funciones: crear la conexión
a la base de datos, hacer el llamado para la operación en una tabla especifica de la base
de datos, ejecutar una operación especifica de acceso o actualización de datos y dejar la
huella o trace dentro del log de la aplicación. Así mismo, cada método da cuenta de un
comportamiento específico de nuestra clase: creación del registro del estudiante, búsqueda
del siguiente identificador único para cada estudiante y la consulta de un estudiante con una
identificación específica. Como podemos apreciar directamente, la interfaz dá una idea del
comportamiento de la clase pero el funcionamiento especifico y detallado es implementado
haciendo uso de clases auxiliares que no ofrecen un acceso público (principio de
encapsulamiento de información). El anterior ejemplo ilustra de manera sencilla y básica
como se aplica el concepto de orientación a objetos en el desarrollo de software. El módulo
3, nos permitirá avanzar un poco más en la comprensión de la aplicación del paradigma
OO para el desarrollo de aplicaciones comerciales con persistencia de datos y manejo de
interfaces de usuario.
 35

Glosario

Ciclo de desarrollo de Ingeniería de Software : Consiste en un conjunto de etapas a

cumplir para poder desarrollar una aplicación de software o todo un sistema de información.

Análisis de requerimientos: Es una de las etapas más importantes del ciclo de desarrollo
de software. Esta etapa consiste en determinar los diferentes elementos de información
necesarios para el desarrollo de una aplicación o un sistema de información a través del
uso de diferentes técnicas y herramientas metodológicas. Esencialmente esta etapa
involucra como actividades: recolección de información, análisis y determinación de
requerimientos y documentación de requerimientos.

Especificación de requerimientos: Es una fase del ciclo de desarrollo de un sistema,

consistente en precisar los elementos principales del sistema, su comportamiento, sus
relaciones y elementos no funcionales tales como elementos de desempeño, estándares de
calidad y restricciones.

Tarjeta de responsabilidad de clases: Es una de las técnicas del análisis Orientado a

Objetos, que nos permite determinar inicialmente las diferentes clases que van a conformar
un sistema de información.

Lenguaje de Modelado Unificado (UML): Es un lenguaje grafico que permite visualizar,

especificar, construir y documentar un sistema.

Modelo Funcional: Es un conjunto de diagramas utilizado en UML, que comprende

muestras del funcionamiento del sistema desde el punto de vista del usuario. EL principal
tipo de diagrama utilizado es el diagrama de caso de uso ( Use Case Diagram ).

Modelo de Objetos: Es un conjunto de diagramas que describe la estructura y sub

estructura del sistema utilizando objetos, atributos, operaciones y asociaciones. Uno de los
principales diagramas utilizados es el Diagrama de clases ( Class Diagram ).
 36

Bibliografía

Libros

Eck, David J. Object Oriented Programming. School of Computer Science

University of KwaZulu-Natal 2007.

Xiaping, Zia. Objected-Oriented software Development Using Java. Editorial Addison-

Wesley, 2003

Mejia , Javier. Manual de GWT. España License de Creative Commons

Larman , Craig. UML 2 et les design patterns. Ed. Pearson 2005

Poo, D , Kiong, D y Snwaralatha, D. Object Oriented Programming. Ed. Springer 2008.

Internet

Bodnar , Jan. The Java Swing layout management tutorial. En http://www.zetcode.com

Vogel,Lars. Manual de GWT. 2008. En: http://www.vogella.com/tutorials/GWT/article.html