1

Programación orientada a Objetos

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

Introducción

Competencias de la asignatura

➢ Entender el paradigma de la programación orientada por objetos

➢ Identificar los elementos conceptuales principales de la aplicación de los principios
de la programación orientada por objetos
➢ Comprender la implementación de los conceptos fundamentales de modularidad,
encapsulamiento, herencia, abstracción y polimorfismo
➢ Comprender los niveles de abstracción y la identificación de los elementos de una
aplicación de software orientada por objetos
➢ Aplicar los conceptos de programación orientada por objetos para la elaboración de
una aplicación básica orientada por objetos
➢ Entender los elementos esenciales de cómo efectuar las pruebas de un programa o
una aplicación
 3

Ideograma ............................................................................................................................. 3
Introducción ........................................................................................................................... 4
1 Manejo de colecciones, listas encadenadas e Iteradores en JAVA ........................... 4
2 Ejercicios y ejemplos de aplicaciones avanzadas con POO...................................... 10
3 Uso de JUnit para pruebas unitarias de código.......................................................... 34
Glosario ............................................................................................................................... 37
Bibliografia ................................................................................. Erreur ! Signet non défini.
3.1 Actividades Propuestas .................................................................................39
 4

Ideograma

Colecciones

Ejercicios y ejemplos
de aplicaciones
Modulo 3 avanzadas con POO
Colecciones y manejo avanzado aplicaciones
OO con Java
Uso de Junit para
pruebas unitarias de
código
 5

Introducción:

Este modulo final del curso de Programación Orientada a Objetos tiene como propósito
principal detallar algunas de las clases JAVA, subrayando su relación con los
conceptos vistos en los dos módulos pasados: Acoplamiento, Herencia,
encapsulamiento etc. Para ello inicialmente se revisará con detalle algunas de las
clases que facilitan el manejo de conjuntos de datos tale como : colecciones,
iteradores, listas, Vectores.

Luego, se trataran algunos elementos claves en la definición de clases y se describirán

las clases esenciales para manejo y gestión de bases de datos. Se mostrará con un
ejercicio como se encadenan y relacionan dichas clases para administrar la información
residente en un software de administración de base de datos.

Por último, se trabajará la iteración 3 y 4 del ejercicio visto en el primer modulo (Tablero
mágico) , para profundizar la escritura de interfaces utilizando SWT y JWT, tema que
fue abordado inicialmente en el modulo 2.

1 Manejo de colecciones, listas encadenadas e Iteradores en JAVA

El manejo de conjuntos de datos en cualquier lenguaje de programación es un aspecto

crucial, pues de alguna manera una buena parte de las aplicaciones de software deben
resolver la forma de guardar, acceder, ordenar, actualizar y borrar conjuntos de datos
que obedecen a alguna disciplina de acceso y siguen algún tipo de estructura
organizativa. Hasta ahora, en los ejercicios que los estudiosos han desarrollado, el
almacenamiento de conjuntos de datos ha utilizado arreglos básicos que utilizan el
concepto de almacenamiento estático. Es decir, la definición de cuanto elementos van
a ser manejado se define previamente ( instante de compilación del programa) y al
ejecutar el mismo no es posible guardar elementos más allá del límite definido
inicialmente. Esta desventaja o inconveniente es resuelta en una buena parte de los
lenguajes de programación utilizando estructuras dinámicas, es decir, estructuras de
datos maleables, las cuales tienen la posibilidad de redefinirse y ampliarse según las
exigencias de espacio en tiempo de ejecución. En esta sección del modulo se va a
discutir cuales son las estructuras y sus ventajas a la hora de otorgar algún grado de
flexibilidad en el manejo de conjunto de datos utilizando almacenamiento dinámico.

En la figura 1, se muestra la grafica del Framework JAVA disponible para el manejo de

conjuntos de datos.
 6

Figura 1. Lista de clases para manejo de conjuntos de datos

Como se observa en la grafica 1, existen dos conjuntos principales que conforman el

framework : las colecciones y los maps. Una colección representa una colección o
conjunto de datos, mientras que un map permite representar la asociación existente
entre objetos de un conjunto de objetos con objetos de otro conjunto. Inicialmente se
revisaran las dos interfaces List y Set que son las aquellas que permitirán implementar
otras clases tales como Vector y ArrayList que en términos prácticos son dos tipos de
arreglo. Se comenzara por estudiar la interfaz List.

Una lista es una colección en la cual los objetos se organizan de forma secuencial. Es
decir, una lista tiene un primer ítem, un segundo ítem, un tercer ítem y así
sucesivamente. Para cualquier ítem de la lista existe un suceso excepto para el ultimo.
Por su parte un Set es una colección de elementos sin ningún orden preestablecido
pero cuya principal característica es que no permite la existencia de objetos duplicados
o repetidos.

Una lista (List) puede permitir la implementación de un ArrayList o un Vector. Se

revisara el siguiente ejemplo para facilitar la comprensión por parte del estudioso. La
figura 2 contiene el listado fuente de la clase ListaEjemplo , la cual permite apreciar
cómo se puede definir un arreglo o lista utilizando la clase Array
 7

Figura 2. Listado fuente de la clase Lista Ejemplo que implementa un ArrayList haciendo uso de
la interfaz List

Fuente: tomado directamente de la aplicación Eclipse

Se aprecia que se han importado 3 clases del Framework Java : Iterator, List y
ArrayList. Las dos primeras son las interfaces que definen la colección de datos y la
forma como se va a recorrer (Iterator) , mientras que ArrayList es la clase directa que
implementa los métodos de la lista. Los métodos principales disponibles del ArrayList
son:

add (E e) Adicionar el elemento al final de la lista

add(int index, E Element) Insertar el elemento en la posición indicada por el
índice i
get (int index) Retorna el element especificado en la posición
indicada por el índice i
indexOf(Object o) Devuelve el indice donde encuentre el objeto o
isEmpty() Retorna verdadero si la lista no tiene elementos
remove(int index) Remueve el elemento presente en el índice index
remove(Object o) Remueve la primera ocurrencia del objeto o
set(int index,E Element) Reemplaza el elemento presente en índice index
por elemento E
size() Retorna un entero con el tamaño de la lista
sublist(int fromIndex,int toIndex) Retorna una sublista correspondiente a los
elementos que van desde la posición fromIndex
hasta la posición toIndex
 8

En la figura 2, se ve que en la línea 13 se declara y se instancia un objeto de la clase

ArrayList. De las líneas 15 a 18 se invoca el método add() para adicionar varios
elementos. En la línea 20, se instancia un objeto de la clase iterator utilizando el
método List.iterator() que va a facilitar el recorrido de cada uno de los elementos de la
misma, a través de un ciclo while. Finalmente, la figura 4 muestra la ejecución de la
clase, donde se despliega la salida de la línea 26 al ser impreso cada elemento del
arreglo.

Figura 4. Impresión del resultado de la ejecución de la clase ListaEjemplo

Fuente: tomado directamente de la herramienta Eclipse

En el siguiente ejemplo se ilustrara la implementación de una colección de elementos

utilizando la interfaz LIst pero con uan estructura java diferente, la colección Vector. La
implementación Vector es la misma de la implementación ArrayList, solo que la clase
Vector soporta métodos adicionales que no pertenecen originalmente al Framework de
las Collection. Además, Vector soporta el manejo del concepto de multihilos (thread-
safe), cuyo tema sera objeto de discusión en un curso avanzado de programación en
próximos semestres. Ahora bien , la implementación de Vector implica mayor uso de
recursos de computo.

Figura 5. Listado fuente de la implementación de una colección utilizando la clase Vector

 9

Fuente: Pantalla tomada por el autor directamente del IDE Eclipse

El programa VectorEjemplo es una clase java que permite visualizar la implementación

de una colección de datos a través de una lista utilizando la clase java Vector. La clase
Vector pertenece al paquete java.util. Vector es un arreglo dinámico que crece acorde
con las necesidades del programa. Vector no requiere una dimensión fija como cuando
se utilizan los arreglos nativos de Strings o de int: String[n] o int[n]. Vector contiene
varios métodos muy útiles heredados de Collection. El método add() se utiliza para
insertar un elemento en la estructura de datos. Si se quiere insertar elementos en una
posición fija se utiliza el método add con los parámetros de la posición y el objeto, tal
como add(index,object). Para capturar o leer un valor del arreglo se utiliza el método
get() y para saber el tamaño del arreglo se utiliza el método size().
 1
0
En la figura 5, se despliega el listado fuente de la clase VectorEjemplo. En la línea 10
se instancia el objeto Vector y como se observa el constructor de la clase, tal como
ocurre también en el caso de la clase ArrayString, no exige ningún tipo de numero
entero para definir el tamaño pues como se ha dicho previamente este tipo de
estructura permite su ampliación dependiendo de las necesidades de cada aplicación.
Las líneas 15 a 17 utilizan el método add para adicionar elementos al arreglo, mientras
que en la línea 25 se utiliza el método size para desplegar el tamaño del arreglo.
Finalmente las líneas 28 a 31, permiten recorrer el arreglo y listar cada uno se sus
elementos.

Figura 6. Impresión de pantalla para la ejecución de la clase VectorEjemplo

Fuente: Tomado directamente de la pantalla del IDE eclipse

La Figura 6, muestra la impresión de pantalla una vez ejecutado la clase

VectorEjemplo.
 10

2 Ejercicios y ejemplos de aplicaciones avanzadas con POO

La siguiente sección del presente modulo estará dedicada a ilustrar la aplicación de los
métodos de Orientación a Objetos utilizando el ejemplo del primer modulo, pero
incluyendo algunas complejidades adicionales que permitirán utilizar otras clases de
algunos paquetes de java.

Se recordara que en el primer modulo se desarrollo una aplicación didáctica cuyo

objetivo era implementar un tablero mágico, una especie de lienzo donde se podía
dibujar libremente utilizando el mouse. En la primera iteración se tocaron aspectos
básicos de la aplicación, mientras que en la segunda iteración se le dio la capacidad al
lienzo (aplicación) de guardar y recordar los trazos.

En esta sección se revisara la tercera iteración de la aplicación del tablero mágico, en

la cual se incluirá el soporte al dibujo de diferentes tipos de formas tales como: líneas,
óvalos y rectángulos. El diseño hasta ahora comprende exclusivamente el dibujo de
trazos. Para poder soportar el uso de diferentes forma , se debe mejorar el diseño de la
herramienta de dibujo y acomodar algunas extensiones. El objetivo de esta tercera
iteración será reconfigurar su extensibilidad.

El primer paso es rediseñar el pad de dibujo para generalizar la noción de formas que
pueden ser hechas. Actualmente, la única forma que puede ser dibujada es un trazo
que está compuesto por uno o varios puntos. Para ir mas allá y generalizar el concepto
de forma, se introduce el uso de la clase Forma para representar cada una de las
formas que puede ser dibujada, siendo el trazo (Trazo) una de ellas.
 11

Figura 7. Rediseño de la estructura de clases para el pad de dibujo d

el tablero magico

Fuente: Adaptado de Xiaoping Jia- Fig. 9-10 pag. 422

El rediseño de la estructura de clases se aprecia en la figura 7 . S ha incluido la clase

abstracta Forma, en vez de utilizar una interfaz, puesto que existen algunas nuevas
funcionalidades que serán comunes a todas las formas, tales como el color. de tal
suerte que, es mucho más apropiado definir los métodos y dichas funcionalidades
comunes dentro de una superclase. El campo color y los métodos asociados
previamente en la clase Trazo se han movido hacia la clase Forma. El método
abstracto draw() se utiliza en cada subclase para definir como se pintara cada forma.
 12

Figura 8. Listado fuente de la clase Trazo redefinida para soportar el dibujo de formas en la
aplicación del tablero magico

Fuente: Tomado directamente por el autor a partir de Eclipse

 13

Por otra parte la clase Forma, que es extendida por Trazo, puede ser visualizada en la
figura 9.

Figura 9. Listado fuente de clase Forma luego del refactoring o rediseño hecho para la
aplicación del Tablero Mágico

Fuente: Tomado directamente por el autor a partir de Eclipse

Al hacer el rediseño de las clases para soportar el uso de diferentes formas al dibujar
al interior del Tablero mágico, se ha utilizado el concepto de patrones y
específicamente el Patrón de Estrategia. La clase Forma es la clase abstracta de
estrategia mientras que la clase Trazo es la clase concreta. El uso de patrones en la
 14

programación moderna y orientada por objetos se revisara en otros cursos de

programación a lo largo del programa de Ingeniería de Software.

Ahora bien , con el propósito de pintar diferentes formas, tales como : óvalos, líneas y
rectángulos, el comportamiento de el listener del canvas debe ser un tanto diferente en
cuanto a cómo se comporta al dibujar las mismas. El diseño más flexible y elegante es
aquel que permite encapsular el comportamiento para dibujar una figura especifica
utilizando una clase que se llamara Herramienta. Esta representa algo así como un
maletín de donde se pued e escoger el tipo de herramienta a utiliz ar correspondiendo a
la forma que se quiere pintar El diagrama de clases se muestra en la figura 10

Figura 10. Diagrama de clases correspondiente a la implementación de la Clase Herramienta

Fuente: Adapatado de Xiaping Jia, Fig. 9.11 Pagina 425

Este diseño permite tener muchas más extensiones para soportar formas y
herramientas adicionales.
 15

La figura 11, muestra el listado de la Interfaz Herramienta, la cual incluye varias

funcionalidades comunes que serán compartidas por todas las herramientas o formas a
dibujar.

Figura 11. Listado fuente de la interfaz Herramienta para el Tablero mágico rediseñado

Fuente: Tomado directamente por el autor a partir de Eclipse

Por su parte, la figura 12, muestra el listado fuente de la clase abstracta

(HerramientaAbstracta) que implementa la interfaz Herramienta

Figura 12. Listado fuente de la implementación de Herramienta (HerramientaAbstract)

 16

Fuente: Tomado por el autor directamente desde Eclipse

La clase TableroHerramienta es una clase concreta que define el comportamiento para

el Tablero mágico en su etapa ya rediseñada. Su implementación posee algunas cosas
comunes de la implementación utilizada anteriormente en la clase
TableroCanvasListener

Figura 13. Modificaciones para la clase TableroCanvasListener para soportar el uso de diversas
formas al dibujar en el tablero mágico rediseñado

Fuente: Tomado por el autor directamente desde Eclipse

 17

Tal como se aprecia en la figura 13, se introdujo el uso de las siguientes artefactos:
interfaz herramienta, clase abstracta HerramientaAbstract y finalmente su
implementación a través de TableroHerramienta, como reemplazo de la forma de
graficar utilizando directamente las clases de awt. Es en esta última clase donde se
delega toda la responsabilidad para responder a los eventos del
TableroCanvasListener. Existe también una gran diferencia en la manera como se crea
el canvas , puesto que en este rediseño se ha introducido un método llamado make
Canvas() en la clase Tablero, el cual permite crear instancias de las subclases de
Tablero Canvas , las cuales representan versiones mejoradas de el canvas. Esto
completa la tercera iteración de la aplicación del tablero mágico , con la cual se han
ilustrado las diferentes formas de aplicación de los conceptos de orientación a objetos
revisados en el primer y segundo modulo al desarrollo de aplicaciones

En seguida se revisara la siguiente iteración del ejercicio del tablero mágico , en la cual
el objetivo es mejorar la funcionalidad del pad de dibujo. EN la iteración anterior se
dieron paso que permiten adicionar estas nuevas funcionalidades de forma fácil e
incremental. El pad de dibujo tendrá una barra de herramientas a la izquierda en el
canvas, con la cual se podrá seleccionar la forma libre, las líneas, los ovales y los
rectángulos . Esta versión también adicionara un nuevo menú – Herramientas – en la
barra de menú. La utilidad para dibujar podrá ser seleccionada utilizando el ítem de
menú correspondiente.

Los aspectos claves a tocar en esta iteración serán:

➢ Soporte para los diferentes comportamientos asociados con cada herramienta y

la forma de intercambiar entre las diferentes herramientas de manera dinámica.
➢ Uso del patrón de diseño OO Factory para permitir crear instancias de
diferentes subclases.

En esta iteración, se soportara el dibujo utilizando las siguientes formas: línea, ovalo y
rectángulo. Estos tres tipos de formas comparten características comunes. En primera
instancia pueden ser completamente definidas utilizando dos puntos : los dos puntos
extremos para las líneas y las dos esquinas diagonalmente opuestas para los
rectángulos y los ovalos. Se llamaran estos puntos los extremos. Una clase abstracta
llamada FormaDosPuntos se introduce para capturar esta funcionalidad común. El
diseño correspondiente a las formas en esta iteración se muestra en la figura 14.
 18

Figura. 14. Diseño de clases para el pad de dibujo de la aplicación del Tablero Mágico

Fuente: Adaptado de Xiapoing Jia. Fig. 9.13 pag. 433

Los siguientes son los métodos resumidos para la clase FormaDosPuntos

Métodos Descripción

setEnds() Fija ambos puntos

setEnd1() Fija el primer punto del extremo

setEnd2() Fija el segundo punto del extremo

getX1() Retorna la coordenada x del primer punto extremo

 19

getY1() Retorna la coordenada y del primer punto extremo

getX2() Retorna la coordenada x del segundo punto extremo

getY2() Retorna la coordenada y del segundo punto extremo

drawOutline() Dibuja una trama temporal de la forma

A continuación se incluye en la Figura 15 el listado completo de la clase abstracta

FormaDosPuntos

Figura 15. Listado Fuente clase abstracta FormaDosPuntos para la aplicación del Tablero
mágico
20
 21

Fuente: Tomado directamente por el autor a partir de Eclipse

Las tres clases concretas para cada forma se definen como subclases de la clase
FormaDosPuntos . A continuación se muestra el código fuente para cada una de ellas.
 22

Figura 16. Listado fuente clase FormaLinea para dibujar una línea en el tablero mágico

Fuente: tomada por el autor directamente de Eclipse

Figura 17. Listado fuente clase FormaOvalo para dibujar un ovalo en el tablero mágico
 23

Fuente: tomada por el autor directamente de Eclipse

 24

Figura 18. Listado fuente clase FormaRectangulo para dibujar un rectángulo en el tablero
mágico

Fuente: tomada por el autor directamente de Eclipse

Teniendo en cuenta el nuevo rediseño, se deberá también tener una nueva forma para
manejar las herramientas. Es por ello que, el pad de dibujo proveerá un conjunto de
diferentes herramientas para pintar. Cada herramienta extiende la clase abstracta
HerramientaAbstracta construida en la anterior iteración. La clase HerramietaKit
representa por tanto el conjunto de herramientas soportada por el pad de dibujo y lleva
cuenta de la Herramienta actualmente seleccionada. Las respuestas del mouse a las
acciones press o release y el drag del mouse en el canavás de dibujo depende de la
herramienta seleccionada. En la clase HerramientaKit, cada herramienta debe ser
identificada o por su nombre o por su posición en la HerramientaKit. Los métodos de la
clase HerramientaKit se resumen a continuación:
 25

Métodos Descripción

addHerramienta() Adiciona una nueva Herramienta a HerramientaKit

getHerramientaCount() Retorna el numero de herramientas en HerramientaKit

getHerramienta(i) Retorna la i-esima herramienta en HerramientaKit

findHerramienta(name) Retorna la herramienta con el nombre dado

setHerramientaSelecccionada(i) Fija la i-esima herramienta para ser la herramienta

corriente

setHerramientaSeleccionada(name) Fija la herramienta con el nombre dato para ser

setHerramientasSelecccionada() Retorna la coordenada y del segundo punto extremo

getHerramientaSeleccionada() Retorna la herramienta seleccionada

A continuación , se muestra el código fuente de la clase HerramientaKit que utiliza

Figura 19. Listado fuente de la clase HerramientaKit del Tablero Mágico

26
 27

Fuente: Tomado directamente por el autor a partir de Eclipse

Para poder describir el comportamiento del dibujo de cada forma y desacoplar la clase
herramientas del pad de dibujo, se introduce la clase DosExtremosHerramienta, la cual
tendrá el siguiente rol dentro de nuestra aplicación:

Cuando se selecciona el dibujo de una línea, o el dibujo de un rectángulo o de un

ovalo, se puede usar el mouse para dibujar cada elemento. Aunque estas formas
tienen muy poco en común, la manera en cómo se dibujan son muy similares –
definiendo los dos puntos. . El procedimiento para dibujar las formas es el siguiente:

❖ Cuando el mouse se presiona, la posición actual del mouse define el primer

punto extremo de la forma seleccionada
❖ Cuando el mouse se arrastra, frames temporales de la forma seleccionada se
pintan. Estos frames temporales siguen el mouse a medida que se arrastra el
mouse. Este proceso se conoce normalmente como banda de caucho (rubber
banding), puesto que el mouse permite estirar la forma como si se tratara de una
banda de caucho.
❖ Cuando el mouse se libera, la posición corriente del mouse define el segundo
punto extremo de la forma seleccionada . Finalmente la forma seleccionada
definida se pinta en el canvas o lienzo de la aplicación.

En razón de las smilaridades de la líneas, los rectángulo y los óvalos se puede diseñar
una sola herramienta, la clase DosExtremosHerramienta, la cual gestionara el dibujo de
las tres formas. Cada forma se identifica con una constante entera: LINE, OVAL y
RECT. Los campos de la clase DosExtremos Herramienta se resumen a continuación:
 28

Campo Descripción

forma Forma a ser dibujada

xStart, yStart Coordenadas del primer punto

 29

A continuación se muestra el listado fuente de la clase :

Figura 20. Listado Fuente de la herramienta DosExtremosHerramienta para la aplicación del

Tablero magico
30
 31

Fuente: Tomado directamente por el autor a partir de Eclipse

En el listado de la clase se puede apreciar que el método mousePressed() registra las

coordenadas de le primero y el último punto de y prepara la “banda de caucho”. El
mecanismo de “RubberBanding” banda de caucho se ejecuta usando un Or-exclusivo o
(XOR) del contexto grafico. Cuando se usa este modo en un contexto grafico y la figura
se dibuja una vez, la figura se hace visible. Sin embargo, el color de la figura depende
no solamente del color actual del lápiz, sino también de los colores de los pixels que
cubre la figura. . Cuando la misma figura se pinta dos veces en la misma posicion , la
figura desaparece. EL método mouseDragged ejecuta el “rubberBanding” . Los valores
canvas.x y canvas.y son las coordenadas de la localización del mouse
correspondientes al proceso intermedio. El método mousReleased registra o guarda el
segundo punto de la forma. Además fija el modo del contexto grafico al modo paint.
También crea las instancia de la forma seleccionada y la pinta en el canvas.
 32

En la figura 21 se aprecia el resultado de la ejecución de la aplicación del Tablero

Mágico una vez finalizada la cuarta iteración incluyendo la aplicación de varios
principios de la POO: encapsulamiento, herencia etc.

Figura 21. Pantallazo de la Ejecución del Tablero Mágico después del refactoring (iteraciones 3 y 4)

Fuente: Tomado por el autor directamente a partir de Elcipse

33
 34

3 Uso de JUnit para pruebas unitarias de código

A continuación se tratara un tema complementario pero supremamente importante en

términos de completar el ciclo de desarrollo de cualquier aplicación de Software. Esto
es: las pruebas unitarias de software. Para ello , se introducirá el uso de la librería
Junit, pieza fundamental dentro de un ambiente Java en el momento de efectuar las
pruebas de cualquier clase o conjunto de clases.

JUNit es una herramienta flexible, de código abierto que le permite a los

programadores java probar sus programas. En la figura 22 , se muestra la plantilla de
una unidad típica de de test de JUnit.

Figura 22. Plantilla de test de Junit

Fuente: Tomado por el autor directamente de Eclipse

Cada prueba de un programa, es decir, test suite, se escribe como una subclase de la
clase TestCase. Se requiere con el nombre del test suite es requerido. Cada test case
 35

se escribe como un método separado. Los nombres de los métodos de tests debe
comenzar con el prefijo test. El método suite() se requiere en el programa de test y
agrega todos los casos de test de la clase en un testsuite.

Una unidad de test exhaustiva y efectiva debe

➢ Probar sistemáticamente todos los aspectos de la implementación basado en

ciertos criterios establecidos; y
➢ Chequear automáticamente la precisión de los resultados del test

Existen dos enfoques básicos para creara casos de prueba y medir la completez de un
conjunto de casos de prueba: los enfoques de caja negra (black box) y de caja blanca
(White box) . El primero se enfoca en la creación de casos de prueba basados en la
especificación de un solo componente, sin tener en consideración como se implementa
el mismo. Por su parte el segundo enfoque, se focaliza en generar los casos de prueba
basado en la estructura del código que implementa el componente. Uno de los
métodos más importantes del enfoque de caja negra es la llamada prueba de
particiones equivalentes de entrada. En este enfoque, el espacio de entrada de un
programa se divide en un numero de particiones de equivalencia. Este espacio puede
incluir tanto elementos de entrada validos como no validos. Los elementos que están
en una misma partición de equivalencia son los datos que serán procesados por el
programa de una manera similar. Por tanto, se puede deducir el comportamiento de un
programa solamente probando una muestra representativa de la partición de
equivalencia. Usando este enfoque, se considera adecuado un conjunto de casos de
prueba si se prueba al menos un representante para cada partición de equivalencia.
36
 37

Glosario

Colección : Es un conjunto de clases java (paquete) que incluye diversas subclases

con el propósito de facilitar la gestión de conjuntos de datos

Patrón de diseño:

Descripción esquemática de diseños reutilizables. Cada patrón describe un problema

recurrente y el núcleo de la solución a dicho problema

Clase abstracta: Una clase que contiene por lo menos un método abstracto. Las
clases abstractas no pueden ser instanciadas . Debe ser extendida por una clase que
implementa los métodos abstractos

Interfaz: Una forma especial de clase que declara las funcionalidades pero no provee
su implementación. Una interfaz solamente declara constantes y métodos abstractos.

Lista: Una colección ordenada de elementos en los cuales sus elementos son
indexados comenzando desde 0. Las listas también se conocen como secuencias

Serializacion: Es el proceso de escribir un objeto hacia un stream de bytes.

Package: Mecanismo para organizar programas o aplicaciones muy grande

subdividiéndolas en unidades manejables. Un paquete contiene clases, interfaces u
otros paquetes
 38

Bibliografía

Libros

Eck, David J. Introduction to Programming Using Java. Introduction to

Programming Using Java. Diciembre 2006. http://math.hws.edu/javanotes/

Xiaoping , Jia. Object-Oriented software development using JAVA. Addison Wesley

2003.

Jimenez, Leoncio et Al. Analogías graficas como método de aprendizaje en un curso

de Programación Orientada a Objetos. En revista de Ingeniería Informática, edición 13,
Noviembre del 2006. Universidad Católica del Maule, Talca – Chile.

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

2008.

Larman , Craig. UML 2 et les design patterns. Editorial Perarson. 3ra. Edicion. 2005
 39

3.1 Actividades Propuestas

Las siguientes son las actividades propuestas

Actividad 1. Elaborar una aplicación utilizando eclipse, java y alguno de los framework
para gráficos: AWT, JWT o SWT , que permita implementar un juego de picas y fijas
de 4 posiciones enteras (ver: http://www.youtube.com/watch?v=MuRmaeymg3A)

Actividad 2. Elaborar una aplicación que permita implementar el juego de tres en línea.
Ver: http://www.juegoswapos.es/juegos-de-tres-en-raya.htm

Actividad 3. Elaborar un programa que permita implementar una aplicación para

manejar el registro de la historia clínica de un paciente según unas requerimientos
básicos.