i

UNIVERSIDAD DE ORIENTE
NCLEO DE ANZOTEGUI
ESCUELA DE INGENIERA Y CIENCIAS APLICADAS
DEPARTAMENTO DE COMPUTACIN Y SITEMAS




GUIA DIDCTICA PARA LA ASIGNATURA OBJETOS Y
ABSTRACCIN DE DATOS, DICTADA A LOS ESTUDIANTES DE ING. EN
COMPUTACIN Y DE ING. DE SISTEMAS, EN LA UNIVERSIDAD DE
ORIENTE

Por:
Prof. Gabriela Mara Veracierta Tovar

Trabajo Ascenso presentado como requisito parcial para
optar a la categora de Profesor Asistente




Barcelona, Mayo de 2012

ii

RESUMEN

La asignatura Objetos y Abstraccin de Datos es muy importante, base
fundamental en el rea de desarrollo de software, usando el paradigma
orientado a objetos que es uno de los ms usados actualmente; a los
estudiantes se les dificulta investigar en bibliografas bien sea por la dificultad
de adquirir libros actualizados, encontrarlos en la sala de lectura del
departamento y en la biblioteca; porque en internet no encuentran
informacin adecuada o es expuesta de una forma entendible para
principiantes, por tal motivo se desarrollo una gua didctica con la
informacin necesaria para que el estudiante pueda comprender de una
manera precisa todo el contenido de la asignatura; y de esta forma poder
consultarla en cualquier momento y disipar dudas referente a un tema
perteneciente a las unidades, con un lenguaje comprensible para nivel de
conocimiento; tambin pueden consultarla antes de clases, o simplemente
repasar el contenido discutido.

iii

DEDICATORIA

A mi Dios, como todo cuanto hago en mi vida es pt dedicado a l.
A mis Padres, todos mis xitos es por y para ellos.
A mis hermanas, que las amo; y son fuente de inspiracin
A mis colegas.
A mis estudiantes, para que se le facilite obtener el conocimiento ms
facilmente


iv

AGRADECIMIENTOS


A Dios por TODO cuanto hay en mi vida.
A mis Padres Dora y Alcides, por siempre estar para m.
A mi hermana querida Aracelis, por siempre estar! muack.
A mis amigos y colegas, por ser fuente de inspiracin y ejemplo de
lucha.
A mis profesores que por siempre lo sern, gracias por guiarme.
Al hermano que me regalo la vida Reinaldo Pastrana, por sus sabios
consejos.


v

TABLA DE CONTENIDO

Pg.
RESUMEN ............................................................................................................................... II
DEDICATORIA ........................................................................................................................ III
AGRADECIMIENTOS ............................................................................................................... IV
INTRODUCCIN .................................................................................................................... XV
1.1 PLANTEAMIENTO DEL PROBLEMA ...................................................................................... 17
1.2 OBJETIVOS ................................................................................................................... 18
1.2.1 Objetivo General .................................................................................................. 18
1.2.2 Objetivos Especficos ............................................................................................ 18
CAPTULO II: MARCO TERICO ............................................................................................. 19
2.1 PAQUETE INSTRUCCIONAL: .............................................................................................. 19
2.2 GUIA DE ESTUDIO: ......................................................................................................... 19
2.3 UNIDAD DIDACTICA: ...................................................................................................... 19
2.4 GUIA DIDCTICA: ........................................................................................................... 20
2.4.1 FUNCIONES BSICAS DE LA GUA DIDCTICA ...................................................... 21
2.4.2 ESTRUCTURA DE LA GUA DIDCTICA .................................................................. 23
CAPTULO III: MARCO METODOLGICO ............................................................................... 25
3.1 NIVEL DE INVESTIGACIN ................................................................................................ 25
3.2 DISEO DE INVESTIGACIN .............................................................................................. 25
CAPTULO IV: REPASO DE CONCEPTOS FUNDAMENTALES DE ALGORITMOS Y LA
PROGRAMACIN, BASADA EN EL PARADIGMA ORIENTADO A OBJETOS ......................................... 27
4.1. OBJETIVOS DE LA UNIDAD ............................................................................................... 27
4.2. CONTENIDO DE LA UNIDAD .............................................................................................. 27
4.2.1. Repaso del concepto de algoritmo .................................................................. 27
4.2.1.1. Definicin de Algoritmo ............................................................................................. 27
4.2.1.2. Caractersticas de Algoritmo ...................................................................................... 28
TABLA DE CONTENIDO

vi

4.2.1.3. Formas de expresar un algoritmo .............................................................................. 28
4.2.1.4. Elementos de un algoritmo ....................................................................................... 29
4.2.1.5. Ejemplo de un algoritmo expresado tanto en diagrama de flujo como en
pseudocdigo 30
4.2.2. Definicin de programacin ............................................................................ 31
4.2.3. Definicin de paradigma ................................................................................. 36
4.2.4. Tipos de paradigma ......................................................................................... 37
4.2.5. Definicin programacin orientada a objetos................................................. 38
4.2.5.1. Programacin Orientada a Objetos: .......................................................................... 38
4.2.5.2. Caractersticas: .......................................................................................................... 39
4.2.6. Definicin de elementos bsicos de la programacin orientada a objetos ..... 41
CAPTULO V: ABSTRACCIN Y ENCAPSULACIN DE DATOS .................................................. 45
5.1. OBJETIVOS ................................................................................................................... 45
5.2. CONTENIDO .................................................................................................................. 45
5.2.1. Definicin de abstraccin de datos. Definicin de encapsulamiento. ............. 46
5.2.2. Tipos de abstraccin existentes. Ejemplos de aplicacin de la abstraccin y
encapsulacin de datos. .............................................................................................................. 47
5.2.2.1. Tipos de abstraccin existentes ................................................................................. 47
5.2.2.2. Ejemplos de aplicacin de la abstraccin y encapsulacin de datos ......................... 48
5.2.2.2.1. Elementos de un programa ............................................................................... 48
5.2.2.2.2 Clases y Objetos ................................................................................................. 67
5.2.3 Ejemplos de programas resueltos donde se aprecie la abstraccin y
encapsulacin de datos de la programacin orientada a objetos. .............................................. 75
5.2.4 Resolucin de problemas usando programacin orientada a objetos, haciendo
nfasis en la abstraccin y encapsulacin de datos. ................................................................... 89
CAPTULO VI: ARREGLOS DE OBJETOS UNIDIMENSIONALES ................................................. 91
6.1 OBJETIVOS ................................................................................................................... 91
6.2 CONTENIDO: ................................................................................................................. 91
6.2.1 Definicin de Arreglos. Declaracin y creacin de arreglos. Tipos de Arreglos
segn sus dimensiones................................................................................................................. 91
6.2.1.1 Definicin de Arreglos ................................................................................................ 91
6.2.1.2 Declaracin y creacin de arreglos ............................................................................. 93
TABLA DE CONTENIDO

vii

6.2.1.3 Tipos de Arreglos segn sus dimensiones .................................................................. 94
6.2.1.4 Los arreglos como parmetros ................................................................................... 97
6.2.2 Aplicacin de arreglos en la programacin orientada a objetos ......................... 99
6.2.2.1 Clase String de Java .................................................................................................... 99
6.2.2.2 Arreglos de tipos de datos abstractos ...................................................................... 102
6.2.2.3 Manejo de Excepciones en Java ............................................................................... 104
6.2.3 Resolucin de problemas con programacin orientada a objetos usando arreglos
107
CAPTULO VII: HERENCIA Y POLIMORFISMO ....................................................................... 114
7.1 OBJETIVOS ................................................................................................................. 114
7.2 CONTENIDO ................................................................................................................ 114
7.2.1 Definicin de herencia. Definicin de superclase y subclases. ........................... 115
7.2.1.1 Definicin de herencia. Definicin de superclase y subclases .................................. 115
7.2.1.2 Diferencia entre la herencia y composicin ............................................................. 119
7.2.2 Relacin entre superclase y subclases en un programa resuelto usando herencia.
120
7.2.3 Resolucin de problemas con programacin orientada a objetos usando herencia
124
7.2.4 Definicin de polimorfismo. Definicin de clases y mtodos abstractos. .......... 125
7.2.4.1 Definicin de polimorfismo ...................................................................................... 125
7.2.4.2 Definicin de Clases y Mtodos Abstractos ............................................................. 125
7.2.4.2.1 Definicin de clases abstractas ........................................................................ 125
7.2.4.3 Definicin de los mtodos abstractos ...................................................................... 126
7.2.4.4 Uso del polimorfismo ............................................................................................... 130
7.2.4.5 Interfaces de Java ..................................................................................................... 131
7.2.5 Problemas resueltos con programacin orientada a objetos usando polimorfismo.
135
7.2.6 Resolucin de problemas con programacin orientada a objetos usando
polimorfismo. 143
CAPTULO VIII: USO DE INTERFAZ GRFICA DE USUARIO .................................................... 144
8.1 OBJETIVOS ................................................................................................................. 144
8.2 CONTENIDO ................................................................................................................ 144
TABLA DE CONTENIDO

viii

8.2.1 Interfaz grfica de usuario ................................................................................. 144
8.2.1.1 API de Java ................................................................................................................ 146
8.2.1.2 Componentes de la interfaz grfica .......................................................................... 147
8.2.1.3 Paquetes Awt y Swing de Java .................................................................................. 149
8.2.1.4 GUI en Java ............................................................................................................... 150
8.2.1.4.1 Contenedor y Administrador de esquemas en Java ......................................... 153
8.2.1.4.2 Eventos y sus manejadores en Java.................................................................. 154
CAPTULO IX: INTRODUCCIN A ALGORITMOS RECURSIVOS .............................................. 169
9.1 OBJETIVOS ................................................................................................................. 169
9.2 CONTENIDO ................................................................................................................ 169
9.2.1 Definicin de recursividad .................................................................................. 170
9.2.2 Tipos de problemas que pueden resolverse usando recursividad en programacin
orientada a objetos. ................................................................................................................... 171
9.2.3 Comparacin de una funcin recursiva con respecto a una funcin iterativa segn
las ventajas y desventajas de cada funcin. .............................................................................. 175
9.2.4 Problemas resueltos con algoritmos en programacin orientada a objetos usando
funciones recursivas. .................................................................................................................. 177
CAPTULO X: INTRODUCCIN A LAS ESTRUCTURAS DE DATOS FUNDAMENTALES. ............. 182
10.1 OBJETIVOS ................................................................................................................. 182
10.2 CONTENIDO ................................................................................................................ 182
10.2.1 Definicin de las estructuras de datos fundamentales. ................................ 182
10.2.1.1 Estructuras de datos ............................................................................................... 182
10.2.1.2 Pilas ........................................................................................................................ 184
10.2.1.3 Colas ....................................................................................................................... 185
10.2.1.4 Listas ....................................................................................................................... 186
10.2.2 Definicin de la Funciones propias de las estructuras de datos fundamentales.
187
10.2.2.1 Clases autorreferenciadas ...................................................................................... 188
10.2.2.2 Funciones propias de las estructuras de datos fundamentales .............................. 188
10.2.3 Resolucin de problemas usando estructuras de datos fundamentales. ...... 212
CONCLUSIONES .................................................................................................................. 214
TABLA DE CONTENIDO

ix

RECOMENDACIONES .......................................................................................................... 215
BIBLIOGRAFA..................................................................................................................... 216
METADATOS PARA TRABAJOS DE GRADO, TESIS Y ASCENSO: ............................................ 218


x

TABLA DE FIGURAS
Pg.
FIGURA 4.1. ALGORITMO EN PSEUDOCDIGO, PARA DETERMINAR SI UN NMERO ES PRIMO O NO.
........................................................................................................................................................ 31
FIGURA 4.2. ALGORITMO EN DIAGRAMA DE FLUJO, PARA DETERMINAR SI UN NMERO ES PRIMO
O NO. .............................................................................................................................................. 32
FIGURA 5.1.CONVERSIN IMPLCITAS DE TIPOS DE DATOS PRIMITIVOS ......................................... 53
FIGURA 5.2. DECLARACIN DE UN OBJETO Y SU REPRESENTACIN EN MEMORIA .......................... 73
FIGURA 5.3. CREACIN DE UN OBJETO Y SU REPRESENTACIN EN MEMORIA ................................ 73
FIGURA 5.4 EJEMPLO DE COMPOSICIN ......................................................................................... 74
FIGURA 5.5 EJEMPLO DE COMPOSICIN ......................................................................................... 75
FIGURA 5.6. REPRESENTACIN DE CRCULOS .................................................................................. 76
FIGURA 5.7. ATRIBUTOS DE LA CLASE CIRCULO. .............................................................................. 76
FIGURA 5.8.(A) OPERACIONES A LOS CRCULOS. ............................................................................. 77
FIGURA 5.8.(B) RESULTADO DE LA OPERACIONES A LOS CIRCULOS ................................................. 77
FIGURA 5.9. ATRIBUTOS DE LA CLASE CIRCULO ............................................................................... 77
FIGURA 5.10. CDIGO FUENTE DE LA CLASE CIRCULO EN LENGUAJE JAVA ...................................... 78
FIGURA 5.11. CDIGO FUENTE DE LA CLASE CIRCULO CON UNA VARIABLE DE CLASE ..................... 80
FIGURA 5.12. REPRESENTACIN DE FRACCIONES O NMEROS RACIONALES .................................. 80
FIGURA 5.13 ATRIBUTOS DE LA CLASE FRACCION, DENTRO DEL PAQUETE MATEMATICAS ............. 81
FIGURA 5.14 ATRIBUTOS Y MTODOS DE LA CLASE FRACCION........................................................ 81
FIGURA 5.15. CDIGO FUENTE DE LA CLASE FRACCION EN LENGUAJE JAVA ................................... 82
FIGURA 5.16 ATRIBUTOS DE LA CLASE NCOMPLEJO, DENTRO DEL PAQUETE MATEMATICAS .......... 86
FIGURA 5.17 ATRIBUTOS Y MTODOS DE LA CLASE NCOMPLEJO .................................................... 87
FIGURA 5.18 CDIGO FUENTE DE LA CLASE NCOMPLEJO ................................................................ 88
TABLA DE FIGURAS

xi

FIGURA 6.1. REPRESENTACIN GRFICA DE UN ARREGLO .............................................................. 92
FIGURA 6.2. REPRESENTACIN DE UN ARREGLO A DE SEIS (6) POSICIONES .................................... 92
FIGURA 6.3. REPRESENTACIN DE UN ARREGLO A DE TIPO INT DE SEIS (6) POSICIONES................. 93
FIGURA 6.4 REPRESENTACIN DE UN ARREGLO D BIDIMENSIONAL DE 4X3 .................................... 95
FIGURA 6.5 REPRESENTACIN DE UN ARREGLO DE 3 DIMENSIONES (4X3X3) ................................. 95
FIGURA 6.6. ARREGLO STRING DE TAMAO 40 ............................................................................. 101
FIGURA 6.7.(A) REPRESENTACIN EN MEMORIA DEL ARREGLO B, DESPUS DE CREADAS TODAS LAS
POSICIONES .................................................................................................................................. 103
FIGURA 6.8. RESULTADO EN EL ARREGLO B ................................................................................... 104
FIGURA 6.9. ATRIBUTOS Y MTODOS DE LA CLASE PUNTO. .......................................................... 107
FIGURA 6.10. CDIGO FUENTE DE LA CLASE PUNTO ..................................................................... 108
FIGURA 6.11. ATRIBUTOS Y MTODOS DE LA CLASE SERIE. ........................................................... 109
FIGURA 6.12. CDIGO FUENTE DE LA CLASE SERIE. ....................................................................... 110
FIGURA 7.1. JERARQUA DE HERENCIA SIMPLE.............................................................................. 117
FIGURA 7.2. JERARQUA DE HERENCIA MLTIPLE ......................................................................... 117
FIGURA 7.3. JERARQUA DE HERENCIA DEL EJERCICIO PROPUESTO ............................................... 121
FIGURA 7.4. CDIGO FUENTE DE LA CLASE PRODUCTO. ................................................................ 122
FIGURA 7.5. CDIGO FUENTE DE LA CLASE DELIMPIEZA. ............................................................... 123
FIGURA7.6. CDIGO FUENTE DE LA CLASE DEALIMENTACION ....................................................... 124
FIGURA 7.7. CDIGO FUENTE DEL EJEMPLO DE LA CLASE ABSTRACTA EMPLEADO. ...................... 127
FIGURA 7.8. CDIGO FUENTE DEL EJEMPLO DE LA SUBCLASE GERENTE. ....................................... 128
FIGURA 7.9. EJEMPLO DE POLIMORFISMO .................................................................................... 129
FIGURA 7.10. (A) SOLUCIN 1 DEL EJEMPLO DE POLIMORFISMO ................................................. 129
FIGURA 7.10. (B) SOLUCIN 2 DEL EJEMPLO DE POLIMORFISMO .................................................. 130
FIGURA 7.11. REPRESENTACIN DE UN ARREGLO DE EMPLEADOS. .............................................. 131
TABLA DE FIGURAS

xii

FIGURA 7.12. CDIGO FUENTE DE LA INTERFACE MIINTERFAZ ...................................................... 132
FIGURA 7.13. CDIGO FUENTE DE LA CLASE QUE IMPLEMENTA A LA INTERFACE MIINTERFAZ ..... 133
FIGURA 7.14. EJEMPLO DE HERENCIA MLTIPLE CON INTERFACES ............................................... 134
FIGURA 7.15. REPRESENTACIN DE LAS FIGURAS GEOMTRICAS ................................................. 137
FIGURA 7.16. CDIGO FUENTE DE LA CLASE ABSTRACTA FIGURAGEOMETRICA ............................ 138
FIGURA 7.17. CDIGO FUENTE DE LA SUBCLASE RECTANGULO ..................................................... 139
FIGURA 7.18. CDIGO FUENTE DE LA SUBCLASE CIRCULO. ............................................................ 140
FIGURA 7.19. CDIGO FUENTE DE LA CLASE FIGURASG QUE DESCRIBE EL ARREGLO ..................... 141
FIGURA 8.1. GUI PARA PROBAR LA CLASE FRACCION .................................................................... 157
FIGURA 8.2. CDIGO FUENTE DE LA CLASE GUI_FRACCION ........................................................... 157
FIGURA 9.1. ILUSTRACIN DE LAS TORRES DE HANOI ................................................................... 173
FIGURA 9.2. REPRESENTACIN GRFICA DE LA SOLUCIN DEL MTODO THANOI. ....................... 174
FIGURA 9.3. CDIGO FUENTE DEL MTODO S. ........................................................................... 178
FIGURA 9.4. CDIGO FUENTE DEL MTODO FACTORIAL ............................................................... 179
FIGURA 9.5. CDIGO FUENTE DEL MTODO FIBONACCI. ............................................................... 181
FIGURA 10.1. ILUSTRACIN DE UNA PILA (DE PLATOS). ................................................................ 185
FIGURA 10.2. ILUSTRACIN DE UNA COLA (DE SUPERMERCADO) ................................................. 186
FIGURA 10.3. ILUSTRACIN DE UNA LISTA ENLAZADA. ................................................................. 186
FIGURA 10.4. CDIGO FUENTE DE LA CLASE NODOPILA ................................................................ 189
FIGURA 10.5. CDIGO FUENTE DE LA CLASE PILA ......................................................................... 190
FIGURA 10.6. CDIGO FUENTE DE LA CLASE ELEMENTOCOLA ....................................................... 193
FIGURA 10.7. CDIGO FUENTE DE LA CLASE COLA ........................................................................ 194
FIGURA 10.8. CDIGO DE LA CLASE NODOLISTAS .......................................................................... 197
FIGURA 10.9. CDIGO FUENTE DE LA CLASE LISTAS ...................................................................... 204
TABLA DE FIGURAS

xiii

FIGURA 10.10. CDIGO FUENTE DE LA CLASE NODOLISTAD ......................................................... 208
FIGURA 10.12. LISTA DOBLEMENTE ENLAZADA ............................................................................. 212



xiv

NDICE DE TABLAS

Pg
TABLA 5.1. EJEMPLO DE LA REPRESENTACIN DE DATOS PRIMITIVOS EN MEMORIA .......... 51
TABLA 5.2. EJEMPLOS DE LOS OPERADORES A NIVEL DE BITS............................................... 60
TABLA 5.2. EJEMPLOS DE LOS OPERADORES DE ASIGNACIN .............................................. 61
TABLA 5.4. PRIORIDAD Y ASOCIATIVIDAD DE TODOS LOS OPERADORES .............................. 62
TABLA 6.1. MTODOS DE LA CLASE STRING ........................................................................ 100
TABLA 8.1. ALGUNOS DE LOS COMPONENTES DE LA GUI ................................................... 148
TABLAA 8.2. ADMINISTRADORES DE ESQUEMAS................................................................ 153
TABLA 9.1. EJEMPLO DE EJECUCIN DEL MTODO S ( N ), PARA N = 4. ............................... 178
TABLA 10.1. FUNCIONES DE UNA PILA ................................................................................ 188
TABLA10.2. FUNCIONES PROPIA DE UNA COLA .................................................................. 192
TABLA 10.3. FUNCIONES PARA UNA LISTA .......................................................................... 196
.


xv

INTRODUCCIN


La asignatura Objetos y Abstraccin de Datos cdigo 0722123, dictada
a los estudiantes de Ingeniera de Sistemas y en Computacin, en el cuarto
semestre de dichas carreras, pertenecientes al Departamento de
Computacin y Sistema, adscrito a la Escuela de Ingeniera y Ciencias
Aplicadas de la Universidad de Oriente; Ncleo de Anzotegui; es una
asignatura base para su formacin profesional debido a que gua sobre el
paradigma de Programacin Orientada a Objetos a un nivel ms avanzado
que en la asignatura anterior que lleva por nombre Programacin Orientada a
Objetos; conocimientos que le facilitarn a realizar proyectos en las
asignaturas mas avanzadas, fortaleciendo as a un profesional con aptitudes
competentes para las exigencias actuales en el campo laboral.

Los temas abarcados en sta asignatura son difcilmente encontrados
en una sola bibliografa, aunado a esto, las bibliografas son de difcil acceso,
tanto en libreras de la zona como en bibliotecas y sala de lectura, de la
Universidad.

Con una gua didctica para la asignatura Objetos y Abstraccin de
Datos que abarque las siete unidades que esta comprende, le brindara la
oportunidad a los estudiantes de tener fcil acceso a la informacin, bien sea
para consultar un tema en especifico en el cual tengan dudas, o leer antes de
la clase algn tema para obtener conocimientos previos, y de esta forma
facilitar su comprensin. Esta gua la tendrn cada uno de los estudiantes de
la asignatura, que pueden llevarla a donde vayan de esta forma no estar
TABLA DE FIGURAS

xvi

dentro del recinto universitario para consultarla, no tendr restricciones de
horarios, de lugar donde se encuentren, entre otros.




CAPTULO I: EL PROBLEMA

1.1 Planteamiento del Problema

Desde el ao 2005 se hizo un cambio de pensum en las carreras de
Ingeniera en Computacin e Ingeniera de Sistemas, como medida para
formar profesionales actualizados en la evolucin de las ciencias
computacionales; y de esta forma capacitarlos adecuadamente a las
exigencias actuales en la sociedad, con respecto a sus areas de trabajo.

En esta reforma curricular, se introdujeron varias asignaturas y se
modificaron otras, con el fin de llevar a cabo el propsito de actualizacin;
entre ellas se creo la asignatura Objetos y Abstraccin de Datos dictada en el
cuarto semestre para ambas carreras, esta asignatura es la segunda en la
rama de programacin, la primera es Programacin Orientada a Objetos,
donde el estudiante aprende los conceptos bsicos de programar, aunado a
la lgica de desarrollar algoritmos para una tarea especifica.

Objetos y Abstraccin de Datos es una asignatura muy importante, es
base fundamental en la formacin de Ingenieros en computacin e
Ingenieros de Sistemas, para desarrollar software de alta calidad, debido a
que el paradigma orientado a objetos es unos de los ms usados
actualmente; y en esta asignatura se profundiza en este paradigma

Para esta asignatura cuando los estudiantes investigan se encuentran
con informacin muy amplia y variada, tanto en bibliografas fsicas como en
internet; en las bibliografas no siempre se abarca todas las unidades que la
conforman, se les dificulta adquirir libros actualizados, en la sala de lectura



del departamento y en la biblioteca, tambin en las libreras de la zona; en
internet no toda la informacin que esta es veraz o es expuesta de una forma
entendible para principiantes, por tal motivo se plantea desarrollar una gua
didctica con la informacin necesaria para que el estudiante pueda
comprender de una manera precisa todo el contenido de la asignatura; y de
esta forma poder consultarla en cualquier momento y disipar dudas referente
a un tema perteneciente a las unidades.

1.2 Objetivos

1.2.1 Objetivo General

Elaborar una gua instruccional que abarque todas las unidades
de la asignatura Objetos y Abstraccin de Datos, dictada en el
departamento de Computacin y sistemas de la Escuela de
Ingeniera y Cs. Aplicadas de la Universidad de Oriente.

1.2.2 Objetivos Especficos

Revisar todo el contenido de la asignatura
Revisar bibliografas que contengan definiciones para los
conceptos relacionados con los temas de la asignatura
Redactar conceptos ejemplificados para los temas, con
ejemplos claros.



CAPTULO II: MARCO TERICO


2.1 Paquete Instruccional:
Segn Lobo N., y Fallas V. En 2008. Un paquete Instruccional es el
conjunto de materiales que se ofrecen al estudiante como instrumentos
bsicos para el logro de su aprendizaje independiente. Constituye el principal
vehculo para que el estudiante pueda desarrollar el autoaprendizaje y la
autoevaluacin, con tal de llevar a cabo el proceso de educacin a distancia.
Normalmente, lo conforman las guias de estudio, las unidades didcticas y
otros materiales complementarios, como artculos, revistas, antologas,
etctera; que mantienen actualizado el tema de estudio abordado.


2.2 Guia de estudio:
Segn Lobo N., y Fallas V. En 2008. Una Guia de estudio, concebida
como un proyecto integral de trabajo, orientado de tutores y estudiantes,
debe contener todo lo relacionado con una unidad organizativa (asignatura,
mdulo, taller, laboratorio, etctera), tomando un marco de referencia el
contexto en el que se ubica (por ejemplo, un plan de estudio). Asimismo,
tiene como finalidad encaminar al alumno en el conocimiento de los paquetes
instructivos de apoyo de cada asignatura.


2.3 Unidad Didactica:
Segn Lobo N., y Fallas V. En 2008. Una Unidad didctica es el
material impreso bsico que desarrollla los contenidos fundamentales de
cada asignatura. Se trata de un texto con estructura metodolgica



especialmente diseada para facilitar el autoaprendizaje del estudiante, de
manera individualizada. La organizacin y presentacin de los contenidos,
as como los elementos didcticos, cumplen funciones especficas de
orientacin para que el alumno aprenda a aprender.


2.4 Guia didctica:
Segn Garca, A. en 2002. La gua didctica es el documento que
orienta el estudio, acercando a los procesos cognitivos del alumno el material
didctico, con el fin que pueda trabajarlos de manera autnoma.

Para Mercer, en 1998, la define como la herramienta que sirve para
edificar una relacin entre el profesor y los alumnos.

Para Constituye un instrumento fundamental para la organizacin del
trabajo del alumno y su objketivo es recoger todas las orientaciones
necesarias que le permitan al estudiante integrar los elementos didcticos
para el estudio de la asignatura.

Para Aguilar, R. en 2006. La gua didcticaes el material educativo que
deja de ser auxiliar, para convertirse en herramienta valiosa de motivacin y
apoyo; pieza clave para el desarrollo del proceso enseanza a distancia,
porque promueve el aprendizaje autnomo al aproximar el material de
estudio al alumno (texto convencional y otras fuentes de informacin), a
travs de diversos recursos didcticos (explicaciones, ejemplos, comentarios,
esquemas y otras acciones similares a la que realiza el profesor en clase).




De ah la necesidad de que la Gua Didctica, impresa o en formato
digital, se convierta en el andamiaje (J. Bruner) que posibilite al estudiante
avanzar con mayor seguridad en el aprendizaje autnomo.


2.4.1 FUNCIONES BSICAS DE LA GUA DIDCTICA
La Gua Didctica cumple diversas funciones, que van desde
sugerencias para abordar el texto bsico, hasta acompaar al alumno a
distancia en su estudio en soledad. Cuatro son los mbitos en los que se
podra agrupar las diferentes funciones:
Funcin motivadora:
o Despierta el inters por la asignatura y mantiene la
atencin durante el proceso de auto estudio.
o Motiva y acompaa al estudiante travs de una
conversacin didctica guiada. (Holmberg, 1985).
Funcin facilitadora de la comprensin y activadora del
aprendizaje:
o Propone metas claras que orientan el estudio de los
alumnos.
o Organiza y estructura la informacin del texto bsico.
o Vincula el texto bsico con los dems materiales
educativos seleccionados para el desarrollo de la
asignatura.
o Completa y profundiza la informacin del texto bsico.
o Sugiere tcnicas de trabajo intelectual que faciliten la
comprensin del texto y contribuyan a un estudio eficaz
(leer, subrayar, elaborar esquemas, desarrollar
ejercicios).



o Suscita un dilogo interior mediante preguntas que
obliguen a reconsiderar lo estudiado (Marn Ibez,
1999).
o Sugiere distintas actividades y ejercicios, en un esfuerzo
por atender los distintos estilos de aprendizaje.
o Aclara dudas que previsiblemente pudieran obstaculizar el
progreso en el aprendizaje.
o Incita a elaborar de un modo personal cuanto va
aprendiendo, en un permanente ejercicio activo de
aprendizaje (Marn Ibez, 1999).
o Especifica estrategias de trabajo para que el alumno
pueda realizar sus evaluaciones a distancia.
Funcin de orientacin y dilogo:
o Fomenta la capacidad de organizacin y estudio
sistemtico.
o Promueve la interaccin con los materiales y compaeros.
o Anima a comunicarse con el profesor-tutor.
o Ofrece sugerencias oportunas para posibilitar el
aprendizaje independiente.
Funcin evaluadora:
o Activa los conocimientos previos relevantes, para
despertar el inters e implicar a los estudiantes. (Martnez
Mediano, 1998: p.107)
o Propone ejercicios recomendados como un mecanismo de
evaluacin continua y formativa.
o Presenta ejercicios de autocomprobacin del aprendizaje
(autoevaluaciones), para que el alumno controle sus



progresos, descubra vacos posibles y se motive a superar
las deficiencias mediante el estudio.
o Realimenta constantemente al alumno, a fin de provocar
una reflexin sobre su propio aprendizaje.
o Especifica los trabajos de evaluacin a distancia.

2.4.2 ESTRUCTURA DE LA GUA DIDCTICA
Cuando se ha elegido trabajar con textos convencionales o de mercado,
como es nuestro caso, es indispensable elaborar Guas Didcticas muy
completas, que potencien las bondades y compensen los vacos del texto
bsico; para lo cual hemos optado por una Gua Didctica que contemple los
apartados siguientes:
1. Datos informativos.
2. ndice.
3. Introduccin.
4. Objetivos generales.
5. Contenidos.
6. Bibliografa.
7. Orientaciones Generales.
8. Orientaciones especficas para el desarrollo de cada unidad.
Unidad/nmero y ttulo.
Objetivos especficos.
Sumario (temas de la unidad).
Breve introduccin.
Estrategias de aprendizaje para conducir a la comprensin de los
contenidos de la asignatura.
Autoevaluacin.
9. Soluciones a los ejercicios de autoevaluacin.



10. Glosario.
11. Anexos.
12. Evaluaciones a distancia.




CAPTULO III: MARCO METODOLGICO


3.1 Nivel de Investigacin

Segn Arias, F. en 1999. El nivel de investigacin se refiere al grado de
profundidad con que se aborda un objeto o fenmeno. Aqu se indicar si se
trata de una investigacin exploratoria, descriptiva o explicativa. En
cualquiera de los casos es recomendable justificar el nivel adoptado.
Segn el nivel, la investigacin se clasifica en:
Investigacin Exploratoria: es aquella que se efecta sobre un
tema u objeto poco conocido o estudiado, por lo que sus
resultados constituyen una visin aproximada de dicho objeto.
Investigacin Descriptiva: consiste en la caracterizacin de un
hecho, fenmeno o supo con establecer su estructura o
comportamiento.
Investigacin Explicativa: se encarga de buscar el por qu de los
hechos mediante el establecimiento de relaciones causa-efecto.

Segn las definiciones dadas; esta investigacin es descriptiva; ya que
se detallaran todas y cada unas de la unidades de estudio en la asignatura
Objetos y abstraccin de datos.

3.2 Diseo de Investigacin

El diseo de investigacin es la estrategia que adopta el investigador
para responder al problema planteado.



En atencin al diseo, la investigacin se clasifica en:
Investigacin Documental: es aquella que se basa en la
obtencin y anlisis de datos provenientes de materiales
impresos u otros tipos de documentos.
Investigacin de Campo: consiste en la recoleccin de datos
directamente de la realidad donde ocurren los hechos, sin
manipular o controlar variable alguna.
Investigacin Experimental: proceso que consiste en someter a
un objeto o grupo de individuos a determinadas condiciones o
estmulos (variable independiente), para observar los efectos que
se producen (variable dependiente).


Segn las definiciones anteriores, esta investigacin segn su diseo
es documental, puesto que se realizara una consulta bibliogrfica para
desarrollar la gua abarcando las unidades de la asignatura.


CAPTULO IV: REPASO DE CONCEPTOS
FUNDAMENTALES DE ALGORITMOS Y LA
PROGRAMACIN, BASADA EN EL PARADIGMA
ORIENTADO A OBJETOS

4.1. Objetivos de la Unidad

Definir con sus propias palabras la programacin orientada a
objetos segn los conceptos y caractersticas discutidas.
Identificar elementos bsicos de la programacin orientada a
objetos en la vida cotidiana, con un buen margen de precisin.

4.2. Contenido de la Unidad

Repaso del concepto de algoritmo.
Definicin de programacin.
Definicin de paradigma.
Tipos de paradigma.
Definicin programacin orientada a objetos.
Definicin de elementos bsicos de la programacin orientada a
objetos.

4.2.1. Repaso del concepto de algoritmo

4.2.1.1. Definicin de Algoritmo



Algoritmo: una secuencia de pasos finitos, definidos, que permiten
hallar la solucin genrica de un problema. Dado un estado inicial y una
entrada, a travs de pasos sucesivos y bien definidos se llega a un estado
final, obteniendo una solucin. Los algoritmos son objeto de estudio de la
algoritmia [Brassard, Gilles; Bratley, Paul (1997). Fundamentos de
Algoritmia. Madrid: PRENTICE HALL]
Un algoritmo se puede llevar a cualquier lenguaje de programacin

4.2.1.2. Caractersticas de Algoritmo

Repetitividad, solucin genrica de un problema.
Pasos bien ordenados.
Debe ser finito, tener un inicio y un fin.
Los pasos deben ser precisos, no ambiguos.
Deben ser independientes de plataformas computacionales, y
lenguajes de programacin.
Eficiencia (espacial, temporal)

4.2.1.3. Formas de expresar un algoritmo

Diagramas de flujos: usando figuras que tienen un significado
para procesos, entradas y salidas de datos por diferentes
dispositivos, unidos por flechas que dan el sentido a los pasos
involucrados. Poco usado actualmente.
Pseudocodigo: un lenguaje que se asemeja a un lenguaje de
programacin y al lenguaje natural. Es casi un cdigo para


desarrollar un algoritmo, pero se debe manejar las palabras
representan cada sentencia.
Lenguaje Natural: es el lenguaje con el cual nos comunicamos los
seres humanos. No muy recomendable porque se puede tornar
muy largo con la descripcin, o poco entendible.

Ejemplos:
Segn las caractersticas, antes mencionadas podr ser un manual
de usuario de un reproductor de msica un algoritmo? O una receta de
cocina?
La respuesta es no, porque en un manual de usuario los pasos que
se dictan no necesariamente tienen que seguir ese orden para tener un
xito.
La receta de cocina tampoco es un algoritmo, porque una
pizca de sal o pimienta al gusto no es para nada precisa.

4.2.1.4. Elementos de un algoritmo

En un algoritmo se hace uso de:
Variables: un nombre simblico que identifica un determinado
espacio de memoria donde es almacenado un valor que puede
cambiar.
Constantes: un nombre simblico de un espacio de memoria que
almacena un dato que no varia durante el algoritmo.
Operadores: smbolos que representan una operacin, ya sea
aritmtica, relacional, lgica, de asignacin.
Bloques: son espacios delimitados que hacen tareas especficas.
Ejemplo llaves, o palabras que indiquen el inicio y fin del bloque.


mbito: es el ciclo de vida de un elemento, Por ejemplo una
variable.
Estructuras de control: son usadas para condicionar la secuencia
que debe seguir el algoritmo, si segn un valor(es) el algoritmo
debe hacer una serie de pasos entonces se utilizan las sentencias
selectivas: SI-SINO, SELECCIN-CASO.
Estructuras repetitivas: su uso es para que una serie de pasos se
repitan mientras una(s) expresin booleana(es) sean verdaderas:
MIENTRAS, HACER-MIENTRAS, PARA.
Entrada y salida: para interactuar con datos suministrados desde
fuera del algoritmo es la entrada, y la informacin que se genera es
la salida.

4.2.1.5. Ejemplo de un algoritmo expresado tanto en diagrama
de flujo como en pseudocdigo

En el siguiente algoritmo se resuelve el problema de verificar si un
numero n, es no primo.

En pseudocdigo:
Observe la Figura 4.1, donde se muestra un algoritmo enxpresado en
pseudocdigo

En Diagrama de flujo de datos:
Obseve en la Figura 4.2, el algoritmo para determinar si un nmero es
primo o no, expresado en diagrama de flujo




1- Inicio_Algoritmo
2- Contador , n : entero;
3- Contador 0 ; #Asignar 0 a una variable Contador.
4- Leer ( n ) ; # el valor del nmero y asignrselo a la variable n.
5- Para c 2 hasta n - 1 hacer
6- Inicio_Para
7- Si residuo de n/c = 0 entonces
8- Inicio_Si
9- Contador Contador + 1 ;
10- Fin_Si
11- Fin_Para
12- Si contador <> 0 entonces
13- Inicio_Si
14- Escribir ( El numero + n + no es primo ) ;
15- Sino
16- Escribir ( El numero + n + es primo ) ;
17- Fin_Si
Fin_algoritmo
Figura 4.1. Algoritmo en pseudocdigo, para determinar si un nmero es primo o no.
Fuente: Propia

4.2.2. Definicin de programacin

Programa: un algoritmo traducido a un lenguaje de programacin,
que generalmente tiene una entrada de datos que es necesario para
realizar un(os) proceso(s) y generar una salida como respuesta.

Lenguaje de Programacin: Es un lenguaje artificial que puede ser
usado para controlar el comportamiento de una mquina, especialmente
una computadora. Estos se componen de un conjunto de reglas


sintcticas y semnticas que permiten expresar instrucciones que luego
sern interpretadas.
Inicio
Contador 0
N
C 0
R
R residuo de N / C
N
Si
C < N
Si
R = 0
C C + 1
si
Si
C = 0
no
El numero no
es primo
El numero es
primo
si
no si
no
Fin

Figura 4.2. Algoritmo en diagrama de flujo, para determinar si un nmero es primo o
no.
Fuente: Propia

Clasificacin de Lenguajes de programacin: Existen tres (3) tipos
de lenguajes

De mquina. Cuyas ordenes estn compuestas por ceros y unos
(0s y 1s); su principal caracterstica es su bajo nivel de


interpretacin por parte del usuario. Es el lenguaje que interpreta
de modo directo la UCP y sus instrucciones estn basadas en
BITS. Este lenguaje no requiere de traductor.
Ej. 0011010101111001 -> Instruccin 1
1111001100001010 -> Instruccin 2
De bajo nivel. Ya que el lenguaje de mquina es de muy difcil
comprensin, los fabricantes de microprocesadores han definido
lenguajes ensambladores que traducen las rdenes dadas por el
usuario a rdenes que puedan ser ejecutadas por la mquina
(lenguaje de mquina). Estas estn basadas en etiquetas
nemnicas o simplemente nemnicos.
Ej. Mov A,1C -> Instruccin 1
Add A,B -> Instruccin 2
De alto nivel. Estos lenguajes permiten escribir programas de una
manera semejante a como nos expresamos en lenguaje natural,
con la salvedad de que generalmente las instrucciones estn
definidas en Ingles.
Ej. printf(hola); Lenguaje C
Writeln(Hola); Lenguaje Pascal
System.out.print(Hola); Lenguaje Java

Estructura de un programa, depende del lenguaje en que se
desarrolle, sin embargo en la mayora de los lenguajes un programa tiene
la siguiente estructura:
Encabezado o Cabecera: En esta seccin, se hace el llamado a
las libreras, o paquetes, sean propias del lenguaje utilizado, o
realizadas por programadores con anterioridad; estas libreras o


paquetes contienen funciones o clases que se necesitaran para
desarrollar el nuevo programa; por ejemplo:
o include < nombre_de_la_libreria . h >
Lenguaje C/C++
o import nombre_del Paquete . nombre_de_la_clase;
Lenguaje Java:
Inicio: todo programa tiene un inicio, al igual que los algoritmos;
ste inicio puede ser con una palabra que lo represente, o con una
llave de apertura.
Cuerpo: es esta seccin van las instrucciones que conforman el
programa.
Fin: al igual que los algoritmos, un programa tiene un fin; partiendo
que todo lo que empieza finaliza, si se tiene un inicio se debe tener
un fin, ste depende del el lenguaje, es representado por una
palabra o una llave de finalizacin.

Lenguajes tipificados: son aquellos, donde las variables adoptan
un tipo, con el rango de valores que pueden almacenar.

Lenguajes no tipificados: son aquellos que no restringen el rango
de valores que puede tomar una variable.

Para los programas desarrollados en lenguajes de
programacin tipificados se deben manejar los siguientes trminos.

Datos: Representacin formal de hechos, conceptos o
instrucciones adecuada para su comunicacin, interpretacin y
procesamiento por seres humanos o medios automticos.


Tipos de datos: Especificacin de un dominio (rango de valores) y
de un conjunto vlido de operaciones a los que normalmente los
traductores asocian un esquema de representacin interna propio,
el dominio es determinado por el numero de bits que puede ocupar
en memoria.
Clasificacin de los tipos de datos:
o En funcin de quien los define.
Tipos de datos primitivos (definidos por el lenguaje de
programacin usado, no se construyen a partir de
otros tipos y son entidades nicas).
Tipos de datos definidos por el usuario.
o En funcin de su representacin interna
Tipos de datos escalares o simples.
Tipos de datos estructurados.
Programa: Una serie de instrucciones que le indican al
computador la tarea que debe llevar a cabo para poder lograr un
objetivo o solucionar un problema, estas instrucciones deben estar
expresadas en un lenguaje que el computador pueda traducir a su
lenguaje de mquina y as ejecutar las instrucciones dadas. Es una
especie de algoritmo escrito en un lenguaje entendido por el
computador.
Programacin: Es la accin de realizar un programa. es
automatizar y definir una serie de procesos para resolver un
problema y obtener un resultado final. Es el proceso de analizar,
escribir y probar, depurar y mantener un cdigo programado.




4.2.3. Definicin de paradigma

El concepto paradigma procede del griego paradeigma, que significa
ejemplo o modelo. En principio, se aplicaba a la gramtica (para
definir su uso en un cierto contexto) y a la retrica (para referirse a una
parbola o fbula). A partir de la dcada del 60, comenz a utilizarse
para definir a un modelo o patrn en cualquier disciplina cientfica o
contexto epistemolgico.

El filsofo y cientfico estadounidense Thomas Kuhn fue el
encargado de actualizar el trmino y darle el significado contemporneo,
al adaptarlo para referirse al conjunto de prcticas que defines una
disciplina cientfica durante un perodo especfico de tiempo.

De esta forma, un paradigma cientfico establece aquello que se
debe observar; el tipo de interrogante que hay que formular para hallar las
respuestas en relacin al objetivo; cmo deben estructurarse dicho
interrogantes; y cmo deben interpretarse los resultados de la
investigacin cientfica.

Paradigmas de programacin: Un paradigma de programacin es un
modelo bsico de diseo y desarrollo de programas, que permite producir
programas con unas directrices especficas, tales como: estructura
modular, fuerte cohesin, alta rentabilidad, entre otros. Un paradigma de
programacin es una coleccin de modelos conceptuales que juntos
modelan el proceso de diseo y determinan, al final, la estructura de un
programa.


4.2.4. Tipos de paradigma
El paradigma a usar para resolver un problema, debe ser
codificado en un lenguaje de programacin compatible con l y capaz
soportar los mismos conceptos del propio paradigma.
Esta compatibilidad hace confundir los conceptos de paradigma y
lenguaje de programacin, mezclando al propio paradigma con su
herramienta de proceso. Al respecto, para no caer en este error
conviene destacar que un mismo paradigma puede ser soportado por
ms de un lenguaje, y un lenguaje puede soportar ms de un
paradigma, como el C++.
El paradigma es el concepto o heurstica intangible, mientras que
el lenguaje es su materializacin en forma de cdigos operacionales.
Los tipos de paradigmas de la programacin, son los siguientes:

Programacin Imperativa. Propicia un entorno de programacin
procedimental, en el que la secuencia de control y el concepto de
variable son sus componentes fundamentales.
Programacin Orientada por Objetos. Resuelve problemas
pensando en objetos, y hace posible la reutilizacin de software.
Programacin Funcional. La programacin funcional, es un
modelo basado en la evaluacin de funciones matemticas,
entendidas como mecanismos para aplicar ciertas operaciones
sobre algunos valores o argumentos, para obtener un resultado o
valor de la funcin para tales argumentos.
Programacin lgica. Resuelve problemas descriptos como las
relaciones de un conjunto de datos, sobre las que aplica reglas de


deduccin y a partir de tales premisas genera conclusiones
aceptadas como validas. Usa la lgica de predicados, o aserciones
lgicas que representan el conocimiento sobre un mbito.
Programacin Concurrente. ste paradigma se basa en la
capacidad de disear y programar tareas que puedan ser
ejecutadas al mismo tiempo, es decir que se pueden efectuar
mltiples acciones simultneamente.

En esta asignatura, los programas se desarrollaran en el paradigma
orientado a objetos; cabe mencionar que los estudiantes tambin utilizarn
los dems paradigmas citados

4.2.5. Definicin programacin orientada a objetos

4.2.5.1. Programacin Orientada a Objetos:

La Programacin Orientada a Objetos (POO u OOP para la sigla
en ingls) es un paradigma de programacin que define los
programas en trminos de "clases de objetos.
Los objetos son entidades que combinan estado (datos) y
comportamiento (procedimientos o mtodos).
La programacin orientada a objetos expresa un programa como
un conjunto de estos objetos (en tiempo de ejecucin), que se
comunican entre ellos para realizar tareas.
Esto difiere de los lenguajes procedurales tradicionales, en los que
los datos y los procedimientos estn separados y sin relacin.
Ejemplos: Delphi, Java, C++, Python.


4.2.5.2. Caractersticas:

Abstraccin. La abstraccin de datos permite no preocuparse de
los detalles no esenciales. Las estructuras de datos y los tipos de
datos son un ejemplo de abstraccin. En la abstraccin se
destacan los aspectos relevantes del objeto e ignorar los aspectos
irrelevantes del mismo (la irrelevancia depende del nivel de
abstraccin, ya que si se pasa a niveles ms concretos, es posible
que ciertos aspectos pasen a ser relevantes).
Encapsulacin. El encapsulamiento consiste en unir en la clase
las caractersticas y comportamientos, esto es, las variables y
mtodos. Es tener todo esto es una sola entidad. En los lenguajes
estructurados esto era imposible. Es evidente que el
encapsulamiento se logra gracias a la abstraccin y el
ocultamiento. La utilidad del encapsulamiento va por la facilidad
para manejar la complejidad, ya que tendremos a las Clases como
cajas negras donde slo se conoce el comportamiento pero no los
detalles internos, y esto es conveniente porque nos interesar ser
conocer qu hace la Clase pero no ser necesario saber cmo lo
hace.
Principio de ocultamiento. Es la capacidad de ocultar los detalles
internos del comportamiento de una Clase y exponer slo los
detalles que sean necesarios para el resto del sistema. El
ocultamiento permite dos (2) cosas: restringir y controlar el uso de
la Clase, restringir porque habr cierto comportamiento privado de
la Clase que no podr ser accedido por otras Clases, y controlar
porque se proveer ciertos mecanismos para que se pueda
modificar el estado de la Clase y es en estos mecanismos dnde


se validarn que algunas condiciones se cumplan. En los
lenguajes de programacin que soportan este paradigma el
ocultamiento se logra usando las palabras reservadas que se
pueden traducir como: publica, privada y protegida delante de las
variables y mtodos.
Herencia. La herencia es uno de los conceptos ms cruciales en la
POO. La herencia bsicamente consiste en que una clase puede
heredar sus variables y mtodos a varias subclases (la clase que
hereda es llamada superclase o clase padre y la heredada llamada
subclases o clases hijas). Esto significa que una subclase, aparte
de los atributos y mtodos propios, tiene incorporados los atributos
y mtodos heredados de la superclase. De esta manera se crea
una jerarqua de herencia. La importancia de la herencia radica, en
que es una forma de reutilizacin de software, con esto se ahorra
tiempo durante el desarrollo de programas; tambin fomenta la
reutilizacin de software depurado y probado de alta calidad, el
cual aumenta la probabilidad de que un sistema se implemente con
efectividad.
Polimorfismo. Es la propiedad que tienen los objetos de permitir
invocar genricamente un comportamiento (mtodo) cuya
implementacin ser delegada al objeto correspondiente recin en
tiempo de ejecucin. La caracterstica del polimorfismo es critica
porque permite que varios tipos (derivados de un mismo tipo base)
sean tratados como si fueran uno slo, y un nico fragmento de
cdigo, se puede ejecutar de igual forma en todos los tipos
diferentes. La llamada a un mtodo polimrfico permite que un tipo
exprese su distincin de otro similar, puesto que ambos se derivan
del mismo tipo base. Esta distincin se expresa a travs de


diferencias en comportamiento de los mtodos a los que se puede
invocar a travs de la clase base.

Estas dos (2) ltimas caractersticas se ilustrarn en la
unidad 4, mientras las otras en la unidad 2.

4.2.6. Definicin de elementos bsicos de la programacin
orientada a objetos

Elementos Bsicos:

Objeto: es una coleccin de datos y subrutinas o mtodos que
operan sobre ellos. Pueden representarse cosas fsicas o
abstractas, que tienen un estado y un comportamiento. Ejemplo un
estudiante, un crculo, una fraccin, un polinomio entre otros, se
consideran objetos. Ciertas propiedades definen a un objeto y se
conocen como campos de datos o propiedades y el
comportamiento de los objetos se definen como mtodos.
Clases: son aquellas estructuras o plantillas que sirven para
describir un objeto. Una clase tiene un nombre y especifica los
miembros que pertenecen a ella, que pueden ser campos de datos
y mtodos. Una vez que se define una clase, el nombre de sta se
convierte en un nuevo tipo de dato y se puede declarar variables
de ese tipo y crear objetos de este tipo.
Mensajes: estos estn asociados con un mtodo, de tal forma que
cuando un objeto recibe un mensaje la respuesta a ese mensaje
es ejecutar el mtodo asociado, Por ejemplo, partamos de que una
ventana de Windows es un objeto entonces cuando un usuario


quiere maximizar una ventana de una aplicacin Windows, lo que
hace simplemente es pulsar el botn de la misma que realiza esa
accin. Eso, provoca que Windows enve un mensaje a la ventana
para indicar que tiene que maximizarse. Como respuesta a este
mensaje se ejecutar el mtodo programado para ese fin.
Mtodos: Se implementa en una clase de objetos y determina
cmo tiene que actuar el objeto cuando recibe el mensaje
vinculado con ese mtodo. A su vez, un mtodo puede tambin
enviar mensajes a otros objetos solicitando una accin o
informacin. En adicin, las propiedades definidas en la clase
permitirn almacenar informacin para dicho objeto.

Diferencia entre objeto y clase:
El objeto es una entidad concreta que existe en tiempo y espacio
mientras una clase representa una abstraccin, la esencia de un
objeto.
Diferencia entre mensaje y mtodos:

El mtodo es una operacin mientras que el mensaje es la
indicacin de que se ejecute el mtodo involucrado con ste.
Ejemplos

de objetos
Libro Java cmo programar de Deitel- Deitel.
Libro Java 2 Curso de Programacin de Ceballos.
En la Figura 2.4. Se puede observar el ejemplo de objetos







Figura 2.4. Ejemplo de Objetos
Fuente: Propia

de Clase
Libro
Clase Libro{
titulo, autores, edicin, editorial, ao}
En la Figura 2.5; se observa el ejemplo de clase Libro
Metodos
De la Figura 2.5 se puede observar evaluar( ) y actualizar ( )
que son mtodos de la clase Libro, son operaciones que se le
pueden aplicar a un objeto de ese tipo de dato.
Mensajes
Los mensajes serian los siguientes:
libroDeMatematicas . evaluar ( ) ;
libroDeFisica . actualizar ( ) ;

De estos ejemplos se puede observar, como una clase describe a
instancias, mientras los objetos son entidades con sus propiedades
perteneciente a una clase; tambin se puede ver que los mtodos son
operaciones dentro de una clase y la llamada a estos son los mensajes.
Libro Java cmo
programar de
Deitel- Deitel.
Libro Java 2 Curso
de Programacin
de Ceballos.



Clase Libro
titulo
autor
editorial
edicin
ao

evaluar ( )
actualizar ( )

Figura 2.5 Ejemplo de clase Libro
Fuente: Propia

Los programas usados para ilustrar los conceptos de la Programacin
orientada a objetos, se crearn con el lenguaje de programacin de alto nivel
Java.



CAPTULO V: ABSTRACCIN Y ENCAPSULACIN DE DATOS

5.1. Objetivos

Definir el concepto de abstraccin encapsulacin de datos con
sus propias palabras, segn lo estudiado en clase.
Discutir la abstraccin y encapsulacin de datos y los tipos de
abstraccin, usando ejemplos de la vida cotidiana, basado en lo
estudiado en la clase.
Resolver un problema propuesto por el docente, usando la
abstraccin y encapsulacin de datos en la programacin
orientada a objetos, con un buen margen de precisin.

5.2. Contenido

Definicin de abstraccin de datos. Definicin de
encapsulamiento.
Tipos de abstraccin existentes. Ejemplos de aplicacin de la
abstraccin y encapsulacin de datos.
Ejemplos de programas resueltos donde se aprecie la abstraccin
y encapsulacin de datos de la programacin orientada a objetos.
Resolucin de problemas usando programacin orientada a
objetos, haciendo nfasis en la abstraccin y encapsulacin de
datos.





5.2.1. Definicin de abstraccin de datos. Definicin de
encapsulamiento.

En cualquier parte del mundo real se puede ver objetos: gente,
animales, plantas, aviones, edificios, computadores, etc. Los seres humanos
piensan en forma de objetos. Los humanos aprenden de los objetos
estudiando sus atributos y observando sus comportamientos, distintos
objetos pueden tener atributos similares y pueden exhibir comportamientos
similares.

La abstraccin es la habilidad de generalizar y centrarse en los
aspectos que permitan tener una visin global del problema y no detenerse
en los detalles concretos de lo que no interesa en un momento determinado.
Ejemplo en el estudio de un computador se puede realizar a nivel de
funcionamiento de sus circuitos electrnicos, en trminos de corriente,
tensin, etc., o a nivel de transferencia entre registros, centrndose as el
estudio en el flujo de informacin entre las unidades que lo componen
(memoria, unidad aritmtico-lgica, registros, etc.), sin importar el
comportamiento de los circuitos electrnicos que componen estas unidades.

Segn la real academia, abstraer es separar por medio de una
operacin intelectual las cualidades de un objeto para considerarlas
aisladamente o para considerar el mismo objeto en su pura esencia o nocin.

En la abstraccin de datos el cliente se preocupa acerca de que
funcionalidad ofrece un objeto dado, pero no acerca de cmo se implementa
esa funcionalidad.



Mientras la encapsulacin permite ver un objeto como una caja negra
en la que se ha introducido de alguna manera toda la informacin
relacionada con dicho objeto. Esto permite manipular los objetos como
unidades bsicas, permaneciendo oculta su estructura interna.

La abstraccin y encapsulamiento estn representadas por la clase. La
clase es una abstraccin, porque en ella se definen las propiedades o
atributos de un determinado conjunto de objetos con caractersticas
comunes, y una encapsulacin porque constituye una caja negra que
encierra tanto los datos que almacena cada objeto como los mtodos que
permiten manipularlos.

5.2.2. Tipos de abstraccin existentes. Ejemplos de aplicacin de
la abstraccin y encapsulacin de datos.

5.2.2.1. Tipos de abstraccin existentes

Abstraccin funcional: crear procedimientos y funciones e
invocarlos mediante un nombre donde se destaca que hace la
funcin y se ignora como lo hace.
Abstraccin de datos:

o Tipos de datos: La representacin usada es invisible al
programador, al cual se permite ver las operaciones
predefinidas para cada tipo.


o Tipos definidos por el programador: que posibilitan la
definicin de valores de datos ms cercanos al problema
que se pretende resolver. Ejemplo estructuras de datos.
o Tipos abstracto de datos, para la definicin y
representacin de tipos de datos, junto con sus
propiedades.

5.2.2.2. Ejemplos de aplicacin de la abstraccin y encapsulacin
de datos

Para mostrar los ejemplos de la aplicacin de la abstraccin y el
encapsulamiento de datos, se deben manejar algunos conceptos
relacionados con la programacin orientada a objetos; tambin nociones y
reglas del lenguaje de programacin Java, a continuacin loe elementos de
un programa, luego clases y objetos.

5.2.2.2.1. Elementos de un programa

Los identificadores, son los nombres que se le asignan a las
variables, constantes, mtodos, clases, paquetes, interfaces, stos
deben ser descriptivos, y evitar nombres genricos como lo son
variable1, constante, entre otros; para los identificadores deben
usarse palabras que hagan referencia a lo que representen, el nombre
de una clase debe representar que esta describiendo, al igual para las
variables y mtodos.
En el lenguaje Java los identificadores deben comenzar con
letras carcter de subrayado ( _ ) carcter de dlar ( $ ) no pueden
comenzar con nmeros, no pueden tener espacios en blanco, ni caracteres


especiales que representen algn operador dentro del lenguaje, ni usar
palabras reservadas del lenguaje en uso; en el lenguaje java esta permitido
el uso de , como carcter valido para los identificadores. En dicho
lenguaje se acostumbra que los nombres de las clases comiencen en
maysculas, los de las variables y mtodos en minsculas y las constantes
todas en maysculas; en Java se diferencia las minsculas de las
maysculas.
Tipos de Datos: En java los tipos de datos se clasifican en
o Primitivos: en ste lenguaje existen ocho (8) tipos de datos
primitivos se dividen en numricos y el boolean, a su vez los
numricos se clasifican en nmeros enteros y nmeros reales.
Cada tipo tiene un rango diferente de valores positivos y
negativos excepto el boolean que slo tiene dos valores (true
false). El tipo de datos que se escoja para declarar las variables
de un determinado programa depender del rango y tipo de
valores que se vaya a almacenar en cada una. Se les llama
primitivos porque ellos estn integrados en el sistema y no son
objetos. A continuacin se van a presentar de esta forma: tipo
de dato (descripcin, cantidad de bits y rango segn la cantidad
de bits usado).
byte nmero entero de 8 bits, rango: -128, +127
short numero entero pequeo de 16 bits, rango: -
32768,+32767
int nmeros enteros de 32 bits, rango: -2147483648,
+2147483647, se pueden representar en las bases
decimal (10), octal (8), y hexadecimal (16); para la base
10 se puede usar los dgitos de 0 a 9, sin que el primer
dgito del numero sea cero (0), ejemplo: 9852; mientras


para la base 8, son los dgitos de 0 a 7, y debe comenzar
con cero (0), ejemplo 052; y para la base 16 los diogitos
vlido son de 0 a 9 y de A F, deben comenzar con un
cero seguido de una equis (0x), ejemplo 0x42B.
long numero entero grande de 64 bits, rango:
9223372036854775808, +9223372036854775807)
char carcter alfabtico, numrico o especial,
representado por un nmero del cdigo Unicode,
comprendidos en el rango de 0, 65535, ste cdigo es
de 16 bits y es un estndar de codificacin de
caracteres, el trmino Unicode proviene de los tres
objetivos perseguidos: Universalidad, uniformidad y
unidad.
float nmeros en coma flotante, con una precisin
aproximada de siete (7) dgitos, y con 32 bits para su
representacin en el formato IEEE 754 (este formato
utiliza 1 bit para el signo, 8 bits para el exponente y 24
para la mantisa)
double nmeros en coma flotantes de 64 bits en el
formato IEEE 754 (1 bit para el signo, 11 bits para el
exponente, y 52 bits para la mantisa) y con una precisin
aproximada de 16 dgitos.
boolean se utiliza para indicar si el resultado de la
evaluacin de una expresin booleana es verdadero
falso. Los dos posibles valores son true false (son
palabras reservadas de Java).
o Representacin de variables de tipos primitivos en
memoria: a continuacin se presenta la tabla 5.1 con un
ejemplo de como se representan los datos primitivos en la


memoria, fjese que el byte se almacena en 1 posicin de
memoria, mientras el short en 2 posiciones consecutivas. Es
importante recalcar que este es slo un ejemplo, para ilustrar
los datos en memoria, realmente cuando son declarados varios
datos no se almacenan en posiciones sucesivas.
o

Tabla 5.1. Ejemplo de la representacin de datos primitivos en memoria (1/2)
Tipo de dato Direccin de
memoria
Contenido en
memoria
byte b = 95 3452FA 95
short s = 2563
3452FB
2563
3452FC
int i = 200520
3452FD
200520
3452FE
3452FF
345300
long l = 2589256
345301
2589256
345302
345303
345304
345305
345306
345307
345308
char a= s 345309 s
34530A
Fuente: Propia




Tabla 5.1. Ejemplo de la representacin de datos primitivos en memoria(2/2)
float f = 256,562
34530B
256,562
34530C
34530D
34530E
52oubl d =
5,623415963
34530F
5,623415963
345310
345311
345312
345313
345314
345315
345316
boolean b = true; Depende de la plataforma
Fuente: Propia

o Conversiones en Java: Cuando Java tiene que evaluar una
expresin en la intervienen operandos de diferentes tipos,
primero convierte, slo para realizar las operaciones solicitadas,
los valores de los operandos al tipo del operando cuya precisin
sea ms alta. Cuando se trate de una asignacin, convierte el
valor de la derecha al tipo de la variable de la izquierda siempre
que no haya prdida de informacin. En otro caso, Java exige
que la conversin se realice explcitamente. La figura 2.1
resume los tipos colocados de izquierda a derecha de menos a
ms precisos; las flechas indican las conversiones implcitas
permitidas:




Figura 5.1.Conversin implcitas de tipos de datos primitivos
Fuente: Propia

Del ejemplo de la Figura 5.1, se puede concluir:
byte bDato = 1 ;
short sDato =0 ;
int iDato = 0 ;
long lDato = 0 ;
float fDato = 0 ;
double dDato = 0 ;

sDato = bDato ;
iDato = sDato ;
lDato = iDato;
fDato = lDato;
dDato = fDato + lDato iDato * sDato / bDato;

Java permite una conversin explcita del tipo de una
expresin mediante una construccin denominada cast, que
tiene la siguiente forma:
(tipo) expresin
Cualquier valor de u tipo entero o real puede ser
convertido a o desde cualquier tipo numrico. No se pueden
realizar conversiones entre los tipos enteros o reales y el tipo
boolean, observe el siguiente ejemplo:
char
short byte
int long float double



byte bDato = 0 ;
short sDato =0 ;
int iDato = 0 ;
long lDato = 0 ;
float fDato = 0 ;
double dDato = 2 ;

fDato = ( float ) dDato ;
lDato = ( long ) fDato ;
iDato = ( int ) lDato ;
sDato = ( short ) iDato ;
bDato = ( byte ) ( sDato + iDato - lDato * fDato / dDato ) ;

La expresin es convertida al tipo especificado si esa
conversin est permitida; en otro caso, se obtendr un error.
La utilizacin apropiada de construcciones cast garantixa una
evaluacin consistente, pero siempre que se pueda, es mejor
evitarla ya que suprime la verificacin de tipo proporcionada por
el compilador y por consiguiente puede conducir a resultados
inesperados, o cuando menos, a una prdida de precisin en el
resultado. Por ejemplo:

double d=10.0/3.0; //el resultado de d:
3.33333333333333335
float r= (float)(10/3.0); // el resultado de r: 3.3333333
Referenciados son clases, interfaces y arrays; estos se ilustrarn en
unidades posteriores


Literales: es la expresin de un valor de un tipo primitivo, puede ser
de:
o Literales Enteros: si no se especifica el signo es positivo por
defecto; [ +/- ]nmero-entero. Para los int +4, 25896, -95; para
los long 48654l 789654L la letra l L es si el numero esta
dentro del rango de un int entonces declararlo que a pesar de
esto es un long;
o Literales Reales: estn formados por una parte entera,
seguido de un punto decimal y una parte fraccionaria, tambin
se permite la notacin cientfica; [ +/- ] parte-entera . parte-
parte-fraccionaria [ e / E +/- exponente ] Para double
159423698.256; 125.1e+3; estos literales por defecto sern
double a menos que se coloque una letra f F al final del
nmero, 25.8f.
o Literales de un solo carcter: son para los char y esta dado
por un solo carcter encerrado entre comillas simples a, 6,
\n, &.
o Literales de cadenas de caracteres: es una secuencia de
caracteres encerrados entre comillas dobles, hola mundo,
esto es una cadena de caracteres!, 14616683; en Java stas
estn descrita con una clase llamada String, vea el punto 2.1 de
la Unidad 3.
Comentarios en Java: Un comentario esta dirigido a un programador
o alguna persona que lea el cdigo, ms no se ejecutar.
o De una lnea: esta representado por dos barras ( // ) el
comentario ser desde las dos barras hasta el fin de la lnea.
//Toda sta lnea es un comentario.


o Tradicional o de bloque: esta formado con una barra seguida
de un asterisco ( /* ) que inician el comentario hasta que se
encuentre un asterisco seguido de una barra ( */ ) que indican el
fin del comentario, sin importar cuantas lneas abarque dicho
comentario. Ejemplo:
/* Este es
un
comentario
de ms de una lnea
*/
o De documentacin: Este tipo comienza con una barra
seguida de doble asteriscos ( /** ) y finaliza con un
asterisco seguido de una barra
( */ ), son comentarios especiales que se utilizan
para generar la documentacin acerca del programa,
aunque tambin se pueden emplear de manera idntica
a los comentarios tradicionales.
Operadores: Son smbolos que indican cmo son manipulados los
datos. Se clasifican en:
o Aritmticos: Son aquellos usados para realizar la operaciones
matemticas:
Suma ( + ) de datos que deben ser enteros o reales (int,
short, long, float, double)
Resta ( - ) de datos que deben ser enteros o reales al
igual que en la suma
Multiplicacin ( * ) de datos que al igual que en la suma y
resta deben ser enteros o reales


Divisin ( / ) de datos que pueden ser enteros o reales,
aunque si son enteros el resultado tambin lo ser
porque es truncado, en el caso que sean real el
resultado tambin lo ser
Residuo ( % ) de datos que slo pueden ser enteros.

Ejemplos
int a = 2,b = 3,r = 0;
r = a + b; //r tienen el valor de 5
r = b - a; //r tienen el valor de 1
r = a * b; //r tienen el valor de 6
r = b / a; /* r tienen el valor de 1, fjese que el
valor tendra que ser 1.5 pero como los dos
operandos son enteros, entonces se trunca el
resultado. Mientras que */
float x = 2.0f, y = 3.0f, r2 = 0.0f;
r2 = y / x; //r tienen el valor de 1.5f aunque
r2 = b / a; /* r tienen el valor de 1.0f, porque los
operandos son de tipo enteros */
o Relacionales: permiten evaluar la igualdad y la magnitud. El
resultado de una evaluacin de este tipo es un valor booleano
true false.
Menor que ( < ), primer operando es mayor que el
segundo?
Mayor que ( > ), primer operando es menor que el
segundo?
Menor o igual que ( <= ), primer operando es menor o
igual que el segundo?


Mayor o igual que ( >= ), primer operando es mayor o
igual que el segundo?
Diferente ( != ), primer operando es diferente que el
segundo?
Es igual a ( == ), primer operando es igual que el
segundo?
Ejemplos:
boolean r;
float x = 5.2f, y = 2.6f;
r = x >= y; // el valor de r es true.
r = x < y; // el valor de r es false.
r = x == y; // el valor de r es false.
r = x != y; // el valor de r es true.
o Lgicos: Se utilizan junto a los operadores relacionales cuando
es necesario hacer ms de una pregunta, y el resultado de
estas operaciones son de tipo boolean.
AND (&& &), para que el resultado sea verdadero
todos los operandos involucrados deben ser verdaderos,
con (&&) si el primer operando evaluado es falso,
entonces los dems no son evaluados.
OR ( || | ) El resultado es verdadero si al menos una de
los operandos es verdadero, si se utiliza el (||) y el primer
operando es verdadero entonces los dems no son
evaluados.
NOT (!) es la negacin de un operando, si el operando
es verdadero entonces el resultado es falso y viceversa.



XOR (^) es un o exclusivo, si slo uno de los operandos
es verdadero el resultado es verdadero. Si hay ms de
uno verdadero el resultado es falso.

Ejemplos.
int p = 10, q = 0;
boolean r;
r = p != 0 && q != 0; // r = false.
r = p != 0 || q > 0; // r = true.
r = q < p && p <= 10; // r = true;
r = !r; // si r = true, entonces ahora es false y
sino es true.
o Unitarios, se aplican slo a un operando, en esta categora
puede entrar el NOT ( ! ) que ya se ha visto
Complemento a 1 ( ~ ), este operador cambia ceros por uno y
unos por ceros, el operando debe ser un tipo primitivo entero.
Complemento a 2 ( - ), es para calcular el complemento
a 2, que non es ms que el complemento a 1 ms 1, el
operador puede ser de un tipo primitivo entero real.

Ejemplos:
int a = 2, b = 0, c = 0;
c = -a; // c es igual a -2
c = ~b; // c es igual a -1
o A nivel de bits, permiten realizar con sus operandos las
operaciones AND, OR, XOR y desplazamientos, bit por bit. Los
operandos tienen que ser enteros.
AND a nivel de bits ( & ), en binario base 2.
OR a nivel de bits ( | ) , en binario base 2.


XOR a nivel de bits ( ^ ) , en binario base 2.
Desplazamiento a la izquierda rellenando con ceros por
la derecha. ( << )
Desplazamiento a la derecha rellenando con el bit de
signo por la izquierda. ( >> )
Desplazamiento a la derecha rellenando con ceros por la
izquierda. ( >>> )
Los operandos tienen que ser de un tipo primitivo
entero; en la Tabla 5.2. Se presentan algunos ejemplos

Tabla 5.2. Ejemplos de los operadores a nivel de bits
Instruccin Resulta Descripcin
int a = 255;
int r = 0;
int m = 32;

a = 255
r = 0
m = 32
Asignacin de las tres (3) variables
r = a & 017;

r = 15. Porque 017 esta expresado en la base 8
entonces (017)
8
(15)
10
(1111)
2
, y
(255)
10
(11111111)
2
, luego si se compara con
AND bit por bit, (00001111)AND(11111111), el
resultado es (00001111)15
r = r | m;

r =47 inicialmente r = 15 (001111)
2
y
m=32(100000)
2
, entonces,
(001111)
2
OR(100000)
2
resulta
(101111)
2
(47)
10

r = a & ~07; r = 248 Porque inicialmente a=(255) (011111111)
2
y
07 (000000111)
2
, entonces , ~07
(111111000)
2
, (011111111) AND
(111111000), resulta (011111000)(248)
10

r = a >> 7;

r = 1 Como se ha dicho que a =
(255)
10
(011111111)
2
, entonces se desea
el desplazamiento de 7 bits a la derecha,
por lo tanto (001111111)(000111111) y as
hasta desplazar los 7 bits de la instruccin
hasta (000000001)(1)
10

r = m << 1; r = 64 equivale a r = m * 2
r = m >> 1; r = 16 equivale a r = m / 2
Fuente: Propia


o De asignacin. Almacena el valor en el operando de la
izquierda, aqu se incluyen los de incremento y decremento
porque implcitamente realizan una asignacin.
Incremento ( ++ )
Decremento ( -- )
Asignacin simple ( = )
Multiplicacin ms asignacin ( *= )
Divisin ms asignacin ( /= )
Modulo ms asignacin ( %= )
Suma ms asignacin ( += )
Resta ms asignacin ( -= )
Desplazamiento a izquierda ms asignacin ( <<= )
Desplazamiento a derecha ms asignacin ( >>= )
Desplazamiento a derecha ms asignacin rellenando
con ceros ( >>>)
Operacin AND sobre bits ms asignacin ( &= )
Operacin OR sobre bits ms asignacin ( |= )
Operacin XOR sobre bits ms asignacin ( ^= )
Los operandos tienen que ser de un tipo de dato
primitivo. en la Tabla 5.3. Se presentan algunos
ejemplos.

Tabla 5.3. Ejemplos de los operadores de asignacin (1/2)
Instruccin Descripcin
int x = 0, n = 10, i = 1; Asignacin
n ++; //incrementa el valor de n en 1
++ n; //incrementa el valor de n en 1.
x = ++ n; incrementa n en 1 y asigna el resultado a x
x = n ++; Asigna el valor de n a x y despus e
incrementa n en 1
Fuente: Propia


Tabla 5.2. Ejemplos de los operadores de asignacin (2/2)
i += 2; Realiza la operacin i = i + 2.
x *= n 3; Realiza la operacin x= x *(n - 3) y no x = x * n
3
n >>= 1; Realiza la operacin n = n >> 1, la cual
desplaza el contenido de n 1 bits a la derecha
Fuente: Propia

El operador ( ++ ) y ( -- ) si estn antes de la variable
es prefijo, es decir, se ejecuta primero el incremento o
decremento y luego las otras operaciones; mientras si
esta como sufijo, despus de la variable, entonces
primero se hacen las otras operaciones y luego se
ejecuta el incremento o decremento.
o Condicional ( ?: ), conocido tambin como operador ternario,
se usa cuando el valor que le asignar a una variable depende
de una condicin, de este tipo: (expresin booleana)? valorV :
valorF; la expresin booleana si es verdadera el resultado ser
valorV y si es falsa ser valorF. Ejemplo
double a = 10.2, b = 20.5, mayor = 0;
mayor = (a > b) ? a : b; //mayor tendr un valor de 20.5
Prioridad de operadores Se ordenan de mayor a menor prioridad, los
que estn en una sola misma lnea tienen la misma prioridad. Ver
Tabla 5.4.
Tabla 5.4. Prioridad y asociatividad de todos los operadores (1/2)
Operador Asociatividad
( ) [ ] . Izquierda a derecha
- ~ ! ++ -- Derecha a izquierda
new (tipo)expresin Derecha a izquierda
* / % Izquierda a derecha
+ - Izquierda a derecha
Fuente: Propia



Tabla 5.4. Prioridad y asociatividad de todos los operadores (2/2)
<< >> >>> Izquierda a derecha
< <= > >= instanceof Izquierda a derecha
== != Izquierda a derecha
& Izquierda a derecha
^ Izquierda a derecha
| Izquierda a derecha
&& Izquierda a derecha
|| Izquierda a derecha
?: Derecha a
izquierda
= *= /= %= += -= <<= >>= >>>= &= |= ^= Derecha a
izquierda
Fuente: Propia

Sentencias de control en el lenguaje Java: son usadas para
controlar la ejecucin de un programa segn ciertas condiciones. En el
lenguaje Java existen las siguientes: if-else, switch, for, while, do-
while.
o La sentencia if permite a un programa tomar una decisin para
ejecutar una accin u otra, basndose en el resultado de una
expresin, la sintaxis es la siguiente:
if (expresin booleana ) [{]
sentencia 1;
[sentencia 2:

sentencia n;
}]
[else{
sentencia a;
sentencia b;



sentencia m;
}]
donde, el valor de la expresin booleana puede ser
verdadero o falso, si es verdadero se ejecutan la/s
sentencia/s de la 1 a la n sin ejecutarse las del else;
sino, se ejecutan las del else (sino) de a hasta m
obviando las del if; en el caso de necesitar que se
ejecute slo una instruccin entonces no es necesario
las llaves del if, igual para el else. Es posible que no
exista else porque no hay instruccin/es que necesiten
ser ejecutadas si la/s expresin booleana es falsa. Las
sentencias pueden ser otros if con otra expresin
booleana, a esto se le conoce como if anidados.
o La sentencia switch, se utiliza para comparar el valor de una
variable con muchos casos, stos ltimos no tienen limites,
pueden ser muchos casos y segn el valor se ejecuten de una
a muchas acciones, su sintaxis:
switch (variable ){
case valor1 : sentencia1;
break;
case valor2 :
case valor3 : sentencia2;
break;
default : sentencia3;
}

donde, variable debe ser de un tipo de dato int, short,
char byte, y si esta variable es igual al valor1 entonces


se ejecutara todas las sentencias que estn desde los
dos puntos ( : ) hasta que se encuentre con la sentencia
break. Y as con todos los cases, en el caso de valor2 y
valor3 se ejecutar la sentencia2, porque en case valor2
no se encuentra el break para que rompa la secuencia,
el default se ejecuta en el caso que la variable no tenga
el mismo valor de ninguno de los cases el default no
necesariamente debe ir al final. El switch debe contener
nicamente los cases y el default que es opcional,
dentro de los case se puede tener cualquier sentencia
de Java.
o La sentencia for, permite ejecutar un ciclo de instrucciones
varias veces pero finita, segn una o mas variables de control,
esta conformado por tres (3) partes fundamentales; su sintaxis:
for(inicializacin(es);expresin_booleana;actualizacin)
[ { ]
sentencia 1;
[ sentencia n; ]
[ } ]

donde, la inicializacin(es) es para asignarle valores
iniciales a la(s) variable(s) necesaria(s) e involucrada(s)
en el ciclo; la expresin booleana es para establecer
la(s) condicin(es) que va hacer que las sentencias se
vuelvan a ejecutar, porque mientras esa expresin
booleana sea verdadera el for se sigue ejecutando una y
otra vez; y la parte de la actualizacin es para que
ocurra un incremento o decremento en la(s) variable(s)


involucrada(s) en la(s) expresin booleana garantizando
as que sta va a tomar el valor de falsa, para que el
ciclo deje de ejecutarse. En el caso de no necesitar una
de las partes entonces se deja en blanco pero se coloca
su punto y coma ( ; ) correspondiente, recordando que
es importante que manejen dentro del for las tareas
correspondientes, si se debe ejecutar una sola
sentencia no hace falta las llaves.
La ejecucin de esta sentencia: se inicializa, luego
se evala la expresin booleana si es verdadera se
ejecutan las sentencias, luego se actualiza(n) la(s)
variable(s) y se vuelve a evaluar y as sucesivamente
hasta que se haga falsa, cuando esto sucede se pasa a
ejecutar la siguiente instruccin fuera del for.
o La sentencia while, ejecuta una o varias sentencias, mientras
una expresin booleana sea verdaera, su sintaxis:

while ( expresin booleana ) [ { ]
sentencia1;
[ sentencia2;
} ]
donde, la(s) sentencia (s) se va(n) a ejecutar mientras la
expresin booleana sea verdadera, si el while consta de
slo una sentencia entonces no es necesario las llaves,
para este ciclo es muy importante el control de las
variables involucradas en la expresin booleana para
que no se haga el ciclo infinito. Si la primera vez la
expresin es falsa no se ejecutar(n) la(s) sentencia(s)


o La sentencia do-while, permite ejecutar una serie de
sentencias al menos una vez, hasta que una expresin
booleana sea falsa, su sintaxis:
do{
sentencia1;

}while(expresin booleana);

donde, la sentencia1 se ejecuta al menos una vez sin
importar la evaluacin de la expresin booleana, luego
se evalua dicha expresin, si es verdadera se continua
ejecutndose la sentencia1, hasta que se haga falsa.
Fjese que este ciclo termina con punto y coma (;).

5.2.2.2.2 Clases y Objetos

Variables: Como se ha definido en la unidad anterior, es (son) una(s)
posicin(es) de memoria con un nombre nico asignado que puede
almacenar un dato a la vez, de un tipo especifico, stas tambin
tienen un ciclo de vida determinado por el mbito donde estn
declaradas, es recomendable asignarle un valor inicial a cada variable;
existen varios tipos de variables:
o Variables locales: se definen y se manipulan dentro de un
mbito especfico, al salir de dicho mbito las variables
declaradas quedan liberadas, es decir, dejan de existir.
Variables de instancia: son aquellos atributos de una
clase para describir a un objeto, cada uno de stos tiene
sus propios valores en sus respectivas caractersticas,


independientes de los dems objetos, por ejemplo cada
persona tiene su color de ojos, o su color preferido, etc.
Variables de clase: estas son declaradas tambin
dentro de la clase, pero almacena un valor para todos y
cada uno de los objetos que se declaren de la clase, y
para usarlas no es necesario crear un objeto, con el
nombre de la clase es suficiente, son generales para
todos los objetos de la clase, los objetos se refieren a los
mismos datos. En el lenguaje Java para definirlas se usa
la palabra reservada static

Para la declaracin de una variable de instancia o clase es de la
siguiente forma, tomando en cuenta que lo que este dentro de los
corchetes es opcional:

[tipo-acceso] [static] tipo-de-dato identificador-variable [,identificador-
variable2,];

Mtodos: Como ya se ha mencionado en la unidad anterior, son
operaciones que se le pueden realizar a objetos, se describen en la
clase y son invocados la mayora de las veces por objetos
pertenecientes a dicha clase. Existen dos tipos de mtodos:
o Mtodos de instancia: son aquellos que slo pueden ser
aplicados a una instancia, es decir, pueden ser invocado o
usados slo por objetos; porque son operaciones dirigidas a los
objetos.
o Mtodos de clase: son aquellos que pueden ser usados sin
necesidad de instanciar la clase, o sin crear un objeto de dicha
clase, puede ser invocado con el nombre de la clase, y tambin


por un objeto; stos no pueden hacer uso de las variables de
instancias porque no estn dirigidos a los objetos, por lo tanto
no puede usar atributos que le pertenecen a stos. Para
definirlos de clase en Java se usa la palabra reservada static.
Parmetros: son valores externos necesarios para llevar a cabo
las operaciones de un mtodo, stos son recibidos en pareja,
conformadas por el tipo de dato e identificador del parmetro; las parejas
se separan con coma simple ( , ). Cuando se invoca un mtodo se debe
enviar el listado de parmetros que ste espera, el primer valor que se
enva corresponde al primer parmetro del mtodo, el segundo valor al
segundo parmetro, y as sucesivamente con todos. Los parmetros son
variables locales.
El paso de parmetros puede ser:
o Por valor: Si en el cuerpo del mtodo se modifica el valor del
parmetro que recibe y esta accin no cambia el valor del
parmetro con que se llama a ejecutar el mtodo, es decir, que
los parmetros enviados son una copia de los originales, por lo
que cualquier modificacin que se haga a estas variables
dentro del mtodo no afecta a la variable original. Cuando el
tipo de datos de los parmetros es primitivo, siempre el paso de
los mismos es por valor.
o Por referencia: cuando los parmetros recibidos son
referencias, es decir, espacios de memoria; cualquier
modificacin que se le haga en el mtodo se vera reflejada en
la variable original. Cuando los parmetros son objetos, o
arreglos siempre el paso de parmetros es por referencia.



Sobrecarga de Mtodos: existe cuando en una clase hay ms de un
mtodo con igual nombre, y poseen diferencias asociados a los
parmetros. Cantidad y/o tipos, por ejemplo: Supngase dos (2)
Mtodos llamados sumar
o sumar ( int , int ) y sumar( int ) en este caso los parmetros
actuales difieren en cantidad.
o sumar ( float ) y sumar ( int ) en este caso los parmetros
actuales difieren con respecto al tipo.
o sumar ( float , double ) y sumar ( int ) en este caso los
parmetros actuales difieren con respecto a la cantidad y al
tipo.

El compilador es el encargado de ejecutar el mtodo correspondiente.

Constructores: Es un mtodo que se ejecutan automticamente
cuando se crea un objeto de una clase. Sirve para inicializar los
miembros de la clase.
El constructor tiene el mismo nombre de la clase. Cuando se define no
se puede especificar un valor de retorno, nunca devuelve un valor. Sin
embargo, puede tomar cualquier nmero de argumentos.
o Constructor por defecto: es el que no tiene parmetros,
normalmente inicializa todos los atributos de la clase con
valores por defecto.
o Constructores sobrecargados: Al igual que se puede
sobrecargar un mtodo de una clase, tambin se puede
sobrecargar el constructor de una clase. De hecho los
constructores sobrecargados sdon bastantes frecuentes y
proporcionan diferentes alternativas para inicializar objetos.


Modificadores o tipos de acceso: es el tipo que define el acceso de
las clases as como variables y mtodos. En el lenguaje Java existen
cuatro (4) tipos:
o public: aquellos elementos que tienen este tipo pueden ser
accedidos desde cualquier clase, por medio de un objeto, o la
clase. Este es usado para la mayora de los mtodos.
o protected: Estn disponibles para la clase donde estn
declarados, otras clases del mismo paquete, y las subclases
(que son aquellas que heredan de sta, este tema se tratar en
la unidad 4).
o private: slo es accesible desde la clase que es miembro. Este
es usado en la mayora de los atributos, para proteger sus
valores y as respetar el principio de ocultamiento.
o Por defecto: si no se usa un especificador, entonces, el
miembro de la clase es visible a la clase de la que es miembro,
a las clases derivadas de la misma, que estn en su mismo
paquete y a otras clases del mismo paquete
Paquete: Es una coleccin de clases, lgicamente relacionadas entre
s, agrupadas bajo un nombre; incluso un paquete puede contener
otro(s) paquete(s). Para usar un paquete en Java se debe hacer la
importacin de la siguiente forma: (a) import identificador-del-paquete
seguido de un punto, seguido del nombre-de-la-clase-a-usarse, (b)
import identificador-del-paquete . *;

(a) import java . io . BufferedReader ;
(b) import java . io . * ;



este ltimo es para importar mas de una (1) clase del mismo paquete.
Tambin se puede crear un paquete con la palabra reservada package
seguido del identificador-del-paquete y por ultimo un punto y coma ( ; ), y as
tambin se incluyen nuevas clases a un paquete. Ejemplo:
package mi_paquete;
class Clase_de_mi_paquete {}
Declaracin y creacin de un objeto: despus de realizada una
clase, se puede instanciar, o declarar y crear un objeto de ese nuevo
tipo de dato, para declararlo se hace similar que para una variable:
tipo de dato en este caso el nombre de la clase seguido del nombre
del objeto o identificador y luego un punto y coma (; ).
Observe:
identificador_de_la _clase identificador_del_objeto1;

mientras que para crearlo se debe hacer un llamado al constructor de la
clase que tiene el mismo nombre de sta, con el operador new que reserva
el espacio necesario en memoria para el nuevo objeto e inicializa los
atributos.
Observe:
identificador_del_objeto1 = new Identificador_de_la _clase ( );

Es importante destacar que para usar un objeto debe estar previamente
declarado y creado, porque sino lo esta, entonces no existe. Esto se debe a
que cuando se declara el objeto no se ha asignado la referencia en memoria
del mismo; observe la Figura 5.2 (a) se define una clase ClaseA con dos
atributos x, y; (b) Donde, para la sentencia ClaseA objeto1; slo se declara,
pero no se le asigna un espacio en memoria (c), el objeto1 referencia a null,
es decir, no tiene memoria asignada; luego en la Figura 5.3, se ilustra la


creacin del objeto en la (a), en la parte (b) se observa la referencia a
memoria del objeto1, y en la (c) esta en la memoria las posiciones
reservadas para todos los atributos del objeto1.

Los objetos no se almacenan en posiciones secuenciales de la
memoria, aunque los atributos de un objeto si lo hacen.









Figura 5.2. Declaracin de un objeto y su representacin en memoria
Fuente: Propia










Figura 5.3. Creacin de un objeto y su representacin en memoria
Fuente: Propia

25896F0
x
25896F1
25896F2
y
25896F03

(c) en memoria
objeto1;
Referencia = null
(a) Declaracin de
la clase ClaseA
Clase A{
char x;
byte y;}
(b) sentencia
de
declaracin del
objeto1
Clase A objeto1;
(b) en memoria
objeto1;

(a) sentencia de creacin
objeto1 = new ClaseA();


Automvil
Motor
Figura 5.4 Ejemplo de Composicin

Para aplicar la abstraccin y encapsulamiento de datos, se
debe desarrollar una clase, donde se haga la abstraccin de los
detalles que se necesitan para describir un objeto, con las
operaciones que describan el comportamiento de ste.
Composicin: una clase puede tener entre sus atributos un objeto de
otra clase; entonces los objetos de la primera clase esta compuesto
por objetos de la segunda clase; como se puede observar la
composicin es una relacin entre clases; por ejemplo: El cuerpo
humano que esta compuesto por los rganos, msculos, sistema
seo; si el cuerpo humano es el objeto a abstraer, entonces sus
caractersticas o atributos son objetos de otras clases. Otro ejemplo
puede ser un automvil, que esta conformado por el motor, sistema de
freno, sistema de amortiguacin, entre otros; para describir el
automvil se necesitan declarar antes las clases que describan un
motor, otra para describir el sistema de freno, y otra para el sistema de
amortiguacin, y as una clase para cada uno de los componentes
complejos que lo conforman, y al final es que se va a declarar la clase
automvil. Como se puede observar en las Figuras 5.4 y 5.5






Fuente: Propia



Fuente: Propia


La composicin es descrita por la relacin tiene un, fjese
que un automvil tiene un motor; el automvil tiene un sistemas
de frenos; el cuerpo humano tiene un sistema seo.

5.2.3 Ejemplos de programas resueltos donde se aprecie la
abstraccin y encapsulacin de datos de la programacin
orientada a objetos.

Como ya se ha mencionado el lenguaje a utilizar en los ejemplos ser el
lenguaje Java.

Observe la Figura 5.6, fjese que hay cinco (5) crculos, las diferencias
entre ellos es el color y el dimetro, es decir, si se quiere describir un circulo
con una clase, los atributos de la misma sern dimetro y color.


Figura 5.5 Ejemplo de Composicin




Figura 5.6. Representacin de crculos
Fuente: Propia

Entonces, los atributos de la clase Circulo en la Figura 5.7:


Clase Circulo
Color
Dimetro

Figura 5.7. Atributos de la clase Circulo.
Fuente: Propia

Ahora bien, que operaciones se le pueden hacer a un crculo? Se
puede cambiar su color, cambiar su dimetro. En Figura 5.8.(a) se puede
apreciar el paso de mensajes a dos de los crculos y en la Figura 5.8.(b) se
puede ver despus de ejecutada la primera figura.




Figura 5.8.(a) Operaciones a los crculos.
Fuente: Propia






Figura 5.8.(b) Resultado de la operaciones a los circulos
Fuente: Propia

Entonces los mtodos de la clase circulo son: cambiarColor (
nuevocolor ) y cambiardiametro ( nuevodiametro ), observe la Figura 5.9

Clase Circulo
color cadena
diametro numero real
Circulo ( numero real , cadena )
cambiarColor ( cadena ) no retorna valor
cambiarDiametro ( numero real ) no retorna valor
Figura 5.9. Atributos de la clase Circulo
Fuente: Propia




Ahora se codifica la clase circulo, partiendo de la Figura 5.9. Observe la
Figura 5.10.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Circulo {
private String color ;
private float diametro ;
Circulo ( String color , float b ) {
this . color = color ;
diametro = b ;
}
public void cambiarColor ( String nuevo ) {
color = nuevo ;
}
public void cambiarDiametro ( float nuevo ) {
dimetro = nuevo ;
}
} //fin de la clase Circulo
Figura 5.10. Cdigo fuente de la clase Circulo en lenguaje Java
Fuente: Propia

De la Figura 5.10. Donde se ilustra el cdigo fuente de la clase Circulo,
se puede ver que la lnea 1 corresponde a la declaracin de la clase, luego
en las lneas 2 y 3 se definen los atributos de la clase, estos pueden ser
definidos al principio como se observa en ste ejemplo, o al final, lo
importante es que estn dentro de la clase y fuera de los mtodos de la
misma.
En las lneas de la 4 a la 7, est el constructor de la clase, que recibe
los valores iniciales para los atributos.
En las lneas 8 y 11 se encuentran los mtodos descritos anteriormente,
cambiarColor que recibe un objeto String que trae el nuevo color, y en la


lnea 11 esta el mtodo cambiarDiametro que recibe el nuevo valor en un
float. Y as finaliza nuestra clase Circulo
Ahora se quiere que en la clase Circulo, se lleve el control de cuantos
crculos se han creado, la solucin a este problema es una variable de clase,
se declara como atributo y se incrementa en el constructor. Ver Figura 5.11.
(Lnea 4 y 8)
Si el problema fuera que los crculos por defecto se crearn ce dimetro
4 y color blancos, entonces se necesita otro constructor que no reciba
parmetros y asigne los valores por defecto, ver Figura 5.11 lneas de la 10 a
la 14.
Fjese que en la Figura 5.11, se aade una variable de clase llamada
cantidad (lnea 4), que se incrementa en el constructor(lneas 8 y 12), esto es
para que cada vez que se cree un nuevo objeto la variable cantidad la
cuente; y se aade un mtodo getCantidad para poder visualizar su valor
fuera de la clase(lnea 17). Tambin es esta figura se puede apreciar la
sobrecarga del constructor (lneas 5 y 10).
Ahora se presenta otro ejemplo referente a fracciones o nmeros
racionales, donde las caractersticas de stos, son dos valores enteros que
representan el numerador y el denominador; a continuacin analizaremos los
objetos asociados a las operaciones aritmticas que se llevan a cabo con las
fracciones. Ver Figura 5.12.

Como se puede observar en la Figura 5.12, cada fraccin tiene un
numerador, y un denominador, estas serian las caractersticas (atributos) y
entre las fracciones se pueden realizar operaciones aritmticas, como se
observa en la figura que la fraccin a se suma con la fraccin b, y la fraccin
b se multiplica con la c; tambin se ilustra como un usuario puede interactuar
con las fracciones, fijndole el numerador o denominador. En la Figura 5.12
se representan los objetos y el paso de mensajes entre ellos.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Circulo {
private String color ;
private float diametro ;
private static int cantidad = 0 ;
Circulo ( String color , float b ) {
this . color = color ;
diametro = b ;
cantidad = cantidad + 1 ; } // fin del constructor
Circulo ( ) {
color = blanco ;
diametro = 4.0f ;
cantidad = cantidad + 1 ; } // fin del constructor
public void cambiarColor ( String nuevo ) {
color = nuevo ; } // fin del mtodo
public void cambiarDiametro ( float nuevo ) {
dimetro = nuevo ; } // fin del mtodo
public int getCantidad ( ) {
return cantidad ; } } //fin de la clase Circulo
Figura 5.11. Cdigo fuente de la clase Circulo con una variable de clase
Fuente: Propia








Figura 5.12. Representacin de Fracciones o nmeros racionales
Fuente: Propia

4/5
2/3
1/9
sumar
multiplica
setNumerador
setDenominador
Usuario


matematica
s
matematicas
Partiendo de la Figura 5.12. se identifican los atributos de la clase
Fraccion, Figura 5.13. y observese que sta clase debe estar dentro de un
paquete con el nombre de matematicas.

El comportamiento de las fracciones puede ser, sumar dos (2)
fracciones, restar, multiplicar, dividir, simplificar, ejecutar la divisin. Ver
Figura 5.14.


Clase Fraccion
numerador
denominador



Figura 5.13 Atributos de la clase Fraccion, dentro del paquete matematicas
Fuente: Propia












Figura 5.14 Atributos y mtodos de la clase Fraccion
Fuente: Propia
Clase Fraccion
num entero
den entero
Constructor Fraccion()
sumar(Fraccin, Fraccion) no retorna valor
restar(Fraccion) no retorna valor
multiplicar(Fraccion) no retorna valor
dividir(fraccion, Fraccion) Fraccion
simplificar ( ) no retorna valor
resultado ( ) real



Codificando la clase Fraccion,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
23
24
25
26
27
28
29
30
31
32
33
34
35
package matematicas ;
class Fraccion {
private int num , den ;
Fraccion ( int a , int b ) {
this . num = a ;
den = b ;
}
public void sumar ( Fraccion f1 , Fraccion f2 ) {
num = f1 . num * f2 . den + f1 . den * f2 . num;
den = f1 . den * f2 . den ;
}
public void restar ( Fraccion f ) {
num = num * f . den - den * f . num ;
den = den * f . den ;
}
public void multiplicar ( Fraccion f ) {
num = num * f . num ;
den = den * f . den ;
}
public static Fraccion dividir ( Fraccion f1, Fraccion f2 ) {
Fraccion f = new Fraccion ( 1 , 1 ) ;
f.num = f1 . num * f2 . den ;
f . den = f1 . den * f2 . num ;
return f ;
}
public void simplificar ( ) {
int n = 0 , menor = 0 ;
if ( num > den ) {
if ( num % den == 0 ) {
num = num / den ;
den = 1 ;
}
else
menor = den;
Figura 5.15. Cdigo fuente de la clase Fraccion en lenguaje Java (1/2)
Fuente: Propia



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
}
else
menor = num ;
if ( menor != 0 )
for ( n = 2 ; n < menor ; n ++ )
if(num % n == 0 && den % n == 0){
num = num % n ;
den = den % n;
}
}
public float resultado ( ) {
float r = ( float ) num / den ;
return r ;
}
public int getDenominador(){
return den;
}
public int getNumerador(){
return num;
}
}//fin de la clase Fraccion
Figura 5.15. Cdigo fuente de la clase Fraccion en lenguaje Java (2/2)
Fuente: Propia

A continuacin se explicara detalladamente el cdigo de la Figura 5.15.

En la lnea 1 se define que esta clase estar en el paquete con el
nombre de matematicas.
En la lnea 2 se declara la clase con la palabra reservada class seguido
del nombre con el cual se definir la clase.
En la lnea 3 se declaran los atributos de la clase, num y den, como
private para definir el tipo de acceso que tendrn como privados solo se
podrn usar dentro de sta clase, y con int se especifica que van almacenar
valores numricos enteros.



En las lneas 4 a 7, se define el constructor de la clase que es el
mtodo encargado de inicializar los atributos, se tiene que llamar igual que la
clase, no necesita ni tipo de acceso ni tipo de dato del valor retornado; para
este caso recibe dos (2) enteros para asignrselos a los dos (2) atributos de
la clase. Es importante destacar que existen casos en los cuales no todos los
atributos deben inicializarse con valores enviados desde fuera de la clase.
Un ejemplo seria si sta clase tuviera un atributo para el resultado de la
fraccin, ste valor no se debera recibir. Porque dependera de los valores
de num y den, es decir, se puede calcular con valores que son conocidos en
la clase. La palabra reservada this es para hacer referencia a un atributo o
mtodo perteneciente a la clase; en ste caso particular no es necesario pero
si la variable local a se llamara num igual que el atributo entonces si fuera
absolutamente necesario la referencia this, para diferenciar el atributo de la
variable local que se esta recibiendo como parmetro.

En las lneas de la 8 a 11, se encuentra el mtodo llamado sumar, que
no retorna ningn valor ya que es de tipo void, y recibe dos (2) parmetros
que son objetos de tipo Fraccion, donde se lleva a cabo la suma de dos (2)
fracciones y se almacena en los atributos pertenecientes a el objeto que
invoco ste mtodo.
En las lneas de la 13 a 15 se puede observar el mtodo restar que
no retorna ningn valor, y recibe solo un parmetro que es un objeto de tipo
Fraccion, donde el minuendo es el objeto Fraccion que invoca ste mtodo y
el sustraendo es el objeto f que se est recibiendo como parmetro, y la
resta se almacena en los atributos del objeto que invoca al mtodo.
En las lneas de 16 a 19, se puede observar el mtodo multiplicar,
muy parecido al anterior el mtodo restar.



En las lneas de la 20 a 25, se encuentra el mtodo dividir, que retorna
un objeto tipo Fraccion, y recibe dos (2) parmetros que son objetos de tipo
Fraccion f1 y f2; tambin ste mtodo es de clase, porque as lo indica la
palabra reservada static, en la lnea 21 se declara y crea un nuevo objeto
Fraccion f para almacenar en ste el resultado de la multiplicacin de los
objetos f1 y f2, y as retornar el objeto f que es una variable local
existente solo en ste mtodo.

En las lneas de la 26 a 44, se halla el mtodo simplicar, que no
retorna ningn valor por esta razn es de tipo void y tampoco recibe ningn
parmetro porque este mtodo va a simplificar el objeto Fraccion que lo
invoque, se declaran dos (2) variables de tipo int n y menor luego se
verifica si se puede llevar a cabo la divisin, sino se guarda en la variable
menor el valor ms pequeo entre el numerador y denominador para luego
proceder a partir de la lnea 39 a buscar un nmero que divida tanto al
numerador como al denominador, para simplicar de esta forma el objeto
Fraccion que invoc al mtodo.

En las lneas de la 45 a 48 se encuentra el mtodo resultado, que
debe retornar un valor coma flotante que representar el resultado de la
divisin del objeto Fraccion que lo invoque, no recibe ningn valor porque los
que necesita son el numerador y denominador, que ya los maneja como num
y den, luego se declara una variable local con el nombre r para almacenar
en sta dicho resultado, fjese que la palabra float entre parntesis es para
hacer una conversin explicita del resultado de la divisin dos nmeros
enteros a un numero en coma flotante, para luego retornarlo.



matematica
s
Y por ltimo se encuentran los mtodos getDenominador y
getNumerador (lneas 49 y 52), para que desde otra clase se puedan
obtener los valores de los atributos.

Para ejemplificar la composicin, se podra describir un nmero
complejo, que tienen una parte real y otra imaginaria, hasta aqu no existira
la composicin, aunque si las partes se representarn con fracciones si.
Ejemplo ( a / b ) + ( c / d ) i; para describir ste numero tanto la parte real
como la imaginaria debe ser objetos de tipo Fraccion.

A estos nmeros complejos se le pueden aplicar operaciones como
suma de dos (2) nmeros complejos, o su resta, entre otras; para ste
ejemplo solo se considerarn estas dos (2) operaciones.



Clase NComplejo
pReal
pImag


Figura 5.16 Atributos de la clase NComplejo, dentro del paquete matematicas
Fuente: Propia

Codificando la representacin de la clase de la Figura 5.17, y
considerando la Figura 5.15, observe el siguiente cdigo.





matematicas

Clase NComplejo
pReal Fraccion
pImag Fraccion
Constructor NComplejo()
sumar(NComplejo,NComplejo) no retorna valor
sumar(NComplejo) no retorna valor
Restar(NComplejo,NComplejo) no retorna valor

Figura 5.17 Atributos y mtodos de la clase NComplejo
Fuente: Propia

Ahora se explicaran las lneas de cdigo de la Figura 5.18
En la lnea 1 se declara que esta clase pertenece al paquete llamado
matematicas, porque ah est la clase fraccion y de esta forma se puede
tener acceso a ella.

En la lnea 2 se declara la clase con el nombre de NComplejo, luego en
la lnea 3 se declaran los atributos de la clase pReal y pImag, que son
objetos de tipo Fraccion, aqu esta presente la composicin, puesto que un
objeto NComplejo est conformado por objetos de otra clase.

En las lneas de la 4 a 15, se encuentran el constructor de la clase que
esta sobrecargado, existen tres (3), que se diferencian por la lista de
parmetros que recibe cada uno, y ello es lo que determinar cual se ejecuta
en su debido momento, si un objeto se crea del tipo NComplejo y se le
envan dos (2) objetos de tipo Fraccion se ejecutar el primer constructor,
mientras si no se enva ningn parmetro se ejecutar el segundo, y cuando


se enven cuatro (4) valores de tipo int, entonces se ejecutar el ultimo pero
no menos importante.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package matematicas;
class NComplejo {
Fraccion pReal, pImag;
NComplejo ( Fraccion a , Fraccion b ) {
pReal = a;
pImag = b;
}
NComplejo ( ) {
pReal = new Fraccion ( 1 , 1 ) ;
pImag = new Fraccion ( 1 , 1 ) ;
}
NComplejo ( int a , int b , int c , int d ) {
pReal = new Fraccion ( a , b ) ;
pImag = new Fraccion ( c , d ) ;
}
public void sumar ( NComplejo n1 , NComplejo n2 ) {
pReal . sumar ( n1 . pReal , n2 . pReal ) ;
pImag . sumar ( n1 . pImag , n2 . pImag ) ;
}
public void sumar ( NComplejo n ) {
pReal . sumar ( pReal , n . pReal ) ;
pImag . sumar ( pImag , n . pImag ) ; } //fin del mtodo
public void restar ( NComplejo n ) {
pReal . restar ( n . pReal ) ;
pImag . restar ( n . pImag ) ;
}
}
Figura 5.18 Cdigo fuente de la Clase NComplejo
Fuente: Propia

En las lneas de 16 a 19, est el mtodo sumar que recibe dos (2)
objetos de tipo NComplejo n1 y n2, donde se usa el atributo pReal que
es de tipo Fraccion, y con ste se llama al mtodo sumar de dicha clase,
mandndole las dos (2) objetos de tipo Fraccion que ese mtodo espera, que


son la parte Real del objeto n1 y la del objeto n2; igualmente para la la
parte Imaginaria.

En las lneas de la 20 a 22, se puede observar el mtodo sumar pero
ste se diferencia del anterior porque recibe slo un objeto NComplejo, para
que lo sume con el NComplejo que invoca al mtodo, de esta manera con los
atributos del objeto solicitante de la ejecucin de ste mtodo sumar, se
invoca el mtodo sumar de la clase Fraccion envindole la pReal del
objeto que invoca y la pReal del objeto que recibe n, igualmente para la
pImag.

En las lneas 23 a 26, se encuentra el mtodo restar recibiendo slo
un objeto NComplejo llamado n; con el atributo pReal del objeto que
invoca ste mtodo se llama el mtodo restar de la clase Fraccion
envindole la pReal del objeto n, de igual forma se hace para la pImag;
culminando as la clase NComplejo.

5.2.4 Resolucin de problemas usando programacin orientada a
objetos, haciendo nfasis en la abstraccin y encapsulacin de
datos.

Cree las clases necesarias para describir un consultorio medico, para
dos (2) pacientes por da, donde se maneje la siguiente informacin
por cada uno: nombre, numero de historia, edad, da y hora de la cita,
y la cantidad de consultas que ha tenido con el doctor; El consultorio
debe tener el nombre del doctor.

. Deber desarrollar las siguientes operaciones:


o Citar un paciente, se debe evitar choque de horario.
o Mostrar a los 2 pacientes ordenados segn el nmero de visitas que
le ha hecho al doctor (descendente).




CAPTULO VI: ARREGLOS DE OBJETOS
UNIDIMENSIONALES

6.1 Objetivos
Definir los conceptos bsicos de arreglos, segn una discusin en
clases.
Identificar los tipos de problemas que se pueden resolver
mediante el uso de arreglos, usando programacin orientada a
objetos.
Resolver problemas haciendo uso de arreglos unidimensionales
para desarrollar programas orientados a objetos

6.2 Contenido:
Definicin de Arreglos. Declaracin y creacin de arreglos. Tipos
de Arreglos segn sus dimensiones.
Aplicacin de arreglos en la programacin orientada a objetos
Resolucin de problemas con programacin orientada a objetos

6.2.1 Definicin de Arreglos. Declaracin y creacin de arreglos. Tipos
de Arreglos segn sus dimensiones.

6.2.1.1 Definicin de Arreglos

Ya se estudio el ejemplo de la clase Fraccion, y la clase NComplejo,
pero que pasara si se necesitara manejar muchas Fracciones, o muchos
nmeros complejos donde sus partes fueran fracciones? Se podran declarar
muchos objetos del tipo necesario, aunque no sera optimo, ya que se haran


lneas de cdigo para cada objeto, tanto para declararlos y crearlos, como
para manejarlos, y si se necesitaran menos objetos o mas, se tendra que
modificar todo, aadiendo o borrando los objetos necesarios y sus lneas de
cdigo; para resolver ste problema se usar un arreglo del tipo necesario,
bien sea Fraccion, NComplejo, o de cualquier clase creada previamente;
entonces observe las definiciones siguientes:

Arreglo: segn Javier Ceballos, es una estructura homognea,
compuesta por varios elementos, todos del mismo tipo y almacenados
consecutivamente en memoria. Cada elemento puede ser accedido
directamente por el nombre de la variable matriz seguido de uno y ms
subndices encerrados entre corchetes ( [ ] ). Ver Figura 6.1

Arreglo


Figura 6.1. Representacin grfica de un Arreglo
Fuente propia

Para referirse a una posicin determinada de un arreglo es necesario
usar un subndice, estos dependiendo del lenguaje a usar comenzarn en
uno (1) cero (0), en el lenguaje java al igual que en C++ se comienzan en
cero (0); como se puede observar en la Figura 6.2

A
A
[0]
A
[1]
A
[2]
A
[3]
A
[4]
A
[5]
Figura 6.2. Representacin de un Arreglo A de seis (6) posiciones
Fuente propia



Suponga que el arreglo A es de tipo int entonces en cada una de las
seis (6) posiciones almacenar un int, vase la Figura 6.3; estas posiciones
se almacenan consecutivamente en memoria, suponiendo que el arreglo A
se comenzara a almacenar en la posicin 2570, y recordando que los datos
tipo int necesitan 4 bytes de memoria para almacenarse.


Posiciones de
memoria:
2
570
2
574
2
578
2
57C
2
580
2
584
A
5
2
8
1
59
5
7
9
9
2
010
Figura 6.3. Representacin de un Arreglo A de tipo int de seis (6) posiciones
Fuente propia

Y as cada una de las posiciones del arreglo va almacenar un valor de
tipo del arreglo; el tipo de dato de las posiciones es determinado por el tipo
con el cual se declara el arreglo,


6.2.1.2 Declaracin y creacin de arreglos

Para declarar un arreglo se debe colocar el tipo de dato, seguido por el
nombre del arreglo, acompaado por un par de corchetes, bien sea en el tipo
de dato en el nombre del arreglo.

Ejemplo:
int A [ ]
int [ ] a.



mientras que para crearlo se le debe definir el tamao usando el operador de
asignacin ( = ) seguido de la operador new (que permite reservar un espacio
de memoria para el nuevo arreglo) y luego el tipo de dato nuevamente y
entre corchetes el tamao o dimensin del arreglo que debe ser un valor
entero y terminar la sentencia con un punto y coma ( ; ).

Ejemplo:
A=new int [ 7 ];

Antes de la creacin de cualquier arreglo es imposible usarlo; tambin
se puede declarar y crear en una misma lnea, observe:

double b [ ] = new double[10];

Tambin se pueden inicializar con los valores que almacenar el
arreglo, asignndoselos entre comillas y separados por coma ( , ), de la
siguiente forma:

char x [ ] = {a,e,i,o};

entonces el arreglo x de tipo char, tendr x [ 0 ] el valor de a, x [ 1 ] el de e,
x [ 2 ] el de i y x [ 3 ] el valor de o.

6.2.1.3 Tipos de Arreglos segn sus dimensiones

Los arreglos no solo se pueden representar de una dimensin, llamados
unidimensionales, pueden ser de dos (2) llamados arreglos bidimensionales,
o de ms llamados matrices, deben manejar dos subndices; y se le definen


la cantidad de filas y las de columnas, como se puede observar en la Figura
6.4
long d [ ] [ ] = new long [ 4 ] [ 3 ];






Figura 6.4 Representacin de un arreglo d bidimensional de 4x3
Fuente propia

Tambin pueden ser de tres dimensiones, la declaracin sera de la
siguiente forma:

tipo_de_dato [ ] [ ] [ ] nombre_del_arreglo = new
tipo_de_dato[filas][columnas][profundidad];










Figura 6.5 Representacin de un arreglo de 3 dimensiones (4x3x3)
Fuente propia
0 1 2
0 d[0][0] d[0][1] d[0][2]
1 d[1][0] d[1][1] d[1][2]
2 d[2][0] d[2][1] d[2][2]
3 d[3][0] d[3][1] d[3][2]
Filas
Columnas
Profundidad


Para declarar y crear el arreglo de la Figura 4.5, supngase que es de
tipo boolean, y se llamara arreglo1, entonces: boolean arreglo1 [ ] [ ] [ ] =
new boolean [ 4 ] [ 3 ] [ 3 ]; En esta asignatura se estudian slo los arreglos
de una dimensin.
Para recorrer un arreglo usualmente se usa la sentencia cclica for para
ir desde una posicin a hasta una posicin b, un for por dimensin.

Ejemplo
Partiendo de la Figura 6.3. Supngase que se desea sumar todos los
valores del arreglo A.


for ( int i = 0, suma = 0; i < 6 ; i ++) // A = {5,28,159,57,99,2010}
suma += A[i];

despus, de que se ejecute todo el for, hasta que la variable i obtenga el
valor de 6, entonces la variable suma va a quedar con el valor de 2358.

Java considera los arreglos como objetos que adems de tener la
capacidad de almacenar varios elementos, dispone de un atributo length que
maneja el numero de elementos que puede almacenar. Usando ste atributo
las instrucciones anteriores queda de la siguiente forma:


for ( int i = 0, suma = 0; i < A . length ; i ++) // A = {5,28,159,57,99,2010}
suma += A[i];



6.2.1.4 Los arreglos como parmetros

Los arreglos pueden utilizarse como parmetros en los mtodos, en el
mtodo se recibe el tipo de dato del arreglo seguido del identificador del
arreglo o nombre, seguido de un par de corchetes vacios,

public void metodo1 ( tipo_dato identificador_arreglo [ ] ){}

Es necesario aclarar que los arreglos pasan por referencia, es decir que
toda modificacin que sufra el arreglo en el mtodo se va a reflejar en el
arreglo original. Bien ahora si se desea pasar un elemento del arreglo de un
tipo primitivo, este pasa por valor, es decir se saca una copia del valor y esa
es la que recibe el mtodo invocado; mientras si el arreglo es de objetos y
tambin se necesita enviar slo una posicin, este paso es por referencia,
dado que todos los objetos usan el paso de parmetros por referencia, por
ejemplo:
int arreglo [ ] = { 1 , 2 , 3 , 4 };
modificarArreglo ( arreglo ) ;
// luego, en el mtodo modificarArreglo
public void modificarArreglo( int a [ ] ){
int i ;
for ( i = 0 ; i < a . lenth ; i ++ )
a [ i ] = a [ i ] + 10 ;
}
//Despus de la ejecucin del mtodo, el valor de arreglo es {10 , 12 ,
13 , 14}



Ahora si al mtodo se enva slo una posicin, del mismo ejemplo
anterior:

modificarElemento ( arreglo [ 0 ] ) ;
//luego en el mtodo
public void modificarElemento ( int x ) {
x = x * 2 ;
}
//Despus de la ejecucin del mtodo modificarElemento, arreglo = {10 ,
12 , 13 , 14}
//como se ve, el arreglo original no fue modificado.

Los mtodos pueden retornar un arreglo, donde el tipo de dato
retornado ser el tipo de dato del arreglo con sus respectivos corchetes
indicando que se trata de un arreglo. Ejemplo

public int [ ] sumar ( int a [ ] , int b [ ] ){
int i, arreglo[ ] ;
arreglo=new int [ a.length ];
for ( i = 0; i < a.length ; i ++ )
arreglo [ i ] = a [ i ] + b [i ] ;
return arreglo;
}

Observe que el mtodo sumar, recibe dos arreglos de tipo int, para
sumar los datos almacenados en todas sus posiciones y almacenarlas en
arreglo arreglo declarado como variable local para luego retornarlo. En este
ejemplo a y b deben tener la misma longitud, y todas sus posiciones deben
tener un elemento, de no ser as ocurrir un error en tiempo de ejecucin,


para evitarlo, se puede pasar como parmetro o argumento la cantidad de
elementos contenidos en cada uno de los arreglos, o despus de la ultima
posicin ocupada colocar un identificador que represente el final del arreglo.

6.2.2 Aplicacin de arreglos en la programacin orientada a objetos

6.2.2.1 Clase String de Java

Java proporciona unas clases para describir cadenas; recordando que
una cadena es una secuencia de caracteres delimitada entre doble comillas,
java, Objetos y Abstraccin de datos, estos caracteres al igual que el tipo
de dato primitivo char, trabajan con el cdigo Unicode. Java de todas las
clases que tiene para el manejo de cadenas la ms usada es la clase String,
cualquier cadena es considerada un objeto de tipo String. Por ejemplo:

String universidad = UDO ;
String pre_requisito = POO ;
Un String es muy diferente de un arreglo de char,
String a = Hola mundo;
char b[ ]= { a , d , i , o , s } ;

si se quiere mostrar por pantalla el valor de las dos variables, el de la
cadena a se mostrar sin ningn problema, mientras que el segundo del
arreglo b se mostrar su equivalente a la direccin de memoria de la variable
b.

La clase String tiene sobrecarga de constructor, por lo tanto un objeto
de este tipo se puede crear de diferentes formas. Ejemplo:



String a = new String ( prueba #1 ) ; // recibe una cadena
String b = new String ( a ) ; //recibe una cadena
char c1[ ] = { p , r , u , e , b , a };
String c = new String ( c ) ; // recibe un arreglo de
caracteres.
Algunos mtodos de la clase String

Tabla 6.1. Mtodos de la clase String
Mtodo Cabecera del mtodo Descripcin
length int length() Devuelve la cantidad de caracteres
charAt char charAt(int posicion) Devuelve el carcter cuyo ndice es:
posicin
compareTo int compareTo(String cad2) Compara alfabticamente dos
cadenas, la que invoca y cad2 que la
recibe, Devuelve un entero (0 si son
iguales; < 0 si alfabticamente es
menor la que invoca que cad2; y > 0
si cad2 es mayor alfabticamente
que la que invoca).
Equals boolean equals(String cad2) Devuelve true si la cadena que invoca
es igual alfabticamente a cad2, toma
en consideracin las maysculas y
minsculas.
equalsIgnoreCase Bolean
equalIgnoreCase(String
cad2)
Parecido al anterior pero ignora
maysculas y minsculas.
Trim String trim() Devuelve la cadena que invoca sin
espacios en blanco.
Fuente propia



A pesar que en la clase String existe un mtodo llamado concat, que
recibe una cadena para concatenarla a la cadena que invoca, tambin existe
el operador ( + ) que concatena tantas cadenas como sea necesario. Ejemplo

String cad = Hola + + Mundo+ Java te da la Bien+ venida;
El resultado de cad ser: Hola MundoJava te da la Bienvenida

Suponga que es necesario almacenar una serie de nombres para
guardar a los estudiantes de una seccin de alguna asignatura, es necesario
declarar un arreglo de String, de la siguiente forma:

String nombres [ ] = new String [ 40 ] ;

Entonces cada una de las 40 posiciones va almacenar un String que
ser el nombre de uno de los estudiantes de la asignatura en consideracin,
ver Figura 6.6.

nombres
0 1 2 3 38 39
Pedro Mara Juan Luisa . Pablo Ana
Figura 6.6. Arreglo String de tamao 40
Fuente propia

Las posiciones del arreglo nombres de la Figura 4.6, son objetos de la
clase String por lo tanto, cada una se puede tratar como una cadena, usando
sus mtodos.



6.2.2.2 Arreglos de tipos de datos abstractos

Como se ilustro en el captulo 3, con las clases se puede crear tipos de
datos propios, no necesariamente de tipos predefinidos por el lenguaje, como
los primitivos, ahora bien, se pueden crear entonces arreglos de esos nuevos
tipos de datos; consideremos el siguiente problema.

Supngase que se necesite manejar n-simas fracciones, se debe tener
un arreglo de tipo Fraccion ( ver seccin3.2.3 del Captulo III) para manejar
varios objetos de este tipo, su declaracin:
Fraccion [ ] b;

Su creacin:

b = new Fraccion [ 6 ] ; // tamao arbitrario 6.

Su representacin grfica, ver Figura 4.7.(a) representacin en
memoria; Figura 4.7.(b) Representacin grfica.

Como se observa en la Figura 6.7 (a), los arreglos se almacenan
secuencialmente en memoria; cuando estos son de objetos, y despus de
creados se reserva el espacio en memoria segn los atributos de los objetos
que conforman dicho arreglo. De la figura como una Fraccion tiene dos
atributos enteros y por cada uno se necesita 4 bytes, entonces se reserva 8
bytes para cada posicin creada del arreglo b.

Para la utilizacin de los arreglos de objetos, se tiene que tener en
cuenta que se debe crear cada una de las posiciones (objetos) para luego


poder utilizarlos, hacer uso de sus atributos e invocar sus mtodos, en el
caso que no se cree una posicin y se trate de llamar un mtodo con ste,
producir un error en tiempo de ejecucin, porque el objeto en cuestin aun
no existe, no ha sido creado.






















Figura 6.7.(a) Representacin en memoria del arreglo b, despus de creadas todas las
posiciones
Fuente propia
En memoria
.. .
A0256
A0257
A0258
A0259
A025A
A025B
A025C
A025D
A025E
A025F
A0260
A0261
A0262
A0263
A0264
A0265
A0266
Arreglo b
0 Referencia
1 Referencia
2 Referencia
3 Referencia
4 Referencia
5 Referencia


Un arreglo de objetos brinda la posibilidad de manejar varios objetos
con un mismo nombre; el recorrido se hace similar a un arreglo de tipo
primitivo. Utilizando un ciclo, el ms usado es el for aunque tambin se
puede hacer con while.

Para crear todas las posiciones del arreglo b de tipo Fraccion, se
recorre el arreglo desde la posicin cero (0) hasta la cinco (5), de la siguiente
forma:

for ( int i = 0; i < 6 ; i++ )
b [ i ] = new Fraccion( i , i + 2 );

el arreglo b quedara con los siguientes valores, observe la Figura 6.8:

B
2
0

3
1

4
2

5
3

6
4

7
5

Figura 6.8. Resultado en el arreglo b
Fuente propia

Supongamos que se desea ubicar cual es el contenido de la posicin 3
del arreglo, entonces se utiliza el nombre del arreglo seguido de la posicin
entre corchetes, es decir, la siguiente instruccin:

Fraccion f = b [3] ; // despus de la instruccin f = 3/5

6.2.2.3 Manejo de Excepciones en Java

Una excepcin es la indicacin de un problema que ocurre durante la
ejecucin de un programa. El nombre viene porque la instruccin en la


mayora de las ejecuciones se hace correctamente, pero es posible que en
una ejecucin ocurra un error, entonces ser la excepcin a la regla.

El manejo de las excepciones le permite al programador desarrollar
programas que puedan resolver las excepciones, evitando que la ejecucin
del programa termine abruptamente, y se le notifique al usuario del problema,
y ejecute lneas de cdigo diseadas para tratar el error. Este manejo ayuda
a que los programas sean ms robustos.

Ejemplos comunes de excepciones, ndices fuera de rango,
desbordamiento aritmtico (es decir, un valor fuera del rango representable
de valores), la divisin entre cero, la asignacin fallida de memoria, entre
otros.

Para manejar una excepcin, Java ofrece los bloques try, catch y finally;
en el primero try se escriben las instrucciones que puedan lanzar una
excepcin, entre llaves ({}); en el bloque catch se desarrollan las
instrucciones que se realizarn en el caso que ocurra una excepcin, entre
llaves ({}), este bloque recibe un parmetro que es un objeto de tipo
Exception o perteneciente a una subclase de sta con el error ocasionado; y
en el bloque finally que es opcional, va el cdigo que siempre se ejecutar,
ocurra o no una excepcin, entre llaves ({}). Por ejemplo, supngase que se
desea dividir dos nmeros ledos, entonces, se declaran tres variables, una
para el resultado y las otras dos para los nmeros.

float resultado, numero1, numero2;
String cadena = ;
numero1 = leerNumero ( ) ;
numero2 = leerNumero ( ) ;


try {
resultado = numero1 / numero2 ; //instruccin que puede dar un error
}
catch ( AritmethicException ae){ //es de la clase que describe las
excepciones aritmticas
cadena = ha ocurrido una excepcin aritmtica ; // instruccin que
se ejecutar si ocurre la excepcin.
}

Fjese que en el ejemplo anterior, el tipo de excepcin que recibe el
catch es AritmethicException, entonces este catch slo se ejecutar cuando
ocurra una excepcin de ese tipo, al ocurrir otra excepcin no se ejecutar;
para cada try puede existir un catch por cada tipo de excepcin que pueda
ser lanzada; aunque por ahora se puede usar un catch que reciba un objeto
de tipo Exception, con esto se asegura que maneje cualquier tipo de
excepcin lanzada, ya que sta clase es la superclase de la jerarqua de
herencia de las excepciones, tema que se abordara en la unidad siguiente.
Con el uso de la clase Exception el bloque catch del ejemplo anterior
quedara de la siguiente forma:

try {
resultado = numero1 / numero2 ; //instruccin que puede dar un error
}
catch (Exception ae){ //es de la clase Exception..
cadena = ha ocurrido una excepcin ; // instruccin que se
ejecutar si ocurre la excepcin.
}



grafica
6.2.3 Resolucin de problemas con programacin orientada a objetos
usando arreglos

Para resolver un problema en programacin orientada a objetos usando
arreglos, se recomienda desarrollar la clase que describa un objeto, luego
desarrollar una que describa el arreglo de objetos, observe el siguiente
problema:

Desarrolle las clases necesaria para almacenar una serie de puntos de
una grfica (mximo 10 puntos).

Para resolverlo se debe desarrollar una clase Punto y luego una clase
Serie. Observe la Figura 6.9.


Clase Punto
coordenadaX entero
coordenadaY entero
Constructor Punto ( )
Constructor Punto (entero, entero)
setX (entero) no retorna valor
setY (entero) no retorna valor
getX ( ) entero
getY ( ) entero
compararCon ( Punto ) booleano
cadena ( ) cadena

Figura 6.9. Atributos y mtodos de la clase Punto.
Fuente propia


A continuacin observe en la Figura 4.10 la clase Punto, partiendo de la
Figura 6.9 y usando los conocimientos obtenidos hasta ahora. Fjese que
esta en el paquete grafica.

Luego se desarrolla la clase Serie en la cual se describir el arreglo de
tipo Punto, con un entero mximo para limitar el arreglo, y un entero ndice
para llevar el control de cuantos objetos tiene el arreglo; tambin se definen
los mtodos necesarios como ingresar un punto recibiendo un nuevo punto y
uno recibiendo las dos coordenadas que forman el nuevo Punto, otro mtodo
para eliminar un punto del arreglo que recibe las coordenadas del punto a
eliminar, otro mtodo para que retorne una cadena formada por todos los
puntos de la serie; estos son los que tienen mayor relevancia, los dems son
para poder obtener los valores de los atributos fuera de la clase Serie. A
continuacin observe en la Figura 6.11 los atributos y mtodos de la clase
Serie.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package grafica ;
public class Punto {
private int x,y;
public Punto ( ) {
x = 0 ;
y = 0 ;
}
public Punto ( int a , int b ) {
x = a ;
y = b ;
}
public void setX ( int a ) {
x = a ;
}
Figura 6.10. Cdigo fuente de la clase Punto(1/2)
Fuente propia



grafica
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void setY ( int a ) {
y = a ;
}
public int getX ( ) {
return x;
}
public int getY ( ) {
return y;
}
public boolean comparaCon ( Punto p ) {
return ( x == p . x && y == p . y );
}
public String cadena ( ) {
return " ( " + x + " , " + y + " ) " ;
}
}
Figura 6.10. Cdigo fuente de la clase Punto(2/2)
Fuente propia















Figura 6.11. Atributos y mtodos de la clase Serie.
Fuente propia

Clase Serie
coordenadaX entero
coordenadaY entero
Constructor Serie ( )
Constructor Serie (entero)
getPunto ( ) Punto [ ]
getIndice ( ) entero
getMaximo ( ) entero
ingresarPunto ( Punto ) cadena
ingresarPunto ( entero , entero ) cadena
eliminarPunto ( entero , entero ) cadena
cadena ( ) cadena


A continuacin la definicin de la clase Serie, su cdigo fuente en la
Figura 6.12.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package grafica ;
public class Serie {
private Punto p [ ] ; //declarando el arreglo p
private int indice , maximo ;
public Serie ( ) {
indice = 0 ;
maximo = 10 ;
p = new Punto [ maximo ] ; //creando el arreglo p
}
public Serie ( int m ) {
indice = 0 ;
maximo = m ;
p = new Punto [ maximo ] ; //creando el arreglo p
}
public Punto [ ] getPunto ( ) {
return p ;
}
public int getIndice ( ) {
return indice ;
}
public int getMaximo ( ) {
return maximo ;
}
public String ingresarPunto ( Punto a ) {
if ( indice < maximo ) {
p [ indice ++ ] = a ;
return "El punto " + p [ indice - 1 ].cadena ( ) + " se ha agregado
correctamente a la serie" ;
}
return " La serie esta completa.. " ;
}
public String ingresarPunto ( int a , int b ) {
if ( indice < maximo ) {
p [ indice ++ ] = new Punto ( a , b ) ;
Figura 6.12. Cdigo fuente de la clase Serie.(1/2)
Fuente propia



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
return " el punto " + p [ indice - 1 ] .cadena ( ) + " se ha
agregado correctamente a la serie";
}
return " La serie esta completa.. " ;
}
public String eliminarPunto ( int a , int b ) {
int i ;
for ( i = 0 ; i < indice ; i ++)
if ( p [ i ] . comparaCon ( new Punto ( a , b ) ) ) {

for ( ; i < indice - 1 ; i ++ )
p [ i ] = p [ i + 1 ] ;
indice -- ;
return " El Punto (" + a + " , " + b +") fue eliminado de la serie" ;
}
return " El punto ( " + a + " , " + b + " ) no se encontr en la serie" ;
}
public String cadena ( ) {
String x = "" ;
int i ;
for ( i = 0 ; i < indice ; i ++ )
x = x + p[ i ] . cadena ( ) + " \n " ;
return " { " + x + " } " ;
}
}
Figura 6.12. Cdigo fuente de la clase Serie.(2/2)
Fuente propia

Como se puede apreciar en la Figura 6.12. En la lnea 1 se define que
esta clase pertenece al paquete grafica.
En la lnea 2 se hace la declaracin de la clase, luego se declara p
como el arreglo de la clase Punto (Lnea 3), tambin se declaran dos (2)
enteros, uno para controlar cuantos elementos hay en el arreglo (ndice) y
el otro para guardar el mximo de elementos del arreglo (mximo); a estos
se le asigna el tamao en los constructores que se encuentran en las lneas


de la 5-9 y de la 10-14, tambin se asigna el valor de cero para el atributo
indice.

En las siguientes lneas de la 15-17 y de la 18- 20 y de la 21-23, se
encuentran los mtodos get para que desde fuera de esta clase se puedan
utilizar los valores de los atributos ya que son de tipo de acceso privados.

En las lneas 24 a la 31, se encuentra el mtodo ingresarPunto que
recibe un nuevo objeto de tipo Punto que es el que se va almacenar en el
arreglo, lo primero que hace en este mtodo es verificar que exista espacio
disponible en dicho arreglo, y retorna un mensaje para notificar si se pudo
ingresar o si todas las posiciones del arreglo estn ocupadas, en este ultimo
caso el mensaje ser La serie esta completa.., algo similar esta en el otro
mtodo ingresarPunto en las lneas 32 a 39 con la diferencia que ste
recibe dos (2) datos tipo enteros.

Luego en la lnea 40 esta el mtodo eliminarPunto que recibe las dos
coordenadas que conforman el punto a eliminar del arreglo, esto se logra
recorriendo el arreglo (lnea 42) y comparando si las coordenadas recibidas
son iguales a todas y cada unas a las correspondientes de los puntos del
arreglo (lnea 43), en el instante que se halle el punto se recorre el arreglo
desde la posicin ocupada por ste hasta la ultima posicin que este
ocupada (lnea 44), sobrescribiendo el punto a eliminar por el siguiente y as
sucesivamente hasta la ultima posicin (lnea 45), luego se debe actualizar la
cantidad de objetos del arreglo que esta almacenada en el atributo y/o
variable de instancia indice (lnea 46), por ultimo en el caso de encontrar el
punto se retorna un mensaje informando que la eliminacin fue un xito
(lnea 47); en caso contrario, de no hallar dicho punto en el arreglo entonces


se retorna un mensaje informando que el punto no exista en la serie (lnea
50).

El ultimo mtodo de la clase es el cadena que retorna todos y cada
uno de los puntos que conforman la serie(Lnea 52), para esta tarea se lleva
a cabo un for para recorrer el arreglo (lnea 55), y dentro de ste se va
concatenando en una variable local x los atributos de los puntos (lnea 56),
para al final retornar la cadena almacenada en x (lnea 57).

Fjese que en esta clase Serie se hace uso de composicin, por lo tanto
para acceder a los atributos de cada punto es necesario usar los mtodos
compararCon y cadena de la clase Punto.




CAPTULO VII: HERENCIA Y POLIMORFISMO

7.1 Objetivos

Definir los conceptos bsicos relacionados con herencia en la
programacin orientada a objetos, basndose en investigacin
previa y discusin en clases.
Identificar las superclases y subclases de problemas resueltos
mediante el uso de herencia en programacin orientada a
objetos.
Resolver problemas haciendo uso de herencia para desarrollar
programas orientados a objetos.
Definir los conceptos bsicos relacionados con polimorfismo en la
programacin orientada a objetos, basndose en investigacin
previa y discusin en clases.
Reconocer los elementos bsicos relacionados a polimorfismo en
problemas resueltos usando polimorfismo en programacin
orientada a objetos.
Resolver problemas haciendo uso de polimorfismo para
desarrollar programas orientados a objetos

7.2 Contenido

Definicin de herencia. Definicin de superclase y subclases.
Relacin entre superclase y subclases en un programa resuelto
usando herencia.
Resolucin de problemas con programacin orientada a objetos
usando herencia.


A Definicin de polimorfismo. Definicin de clases y mtodos
abstractos
Problemas resueltos con programacin orientada a objetos usando
polimorfismo
Resolucin de problemas con programacin orientada a objetos
usando polimorfismo

7.2.1 Definicin de herencia. Definicin de superclase y subclases.

7.2.1.1 Definicin de herencia. Definicin de superclase y subclases

Las caractersticas fundamentales de la programacin orientada a
objetos son abstraccin, encapsulamiento, herencia y polimorfismo. Hasta
ahora slo se ha abordado la abstraccin y la encapsulacin.

La herencia provee el mecanismo ms simple para especificar una
forma alternativa de acceso a una clase existente, o bien para definir una
nueva clase que aada nuevas caractersticas a una que ya exista.

La herencia permite definir nuevas clases usando como base las ya
existentes, la nueva clase hereda los atributos y comportamiento de la que
existe.

La herencia es una herramienta poderosa que proporciona un marco
adecuado para producir software fiable, comprensible, de bajo coste,
adaptable y reutilizable.



Esta nueva clase se denomina subclase, clase derivada o clase hija y
la clase existente, superclase, clase base o clase padre.
Con la herencia todas las clases estn clasificadas en una jerarqua.
Cada clase tiene la superclase (la clase superior en la jerarqua) que
necesite, y cada clase puede tener una o ms subclases (las clases
inferiores en la jerarqua). Las clases que estn en la parte inferior en la
jerarqua se dice que heredan de las clases que estn en la parte superior.

Existe herencia simple y mltiple; en la simple una subclase slo puede
tener una superclase, aunque una superclase puede tener ms de una
subclase. En la Figura 7.1. Se puede observar como la superclase es
Empleado con los atributos: nombre y numSegSoc, ste ltimo representa
el nmero del seguro social de los Empleados, mientras las subclases son
Gerente y Supervisor que heredan todos los atributos y todos los mtodos de
la clase Empleado.

Mientras en la herencia mltiple se permite que cada subclase pueda
tener ms de una superclase. Ver Figura 7.2. En sta figura se observa que
existen dos superclases Docente y Estudiante, y una subclase Preparador
donde Preparador hereda de las dos superclases.

El lenguaje Java slo soporta herencia simple, no se puede tener
una subclase que herede de ms de una clase como en la Figura 7.2.
Por lo tanto como ese es el lenguaje elegido para ejemplificar la
asignatura, se limitara a estudiar herencia simple.
















Figura 7.1. Jerarqua de herencia simple
Fuente propia












Figura 7.2. Jerarqua de herencia mltiple
Fuente propia

Clase Empleado
nombre cadena
numSegSoc cadena

Clase Supervisor
nombre cadena
numSegSoc cadena

Clase Gerente
nombre cadena
numSegSoc cadena

Clase Docente
asignatura cadena
salario cadena

Clase Estudiante
promGral cadena
credAprob cadena

Clase Preparador




Existe una relacin que describe la herencia es un, de la Figura
7.1. Un Gerente es un Empleado y tambin un Supervisor es un
Empleado, de la Figuro 5.2 un Preparador es un Docente y tambin es un
Estudiante. La herencia es transitiva, lo que indica que si en una
jerarqua de herencia como la de la Figura 7.1. se le aade la clase
Persona, para que la clase empleado herede de ella, entonces como:

Un Gerente es un Empleado, y
Un Empleado es una Persona, entonces
Un Gerente es una Persona.

Se puede observar la transitividad, La herencia es unidireccional, si
empleado hereda de Persona es imposibles que Persona herede de
Empleado.

En el lenguaje Java existe una clase llamada Object, es la clase raz de
la jerarqua de clases de la biblioteca Java; pertenece al paquete java.lang.
As mismo, cualquier clase que se implemente pasar a ser automticamente
una subclase de esta clase. Todos los mtodos de Object son heredados por
las clases de la biblioteca Java y por cualquier otra clase que se incluya en
un programa. Tres de estos mtodos son wait, notify y notifyAll para el control
de hilos en la programacin concurrente tema ajeno a los objetivos de esta
asignatura; otros son getClass (para obtener la clase a la cual pertenece el
objeto) y clone (para sacarle una copia al objeto que lo invoque), equals
(para comparar dos objetos, retorna un boolean), toString (para devolver el
objeto en forma de cadena) y finalize (para el recolector de basura). Todos
estos mtodos se pueden sobrescribir en las clases adaptndolo a las
necesidades presentes.



7.2.1.2 Diferencia entre la herencia y composicin

La Funcionalidad de la herencia en ocasiones tiende a confundir a los
aprendices de programacin orientada a objetos, puesto que se piensa en
que cuando la subclase hereda los atributos de la superclase, es similar a
que en los atributos de una clase exista un objeto de otra, definida
anteriormente; para diferenciar las caractersticas se usan tanto la relacin
vista de es un y la relacin tiene un, como ya se dijo es un es para
describir la herencia un objeto de la subclase es un objeto de la superclase, y
tiene un es para describir la composicin un objeto de la nueva clase tiene un
objeto de la clase declarada con anterioridad, partiendo de las Figuras 3.4 y
5.1.
1. Un Automvil tiene un Motor ?
2. Un Automvil es un Motor ?
3. Un Supervisor tiene un Empleado ?
4. Un Supervisor es un Empleado ?
Las respuestas a las interrogantes son:
1. si, es composicin.
2. no.
3. no.
4. si, es herencia.

Porque un Automvil no es un Motor es mucho ms, aunque el Motor lo
conforma tambin tiene caja, neumticos, chasis, entre otros. Mientras que
un gerente no puede tener un Empleado, sin embargo es un Empleado; el
uso de estas relaciones ayuda a visualizar en qu momento se debe usar
herencia o composicin, solo se tienen que hacer dos interrogantes, y segn
sean las respuestas se usa herencia composicin.


7.2.2 Relacin entre superclase y subclases en un programa resuelto
usando herencia.

Es importante que las superclases y subclases estn o en el mismo
paquete o se importe el paquete donde este la superclase para poder usarla.

Supngase el siguiente enunciado de problema.
Una compaa que se dedica a la venta de productos, por cada uno se
maneja la siguiente informacin: cdigo y precio. Un producto puede ser de
limpieza de alimentacin, en los de limpieza se tiene tambin un
ingrediente activo, y en los de Alimentacin se tiene tambin la ao de
vencimiento.

Para resolver este ejercicio, lo primero es identificar las clases, es decir
la clasificacin, y stas son: Producto, DeAlimentacin y DeLimpieza, para la
jerarqua de herencia, la superclase es Producto y las subclases
DeAlimentacin y DeLimpieza. Ver Figura 7.3.


A continuacin los cdigos fuentes que le corresponde a las clases que
conforman la jerarqua de herencia, en la Figura 7.4. La superclase Producto,
se desarrolla normalmente como se vio en los ejemplos anteriores.









articulos

















Figura 7.3. Jerarqua de herencia del ejercicio propuesto
Fuente propia




Clase Producto
codigo cadena
precio real
Producto ( )
Producto(cadena , real )
setCodigo(cadena) no retorna valor
setPrecio(real) no retorna valor
getCodigo() cadena
getPrecio() real
cadena( ) cadena
Clase Delimpieza
ingredienteAct cadena
DeLimpieza( cadena , real , cadena )
setIngredienteA(cadena) no retorna valor
getIngredienteA( ) cadena
cadena ( ) cadena
Clase DeAlimentacion
aoVenc entero
DeAlimentacion ( cadena , real , entero
)
setAoVenc(entero)no retorna valor
getaoVenc( ) entero
cadena( ) cadena



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package articulos ;
import caracteristicas ;
public class Producto {
private String codigo;
private float precio;
public Producto ( ) {
codigo = 0 ;
precio = 0 . 0 f ;
}
public Producto ( String c , float p ) {
codigo = c ;
precio = p;
}
public void setCodigo ( String a ) {
codigo = a ;
}
public void setPrecio ( float a ) {
precio = a ;
}
public String getCodigo ( ) {
return codigo ;
}
public float getPrecio ( ) {
return precio ;
}
public String cadena ( ) {
return El producto: cdigo + codigo + , + tiene un precio
de BsF. + precio ;
}
}
Figura 7.4. Cdigo fuente de la clase Producto.
Fuente propia



Seguidamente las subclases DeLimpieza (Figura 7.5) y DeAlimentacion
(Figura 7.6), observe que stas en la lnea 1 de cada clase, se puede
observar extends una palabra reservada, que indica que la clase que se esta
declarando es una subclase del nombre de clase que le sigue, en este caso
la superclase Producto, as se codifica la herencia en Java; luego en los
constructores la primera instruccin con la que se topa es { super ( c ,
p ); } (en la lnea 5, de las Figuras 7.5 y 7.6 ) que indica la llamada al
constructor de la superclase y se le enva todos los parmetros que recibe.
Tambin en los mtodos cadena, se tiene un {super . cadena ()} (Lnea 14 de
las Figuras 7.5 y 7.6) esto hace que se ejecute el mtodo cadena de la
superclase y concatene esa cadena con lo dems.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package articulos ;
public class DeLimpieza extends Producto {
private String ingredienteAct;
public DeLimpieza (String c , float p , String ing ) {
super ( c , p ) ;
ingerdienteAct = ing ;
}
public void setIngredienteA ( String a ) {
ingredienteAct = a ;
}
public String getIngredienteA ( ) {
return ingredienteAct ;
}
public String cadena ( )
return super . cadena ( ) + Es un articulo de limpieza y el
ingrediente activo que contiene es: + ingredienteAct ;
}
}
Figura 7.5. Cdigo fuente de la clase DeLimpieza.
Fuente propia



Del ejercicio anterior se puede observar que con respecto a la sintaxis,
la superclase se desarrolla como las clases tradicionales que se han
ilustrado hasta ahora; mientras que las subclases se le coloca la palabra
reservada extends en la declaracin de las mismas, y en el constructor de
stas la primera instruccin tiene que ser el llamado al constructor de la
superclase, envindole los parmetros necesarios.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package artculos ;
public class DeAlimentacion extends Producto{
private int aoVenc;
public DeAlimentacion (String c , float p , int a ) {
super ( c , p ) ;
aoVenc = f ;
}
public void setAoVenc (int a ) {
aoVenc = a ;
}
public int getAoVenc ( ) {
return aoVenc ;
}
public String cadena ( ) {
return super . cadena ( ) + Es un articulo de alimentacin, y el
ao de vencimiento es + aoVenc . cadena ( ) ;
}
}
Figura7.6. Cdigo fuente de la clase DeAlimentacion


7.2.3 Resolucin de problemas con programacin orientada a objetos
usando herencia
Realice las clases necesarias para describir la siguiente jerarqua
persona, Estudiante y profesor, cada una de las clases con al menos
dos (2) atributos y al menos dos (2) mtodos diferentes a los
constructores, set, get, y cadena.


7.2.4 Definicin de polimorfismo. Definicin de clases y mtodos
abstractos.

7.2.4.1 Definicin de polimorfismo

Polimorfismo es la facultad de asumir muchas formas, en el paradigma
de Programacin Orientado a Objetos se refiere a la facultad de llamar a
muchos mtodos diferentes utilizando una nica sentencia.

El polimorfismo permite que diferentes objetos respondan de modo
diferente al mismo mensaje. ste parte de la herencia, porque existe una
subclase y de una a varias subclases.

Para hacer uso del polimorfismo es necesaria una clase abstracta, que
no es ms que la representacin de conceptos generales, que engloban las
caractersticas comunes de un conjunto de objetos. Por ejemplo Empleado
es un contexto de trabajadores, es una clase general que engloba las
propiedades y mtodos comunes a todo tipo de empleado que trabaja en una
empresa. La clase general Empleado, no es necesario que se instancie, es
decir, que se cree un objeto de este tipo, si existe Gerente, Obrero,
Supervisor, entre otros, para que declarar un Empleado mejor se utilizan las
subclases.

7.2.4.2 Definicin de Clases y Mtodos Abstractos

7.2.4.2.1 Definicin de clases abstractas



Para definir la clase general (superclase) se necesita la palabra
reservada abstract que es un modificador para definir clases y mtodos
abstractos; en una clase abstracta debe existir de uno a varios mtodos
abstractos, stos solo se declaran en la superclase, mientras su definicin se
desarrolla en las subclases; la clases abstractas tambin pueden contener
variables de instancia y de clase, al igual que mtodos de instancias y de
clases.

Para definir una clase abstracta se hace de la siguiente forma:
abstract class Identificador_de_la_clase { . . . }

Por ejemplo:
abstract class Empleado { . . . }
Mientras que las subclases:
class Gerente extends Empleado { . . . }

como se puede observar las subclases se definen al igual que con herencia.

7.2.4.3 Definicin de los mtodos abstractos

Esta definicin se hace dentro de la clase abstracta, porque estos
mtodos pueden estar declarados nicamente en las clases abstractas, y su
definicin en las subclases.

Como se puede observar en la Figura 7.7, en la lnea 2 se declara la
clase Empleado como abstracta; luego se definen los atributos de la clase
(lneas 3 y 4); en las lneas 5 a 8 esta el constructor de la clase; en las lneas
9 a la 14 los mtodos setSueldo y getSueldo para poder tener acceso al


atributo sueldo desde fuera de sta clase; en la lnea 15 esta la declaracin
del mtodo abstracto, que es de tipo de acceso pblico, no retornara ningn
valor y su nombre es calcularSueldo, y no necesita parmetros, se puede
ver que finaliza con punto y coma porque esta sentencia termino; y por ultimo
en la lnea 16 se encuentra el mtodo cadena. A continuacin las subclases,
observe la Figura 7.8.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package empresa ;
abstract class Empleado{
private String nombre;
private float sueldo;
Empleado( String n , float s ) {
nombre = n ;
sueldo = s ;
}
public void setSueldo (float s) {
sueldo = s ;
}
public float getSueldo ( ) {
return sueldo ;
}
public abstract void calcularSueldo ( ) ;
public String cadena ( ) {
return el empleado + nombre + tienen un sueldo de BsF. +
sueldo; } /*fin del mtodo*/ } //fin de la Clase
Figura 7.7. Cdigo fuente del ejemplo de la clase abstracta Empleado.
Fuente propia






1
2
3
4
5
6
7
8
9
10
11
12
13
package empresa ;
class Gerente extends Empleado {
private String sucursal;
Gerente ( String n , float s , String su ) {
super ( n , s ) ;
sucursal = su;
}
public void calcularaSueldo ( ) {
setSueldo ( getSueldo ( ) getSueldo ( ) * 0.1 + 300 ) ;
}
public String cadena ( ) {
return super . cadena ( ) + y es gerente de la sucursal + sucursal ;
} /*fin del mtodo*/ } //fin de la clase
Figura 7.8. Cdigo fuente del ejemplo de la subclase Gerente.
Fuente propia

En la Figura 7.8. Se puede ver en la lnea 1 la declaracin del paquete
empresa; luego la lnea 2 la declaracin de la clase Gerente como subclase
de Empleado; en la lnea 3 se declara el atributo sucursal; en las lneas 4 a
7 el constructor con la primera instruccin invocando al constructor de la
superclase; en la lnea 8 se encuentra la definicin del mtodo abstracto que
hereda, es decir, con las instrucciones que lo conforman; y por ultimo en la
lnea 11 el mtodo cadena.


Si en una subclase no se define el mtodo abstracto de la superclase,
entonces sta debe ser abstracta tambin; y la subclase de sta debe definir
los de la primera superclase y los de la segunda, supngase
abstracta clase A

abstracto metodo1( ) no retorna valor





Figura 7.9. Ejemplo de polimorfismo
Fuente propia

Como se observa en la Figura 7.9. La clase B hereda de la clase A que
es abstracta, y en la subclase B no se redefine el mtodo1, esto producir un
error para solucionarlo (a) se debe redefinir el mtodo o (b) la clase B debe
ser abstracta tambin, vea Figura 7.10.

abstracta clase A

abstracto metodo1( ) no retorna valor




Figura 7.10. (a) Solucin 1 del Ejemplo de polimorfismo
Fuente propia
clase B

metodo2 ( ) entero
clase B

metodo2 ( ) int
metodo1 ( ) no retorna valor


abstracta clase A

abstracto metodo1( ) no retorna valor




Figura 7.10. (b) Solucin 2 del Ejemplo de polimorfismo
Fuente propia

7.2.4.4 Uso del polimorfismo

La funcionalidad del polimorfismo ser explicada con un ejemplo, de las
Figuras 7.8 y 7.9, supngase que existen otras dos subclases, una para
Supervisor y otra para Obrero; si la empresa necesita manejar todo el
personal en un arreglo, en ste debe haber Gerentes, Supervisores y
Obreros, entonces se puede hacer un arreglo para cada subclase, pero
tambin se puede declarar un arreglo de tipo de la superclase abstracta
Empleado, y cada posicin crearla como un tipo de dato de las subclase;
luego recorrer el arreglo e invocar el mtodo definido en todas las subclases
calcularSueldo( ), porque el mtodo que se ejecute corresponder a la
subclase que pertenezca la posicin del arreglo en un momento dado.

Observe la Figura 7.11. Donde se tiene un arreglo E de tipo
Empleado, y en cada posicin esta un objeto perteneciente a las distintas
subclases, Gerente, supervisor y Obrero, Ejemplo

abstracta clase B

metodo2 ( ) entero


Empleado E [ ] = new Empleado [ 4 ] ;
E [ 0 ] = new Gerente ( ) ;
E [ 1 ] = new Obrero ( ) ;
E [ 2 ] = new Supervisor ( ) ;
E [ 3 ] = new obrero ( ) ;
int in ;
for ( in = 0; in < E . length ; in ++ )
E [ in ] . calcularSueldo ( ) ; //sin importar de que tipo es E [ in ].
0 1 2 3
Arreglo E Gerente Obrero Supervisor Obrero
Figura 7.11. Representacin de un arreglo de Empleados.
Fuente propia

De esta forma se calcula el sueldo de todos los empleados del arreglo.
Para mayor informacin, Ver el punto 7.2.6.

7.2.4.5 Interfaces de Java

Las interfaces Java son expresiones puras de diseo. Se trata de
autnticas conceptualizaciones no implementadas que sirven de gua para
definir un determinado concepto (clase) y lo que debe hacer, pero sin
desarrollar un mecanismo de solucin.

Se trata de declarar mtodos abstractos y constantes que
posteriormente puedan ser implementados de diferentes maneras segn las
necesidades de un programa.

Declaracin


Para declarar una interfaz se utiliza la sentencia interface, de la misma
manera que se usa la sentencia class; observe Figura 5.12.






Figura 7.12. Cdigo fuente de la interface MiInterfaz
Fuente propia

Se observa en la declaracin que las variables adoptan la declaracin
en maysculas, pues en realidad actuarn como constantes final. En ningn
caso estas variables actuarn como variables de instancia.

Por su parte, los mtodos tras su declaracin presentan un punto y
coma, en lugar de su cuerpo entre llaves. Son mtodos abstractos, por tanto,
mtodos sin implementacin

Implementacin de una interfaz
Como ya se ha visto, las interfaces carecen de funcionalidad por no
estar implementados sus mtodos, por lo que se necesita algn mecanismo
para dar cuerpo a sus mtodos.
La palabra reservada implements utilizada en la declaracin de una
clase indica que la clase implementa la interfaz, es decir, que asume las
constantes de la interfaz, y codifica sus mtodos; ver Figura 7.13.



1
2
3
4
interface MiInterfaz {
int CONSTANTE = 100;
int metodoAbstracto ( int parametro ) ;
}










Figura 7.13. Cdigo fuente de la clase que implementa a la interface MiInterfaz
Fuente propia

En este ejemplo se observa que han de codificarse todos los mtodos
que determina la interfaz (metodoAbstracto( )), y la validez de las constantes
(CONSTANTE) que define la interfaz durante toda la declaracin de la clase.
Una interfaz no puede implementar otra interfaz, aunque s extenderla
(extends) amplindola.

Herencia mltiple de Interfaz
Java es un lenguaje que incorpora herencia simple de implementacin
pero que puede aportar herencia mltiple de interfaz. Esto posibilita la
herencia mltiple en el diseo de los programas Java.

Una interfaz puede heredar de ms de una interfaz antecesora.

interface InterfazMultiple extends Interfaz1 , Interfaz2 { }
Una clase no puede tener ms que una superclase, pero puede
implementar ms de una interfaz:

class MiClase extends SuPadre implements Interfaz1 , Interfaz2 { }

1
2
3
4
5
6
class ImplementaInterfaz implements MiInterfaz {
int multiplicando = CONSTANTE ;
int metodoAbstracto ( int parametro ) {
return ( parametro * multiplicando ) ;
}
}


El ejemplo tpico de herencia mltiple es el que se presenta con la
herencia en diamante, ver Figura 7.14:








Figura 7.14. Ejemplo de herencia mltiple con interfaces
Fuente propia

De la Figura 7.14. Para poder llevar a cabo un esquema como el
anterior en Java es necesario que las clases A, B y C de la figura sean
interfaces, y que la clase D sea una clase (que recibe la herencia mltiple):

interface A{ }
interface B extends A{ }
interface C extends A{ }
class D implements B,C{ }

Colisiones en la herencia mltiple de Interfaces
En una herencia mltiple, los identificadores de algunos mtodos o
atributos pueden coincidir en la clase que hereda, si dos de las interfaces
padres tienen algn mtodo o atributo que coincida en nombre; a esto se le
llama colisin.


A

B

C

D


Esto se dar cuando las clases padre (en el ejemplo anterior B y C)
tienen un atributo o mtodo que se llame igual. Java resuelve el problema
estableciendo una serie de reglas.

Para la colisin de nombres de atributos, se obliga a especificar a qu
interfaz base pertenecen al utilizarlos.

Para la colisin de nombres en mtodos:

Si tienen el mismo nombre y diferentes parmetros: se produce
sobrecarga de mtodos permitiendo que existan varias maneras de llamar al
mismo.
Si slo cambia el valor devuelto: se da un error de compilacin,
indicando que no se pueden implementar los dos
Si coinciden en su declaracin: se elimina uno de los dos, con lo que
slo queda uno.

7.2.5 Problemas resueltos con programacin orientada a objetos
usando polimorfismo.

Desarrolle las clases necesarias para describir la siguiente
jerarqua: Figura Geomtrica, Rectngulo, y Circulo; para que
almacene N figuras y calcule el rea de cada una.

Para resolver este problema se debe definir las clases a desarrollar,
como se observa en la Figura 7.15, representacin de la jerarqua de
herencia de las figuras geomtricas, se tiene la superclase abstracta
FiguraGeometrica, con el atributo area, los mtodos de instancias getArea


y cadena, y el mtodo abstracto setArea. Tambin se tienen las subclases
Rectangulo y Circulo, con sus variables, mtodos de instancias, y la
redefinicin del mtodo abstracto setArea que heredan de la superclase
Figurageometrica.

Todas las clases tanto la superclase como las subclases pertenecen al
paquete figuras, y la clase donde se define el arreglo FigurasG tambin
pertenece a ste paquete, en sta clase se define un arreglo del tipo
FiguraGeometrica aunque esta clase no puede ser instanciada en la
declaracin y creacin de un arreglo no hay instanciacin puesto que un
arreglo es una coleccin de variables con un mismo nombre, lo que no se
puede hacer es crear una de las posiciones del arreglo como
FiguraGeometrica, porque as si producir un error, pero mientras las
posiciones del arreglo se creen utilizando una de las subclases que no sean
abstractas, todo marchara bien.

A continuacin el cdigo fuente que corresponde a las clases
FiguraGeometrica Figura 7.16

Como se puede observar en la Figura 7.16, en la lnea 2, se define la
clase como abstracta, esto indica que debe contener al menos un mtodo
abstracto, que su declaracin se encuentra en la lnea 10, de tipo de acceso
publico, abstracto, no retorna ningn valor, con en el nombre setArea, y sin
recibir parmetros.







figuras









Figura 7.15. Representacin de las figuras geomtricas
Fuente propia


Los cdigos fuentes de las clases Rectangulo y Circulo estn
desarrollados en las Figuras 7.17 y 7.18, en estas se puede observar en las
respectivas lnea 2 de cada clase que heredan de la clase abstracta con la
palabra reservada para definir la herencia extends, y en la lnea 5 esta el
llamado al constructor de la superclase, y en la lnea 21 y 14 de cada clase
abstracta clase FiguraGeometrica
area real
Constructor FiguraGeometrica ( )
getArea ( ) real
abstracto setArea ( ) no retorna valor
clase Circulo
radio real
Constructor Circulo ( real )
setRadio ( real ) no retorna valor
getRadio ( ) real
setArea( ) no retorna valor
cadena ( )cadena
clase Rectangulo
base real
alturareal
Constructor Rectangulo ( real , real )
setBase ( real ) no retorna valor
setAltura ( real ) no retorna valor
getBase ( ) real
getAltura ( ) real
setArea( ) no retorna valor
cadena ( )cadena


respectivamente, est la redefinicin del mtodo setArea, fjese que las
instrucciones corresponden a la frmula para calcular el rea de cada figura.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
package figuras;
public abstract class FiguraGeometrica {
protected float area;
public FiguraGeometrica() {
area = 0.0f ;
}
public float getArea ( ) {
return area ;
}
public abstract void setArea ( ) ;
public String cadena ( ) {
return "tiene un area de " + area ;
}
}
Figura 7.16. Cdigo fuente de la clase abstracta FiguraGeometrica

Fuente propia


En la clase circulo (Lnea 15 de la Figura 7.18) se usa la constante PI
definida en la clase Math como un double, para multiplicarla con valores float
y almacenarla en uno de ellos existe perdida de precisin por esta razn se
debe hacer una conversin explicita a float.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package figuras;
public class Rectangulo extends FiguraGeometrica {
private float base , altura ;
public Rectangulo( float b , float a) {
super ( ) ;
base = b;
altura = a;
}
public void setBase ( float a ) {
base = a;
}
public void setAltura ( float a ) {
altura = a;
}
public float getBase ( ) {
return base ;
}
public float getAltura ( ) {
return altura ;
}
public void setArea( ) {
area = base * altura ;
}
public String cadena ( ) {
return "El Rectangulo de " + base+ "x" + altura+ super. cadena ( ) ;
}
}
Figura 7.17. Cdigo fuente de la subclase Rectangulo
Fuente propia




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package figuras;
public class Circulo extends FiguraGeometrica{
private float radio ;
Circulo ( float r ) {
super ( ) ;
radio = r ;
}
public void setRadio ( float r ) {
radio = r ;
}
public float getRadio ( ) {
return radio ;
}
public void setArea ( ) {
float aux = (float)Math . PI ;
area = 2 * aux *radio ;
}
public String cadena ( ) {
return " El Circulo de radio " + radio + super . cadena ( ) ;
}
}
Figura 7.18. Cdigo fuente de la subclase Circulo.
Fuente propia

En la siguiente figura (Figura 7.19), se encuentra el cdigo fuente de la
clase FigurasG, que pertenece al paquete figuras, en la lnea 3 se declara el
arreglo de tipo FiguraGeometrica, para que se puedan almacenar figuras
tanto Rectangulos como Circulos, tambin se declaran dos enteros uno in
para controlar cuantas figuras geometricas almacena el arreglo en un


momento dado, y un max para la cantidad mxima de elementos a
almacenar(Lnea 4); en la lnea 7 se le asigna el tamao al arreglo fg con el
valor entero que recibe el constructor, tambin se le asigna este mismo
entero a la variable de instancia max, y a la variable in se le asigna el
valor cero (0), porque inicialmente el arreglo no contiene figuras; en la lnea
11 se encuentra el mtodo ingresarF que retorna una cadena, y recibe un
objeto declarado como FiguraGeometrica para que pueda almacenar un
objeto creado de cualquier tipo de las subclases de sta, en este caso
Rectangulo Circulo, luego dentro de este mtodo, en las lneas 14 y 16, se
pregunta a que clase pertenece el objeto con los mtodos getClass
perteneciente a la clase Object que retorna la clase con el nombre de los
paquetes que la contenga, por ejemplo en este caso retorna
figuras.Rectangulo y el mtodo getSimpleName() retorna slo el nombre
de la clase, por ejemplo Rectangulo sin el o los paquetes donde se
encuentre, depende a que subclase pertenece, se invoca el mtodo
correspondiente ingresarR ingresarC", haciendo una conversin
explicita al objeto f que se recibe como parmetro.

1
2
3
4
5
6
7
8
9
10
package figuras;
public class FigurasG {
FiguraGeometrica fg [ ] ;
int in , max ;

public FigurasG ( int n ) {
fg = new FiguraGeometrica [ n ] ;
max = n ;
in = 0 ;
}
Figura 7.19. Cdigo fuente de la clase figurasG que describe el arreglo (1/2)
Fuente propia


11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public String ingresarF ( FiguraGeometrica f ) {
String x = " " ;
if ( in < max )
if ( f . getClass ( ). getSimpleName ( ). equals(" Rectangulo ") )
x = ingresarR ( ( Rectangulo ) f ) ;
else if (f.getClass( ). getSimpleName( ). equals ( "Circulo"))
x = ingresarC ( ( Circulo ) f ) ;
return x ;
}
public String ingresarR ( Rectangulo r ) {
fg [ in ++ ] = new Rectangulo ( r . getBase ( ) , r . getAltura ( ) ) ;
return " El Rectngulo se ha creado satisfactoriamente ";
}
public String ingresarC ( Circulo r ) {
fg [ in ++ ] = new Circulo ( r . getRadio ( ) ) ;
return " El Circulo se ha creado satisfactoriamente " ;
}
public String cadena ( ) {
String x = " " ;
for ( int i = 0 ; i < max ; i ++ )
x = x + fg [ i ] . cadena ( ) + " \n " ;
return x ;
} /* fin del mtodo */ } //fin de la Clase
Figura 7.19. Cdigo fuente de la clase figurasG que describe el arreglo(2/2)
Fuente propia





7.2.6 Resolucin de problemas con programacin orientada a objetos
usando polimorfismo.

La Empresa QWX2000 c.a. desea saber el sueldo que se le debe pagar
a un empleado en la semana. Tomando en cuenta lo siguiente:
A un Obrero una hora extra es pagada como el 10% de su sueldo base,
se le descuenta 2% por seguro social, 3% por Ley poltica habitacional y 5%
por paro forzoso. Mientras que a un Supervisor una hora extra es pagada
como el 4% de su sueldo base, se le descuenta 3% por seguro social, 5%
por Ley poltica habitacional, 6% por paro forzoso y se le es asignado un
bono de Bs. 50.000 por cumplimiento de horario; y a un Gerente se le asigna
un bono de 10% al mes, por ser personal de confianza, se le descuenta 10%
por seguro HCM, 9% por Ley poltica habitacional Realizar un programa en
java que calcule el sueldo total que debe percibir un empleado.



CAPTULO VIII: USO DE INTERFAZ GRFICA DE USUARIO

8.1 Objetivos
Definir Interfaz grfica de usuario basado en una investigacin
previa y discusin en clases.
Definir componentes que conforman la interfaz grafica de usuario,
segn discusin en clases.
Identificar componentes que conforman la interfaz grafica de
usuario, usando programacin orientada a objetos.
Resolver problemas haciendo uso de interfaz grafica de usuario y
manejo de eventos para desarrollar programas orientados a
objetos.

8.2 Contenido
Definicin interfaz grafica de usuario.
Definicin de los componentes que conforman la interfaz grafica
de usuario.
Ejemplos de los componentes que conforman la interfaz grafica
de usuario en la programacin orientada a objetos.
Resolucin de problemas usando interfaz grfica y manejo de
eventos en programacin orientada a objetos.
Definicin interfaz grafica de usuario.

8.2.1 Interfaz grfica de usuario

El concepto de interfaz es un concepto amplio que ha sido definido,
segn el mbito de conocimientos, desde varios puntos de vista: desde la
biologa (interfase), ha sido definida como la capa de un organismo que


separa su interior del exterior, desde la electrnica y las telecomunicaciones,
se ha definido como puerto a travs del que se envan o reciben seales
desde un sistema o subsistemas hacia otros. En qumica interfaz es la
superficie entre dos fases distintas en una mezcla heterognea.

Si vamos al origen de la palabra interfaz se encuentra una palabra
compuesta, por dos vocablos:
Inter proviene del latn inter, y significa, entre o en medio, y Faz
proviene del latn faces, y significa superficie, vista o lado de una cosa. Por
lo tanto una traduccin literal del concepto de interfaz atendiendo a su
etimologa, podra ser superficie, vista, o lado mediador.

En el contexto de la interaccin persona-computador, se habla de
interfaz de usuario, para referirse de forma genrica al espacio que media la
relacin de un sujeto y un ordenador o sistema interactivo. La interfaz de
usuario, es esa ventana mgica de un sistema informtico, que posibilita a
una persona interactuar con l.

Cuando se habla de interfaz grfica de usuario (GUI), el concepto es
an ms especfico en cuanto que interfaz grfico de usuario al contrario que
el concepto de interfaz tiene una localizacin determinada y definida: Si el
interfaz etimolgicamente supone la cara o superficie mediadora, el interfaz
grfico de usuario, supone un tipo especfico de interfaz que usa metforas
visuales y signos grficos como paradigma interactivo entre la persona y el
computador. La interfaz grfica, da pistas sobre el modelo de interaccin y la
tipologa de signos que contiene esta superficie mediadora.

Una interfaz grfica de usuario (GUI) presenta un mecanismo amigable
al usuario para interactuar con un programa; ya que a este ltimo le


proporciona una apariencia visual nica. Al proporcionar distintos programas
en los que componentes de la interfaz de usuario sean consistentes e
intuitivos, los usuarios pueden familiarizarse con un programa incluso antes
de utilizarlo. Esto, a su vez, reduce el tiempo que requieren para aprender a
usar un programa y aumenta su habilidad para utilizar el programa en una
manera productiva.

Uno de los principales objetivos de este tipo de entornos es minimizar el
tiempo de aprendizaje de la aplicacin para el usuario. Sin embargo, desde
el punto de vista del programador, ha supuesto un importante giro en la
filosofa tradicional de programacin.


8.2.1.1 API de Java

API (Application Programming Interface o Interfaces de programacin
de aplicacin), stas no son ms que colecciones de clases existentes en las
bibliotecas de clases de Java. Las APIs tambin se conocen como
bibliotecas de clase de Java.

La API de Java proporciona una vasta coleccin de clases que
contienen mtodos para realizar clculos matemticos, manipulaciones de
cadenas, manipulaciones de caracteres, operaciones de entrada/salida,
comprobacin de errores y muchas operaciones tiles. Este conjunto de
clases facilita la escritura de programas, ya que la API de Java proporciona
muchas herramientas que necesitan los programadores.



Por ejemplo la clase String vista en la unidad III, la clase Math que
contiene constantes y funciones matemticas, como la constante PI,
funciones como para calcular la potencia (pow), la raz cuadrada (sqrt) entre
otras; las clases de los componentes de la interfaz grfica de usuario; las
interfaces para el manejo de eventos en las interfaces grfica de usuario.

Visto de otra forma el API de Java es un conjunto de clases que es
utilizado para generar programas bsicos en el lenguaje; utilizando una
analoga, estas clases tienen la misma funcionalidad que las
funciones/clases estndar utilizadas en otros lenguajes C/C++, Perl

Partiendo de estas clases (API de Java) se generan todos los
programas, interfaces y elementos programados en Java, inclusive a partir de
estas clases se puede definir otras clases especficas que sern utilizadas
por su programa o producto.

Definicin de los componentes que conforman la interfaz grafica de
usuario.

8.2.1.2 Componentes de la interfaz grfica

Las interfaces grficas de usuario (GUIs) se crean a partir de
componentes de la GUI tambin conocidos como controles o widgets
(accesorios de ventana). Un componente de la GUI es un objeto con el cual
interacta el usuario mediante el ratn, el teclado u otra forma de entrada,
como el reconocimiento de voz. Varios de los componentes de la GUI se
muestran en la Tabla 8.1.



Tabla 8.1. Algunos de los componentes de la GUI
Componente
Componente en Java
del paquete javax .
swing
Descripcin
Etiqueta JLabel rea en donde pueden mostrarse
iconos o texto no editable.
Campo de texto JTextField rea en la que el usuario introduce
datos desde el teclado. Esta rea
tambin puede mostrar informacin.
Botn JButton rea que, cuando el ratn hace clic
sobre ella, desencadena un evento.
Cuadro de
comprobacin
JCheckBox Componente de la GUI que puede
estar o no seleccionado.
rea de lista
modificable
JComboBox Lista desplegable de elementos, de
los cuales el usuario puede
seleccionar uno haciendo clic en l o
posiblemente escribiendo dentro del
cuadro.
Lista de opciones
mltiples
JList rea que contiene una lista de
elementos, de los cuales el usuario
puede seleccionar cualquiera
haciendo clic en l. Pueden
seleccionarse varios elementos.
Fuente: propia

Son algunos de los ms usados; con etiquetas, campos de texto y
botones se puede desarrollar una interfaz grfica de usuario agradable y de
fcil manejo para probar una(s) clase(s); stas sirven para probar el buen
funcionamiento de las clases que hasta ahora se han desarrollado.




8.2.1.3 Paquetes Awt y Swing de Java

En la Tabla 8.1 se presentan los componentes que pertenecen al
paquete javax . swing, porque es el ms usado actualmente, la mayora de
los componentes de swing, como se le llama comnmente, estn escritos, se
manipulan y muestran completamente en Java(llamado componentes puros
de Java).

Los componentes originales de la GUI del paquete java . awt del AWT
(Abstract Windows Toolkit) estn enlazados directamente con las
herramientas de interfaz grfica de usuario de la plataforma local(sistema
operativo). Cuando se ejecuta un programa en Java con una GUI de la AWT
en distintas plataformas Java, los componentes de la GUI del programa se
muestran de manera distinta en cada plataforma; por ejemplo un objeto tipo
Button (de la AWT) en una computadora que se ejecute el sistema operativo
Microsoft Windows tendr una apariencia visual como los botones de ese
sistema operativo, mientras que en una que ejecute el sistema operativo Mac
OS de Apple, el objeto Button tendr la misma apariencia visual de los
botones del sistema operativo actual. En ocasiones, la forma en que un
usuario puede interactuar con un componente AWT especfico es distinta
entre las plataformas.

Los componentes de Swing comnmente se conocen como
componentes ligeros; estn escritos completamente en Java, por lo que no
son abrumados por las complejas herramientas de la GUI de la plataforma
en que se utilicen. Sin embargo, a los componentes de AWT (muchos de los
cuales comparan con los componentes de Swing), que estn enlazados a la
plataforma local, se les llama componentes pesados; stos dependen del


sistema de ventanas de la plataforma local para determinar su funcionalidad,
apariencia visual, y manera en que el usuario interacta con el programa.

Para utilizar componentes de la GUI efectivamente, se utilizan los
paquetes javax.swing y java.awt, conjuntamente, para obtener un resultado
esperado, porque en el paquete java.awt, existen clases e interfaces
necesarias para el desarrollo de la GUI, sobretodo los componentes escucha
de eventos (oyentes de eventos), mientras que en el paquete javax.swing,
estn desarrollados los componentes de escucha de eventos adicionales que
son especficos para los componentes Swing.

8.2.1.4 GUI en Java

En el lenguaje Java las interfaces grficas de usuario se pueden
desarrollar con:
Un applet es un subprograma que se ejecuta dentro de una pgina
web, donde la clase que lo describe tiene que heredar de la
superclase JApplet, y se puede redefinir los mtodos que se
encuentran en la clase JApplet:
o public void init ( )
Este mtodo es llamado una vez por el contenedor de
applets cuando se carga un applet para ejecutarse. Lleva a
cabo la inicializacin de un applet. Las acciones tpicas que se
realizan aqu son inicializar campos, crear componentes de la
GUI, cargar los sonidos a reproducir, cargar las imgenes a
mostrar.
o public void start ()


Este mtodo se llama despus de que el mtodo init
termina de ejecutarse. Adems, si el navegador visita otro sitio
Web y despus regresa a la pgina de HTML en la que reside
el applet, el mtodo start se llama de nuevo. Este mtodo lleva
a cabo todas las tareas que deben completarse cuando el
applet se carga por primera vez, y que deben de llevarse a
cabo cada vez que se vuelva a visitar la pagina de HTML en la
que reside el applet. Las acciones tpicas que se realizan aqu
incluyen el empezar una animacin y empezar otros
subprocesos de ejecucin. Las animaciones y sonido son
ajenos al objetivo de la asignatura, entonces este mtodo no se
redefinir en los ejemplos.
o public void paint ( Graphics g )
Este mtodo de dibujo se llama despus de que el mtodo
init termina de ejecutarse y el mtodo start ha comenzado.
Tambin se llama cada vez que el applet necesita volver a
pintarse. Por ejemplo, si el usuario cubre el applet con otra
ventana abierta en la pantalla y despus descubre el applet, se
hace una llamada al mtodo paint. Las acciones tpicas que se
realizan aqu incluyen el dibujar con el objeto g tipo Graphics
que se pasa al mtodo paint mediante el contenedor de
applets.
o public void stop ( )
Este mtodo se llama cuando el applet debe detener su
ejecucin; normalmente, cuando el usuario del navegador sale
de la pginaHTML en la que reside el applet. El mtodo realiza
todas las tareas requeridas para suspender la ejecucin del
applet. Las acciones tpicas que se realizan aqu son detener la
ejecucin de las animaciones y los subprocesos. Las


animaciones y subprocesos son ajenos al objetivo de la
asignatura, entonces este mtodo no se redefinir en los
ejemplos.
o public void destroy ( )
Este mtodo se llama cuando el applet se va a quitar de
memoria; normalmente, cuando el usuario del navegador sale
de la sesin de navegacin(es decir, cuando cierra todas las
ventanas del navegador). El mtodo realiza todas las tareas
requeridas para destruir los recursos asignados al applet.
Un Frame es una aplicacin que se ejecuta desde el computador,
como una aplicacin para un computador personal o para que se
ejecute en un servidor;

A continuacin se explicaran los applet.

Para desarrollar un applet un frame hay que importar los paquetes
javax.swing , java.awt y java.awt.event para usar los componentes que se
encuentran descritos en las clases pertenecientes a estos, como manejar las
acciones descritas en alguno de estos paquetes. Hay que desarrollar una
clase que herede de las clases JApplet de JFrame segn sea el caso, y
que implemente unas interfaces definidas en Java, por ejemplo
ActionListener, ItemListener, MouseListener entre otras, stas definen un
comportamiento para el manejo de los eventos producidos por el usuario, los
cuales el programador debe manejarlos para que el usuario tenga la
respuesta esperada.




8.2.1.4.1 Contenedor y Administrador de esquemas en Java

Otro componente importante es el contenedor de la clase Container, el
contenedor va a abarcar todos y cada uno de los componentes que
conforman la GUI, tambin va a definir el orden que tendrn stos en la GUI;
El orden es especificado por el Administrador de esquemas que proporciona
herramientas bsicas de distribucin visual, que son ms fciles de usar que
determinar la posicin y tamao exactos de cada componente de la GUI.
Esta funcionalidad permite al programador concretarse en la vista y sentido
bsicos, y deja que el administrador de esquemas procese la mayora de los
detalles de la distribucin visual. En Java existen cinco (5) posibles
esquemas, vea Tabla 8.2.

Tablaa 8.2. Administradores de esquemas(1/2)
Administrador
de esquemas
Descripcin
FlowLayout
Coloca los componentes secuencialmente (de izquierda a
derecha) en le orden en que se agregaron. Tambin es
posible especificar el orden de los componentes utilizando
el mtodo add de Container, el cual toma un objeto
(componente de la GUI) y una posicin de ndice entero
como argumentos.
BorderLayout
Ordena los componentes en cinco reas: NORTH, SOUTH,
EAST, WEST y CENTER
Fuente: propia






Tablaa 8.2. Administradores de esquemas(2/2)
Administrador
de esquemas
Descripcin
GridLayout Ordena los componentes en filas y columnas, empezando en la
celda superior izquierda de la cuadricula, y procediendo de
izquierda a derecha hasta que la fila est llena. Despus el
proceso contina de izquierda a derecha en la siguiente fila, y as
sucesivamente.
BoxLayout Permite ordenar los componentes de la GUI de izquierda a
derecha, o de arriba hacia abajo, en un contenedor. La clase Box
declara un contenedor con BoxLayout como su administrador de
esquema predeterminado, y proporciona mtodos estticos para
crear un objeto Boxcon un esquema BoxLayout horizontal o
vertical
GridBagLayout Es similar al GridLayout. A diferencia de ste, el tamao de cada
componente puede variar (es decir, pueden ocupar varias filas y
columnas) y pueden agregarse componentes en cualquier orden.
Fuente: propia


De todos los administradores de la Tabla 6.2 el ms usado es el
FlowLayout.

8.2.1.4.2 Eventos y sus manejadores en Java

Evento: es la interaccin del usuario con un componente de la GUI, es
decir, cuando el usuario cliquea a un componente de la GUI; en el instante
que esto suceda, el programa enva un mensaje al applet informando que un
evento ha ocurrido, para que se ejecuten las instrucciones necesarias. En


una interfaz grfica todas las acciones son desencadenadas por eventos, es
lo que indica los deseos del usuario; Este estilo de programacin se conoce
como programacin controlada por eventos.

Los manejadores de eventos son aquellos mtodos invocados al ocurrir
un evento tambin se conocen simplemente como manejadores de evento.

Cuando ocurre un evento en la GUI de un programa, el mecanismo
para manejar eventos crea un objeto que contiene informacin acerca del
evento que acaba de ocurrir, e invoca a un mtodo apropiado para manejar
eventos (declarado en una interfaz del API de Java) en el caso de los
botones el mtodo es actionPerformed, para los radio botones, casillas de
verificacin, entre otros es el itemStateChanged.

A cada componente que se le desee manejar un evento se le tiene que
aadir un oyente (Listener) de eventos, para que cuando el usuario
interacte con ste, se ejecute el mtodo correspondiente a el tipo de oyente
que se le aadi; por ejemplo a los botones en el mtodo init(en el caso del
Applet) despus de crearlos, se le aade el oyente de la siguiente forma:

Boton1 . addActionListener( ) ;

Si fuera a un radio botn, de la siguiente forma:

radioBoton1 . addItemListener ( ) ;

Luego en el applet, para los botones se tiene que redefinir el mtodo
actionPerformed que recibe un objeto de tipo ActionEvent, con toda la


informacin del evento que recin ocurri, y as los mtodos que le
correspondan a cada componente con el oyente aadido;

Es importante resaltar que si a un componente botn de la GUI no se le
aade un oyente de eventos, al usuario interactuara con ste y no se
procesara la accin, es decir el programa no ejecutara ninguna accin.

La interaccin del usuario con la GUI controla el programa, por esta
razn es que se le llama programacin controlada por eventos.

Para el manejo de eventos es necesario que la clase implemente las
interfaces necesarias, para los eventos esperados, para seguir con los
botones, la interfaz a implementar es ActionListener; y como no hay lmites
en las interfaces que una clase puede implementar, en una misma interfaz
grfica se pueden manejar muchos eventos de diferentes tipos.

Ejemplos de los componentes que conforman la interfaz grafica
de usuario en la programacin orientada a objetos.

Se recuerda la clase Fraccion desarrollada en el Captulo 5, en la figura
5.4. Si se quiere probar dicha clase con una GUI, se usar un JApplet, la
interfaz constar de siete (7) campos de texto, siete (7) etiquetas y cinco (5)
botones, ver Figura 8.1.





Figura 8.1. GUI para probar la clase Fraccion
Fuente: propia
El cdigo fuente correspondiente de la GUI de la Figura 8.1. Se puede
observar en la Figura 8.2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java . awt. * ;
import java . awt . event . * ;
import javax . swing . * ;
public class GUI_Fraccion extends JApplet implements ActionListener {
JLabel lfraccion1 , lfraccion2 , lBarra1 , lBarra2, lbarra3 , lResul , lIgual ;
JTextField tNum1 , tDen1 , tNum2 , tDen2 , tNumR , tDenR , tResul ;
JButton bSuma , bResta , bMult , bDiv , bIgual;
Container c;
public void init ( ) {
c = getContentPane ( ) ;
c . setLayout ( new FlowLayout ( ) ) ;
lfraccion1 = new JLabel ( "Fraccin 1 : " ) ;
lfraccion2 = new JLabel ( "Fraccin 2 : " ) ;
lBarra1 = new JLabel ( " / " ) ;
lBarra2 = new JLabel ( " / " ) ;
lbarra3 = new JLabel ( " / " ) ;
lResul = new JLabel ( " Resultado : " ) ;
lIgual = new JLabel ( " = " ) ;
tNum1 = new JTextField ( "" , 3);
tDen1 = new JTextField ( "" , 3);
tNum2 = new JTextField ( "" , 3);
tDen2 = new JTextField ( "" , 3);
tNumR = new JTextField ( "" , 3);
tDenR = new JTextField ( "" , 3);
Figura 8.2. Cdigo fuente de la clase GUI_Fraccion(1/5)
Fuente: propia



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
tResul = new JTextField ( "" , 5);
bSuma = new JButton ( " + " ) ;
bResta = new JButton ( " - " ) ;
bMult = new JButton ( " * " ) ;
bDiv = new JButton ( " / " ) ;
bIgual = new JButton ( " = " ) ;
bSuma . addActionListener ( this ) ;
bResta . addActionListener ( this ) ;
bMult . addActionListener ( this ) ;
bDiv . addActionListener ( this ) ;
bIgual . addActionListener ( this ) ;
c . add ( lfraccion1 ) ;
c . add ( tNum1 ) ;
c . add ( lBarra1 ) ;
c . add ( tDen1 ) ;
c . add ( lfraccion2 ) ;
c . add ( tNum2 ) ;
c . add ( lBarra2 ) ;
c . add ( tDen2 ) ;
c . add ( bSuma ) ;
c . add ( bResta ) ;
c . add ( bMult ) ;
c . add ( bDiv ) ;
c . add ( bIgual ) ;
c . add ( lResul ) ;
c . add ( tNumR ) ;
c . add ( lbarra3 ) ;
c . add ( tDenR ) ;
c . add ( lIgual ) ;
c . add ( tResul ) ;
}
public void paint ( Graphics g ) {
super . paint ( g ) ;
}
public void actionPerformed ( ActionEvent ae ) {
if ( ae . getSource ( ) . equals ( bSuma ) )
Figura 8.2. Cdigo fuente de la clase GUI_Fraccion(2/5)
Fuente: propia



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
sumar ( ) ;
else if ( ae . getSource ( ) . equals ( bResta ) )
restar ( ) ;
else if ( ae . getSource ( ) . equals ( bMult ) )
multiplicar ( ) ;
else if ( ae . getSource ( ) . equals ( bDiv ) )
dividir ( ) ;
else
resultado ( ) ;
}
public boolean isLleno ( ) {
if( ! tNum1 .getText ( ) .equals( " " ) && ! tDenn1 .getText( ) . equals( "" )
&& ! tNum2 . getText( ) . equals( " " ) && ! tDen2 . getText( ) . equals( " " ) )
try { if ( Integer . parseInt ( tDen1 . getText ( ) ) != 0 &&
Integer . parseInt ( tDen2 . getText ( ) ) != 0 )
return true ; }
catch ( Exception ex ) { return false ; }
return false;
}
public void sumar ( ) {
if ( isLleno ( ) ) {
Fraccion a = toma ( tNum1 , tDen1 ) ;
Fraccion b = toma ( tNum2 , tDen2 ) ;
if ( a != null && b != null ) {
Fraccion d = null ;
d = new Fraccion ( 1 , 1 );
d . sumar ( a , b ) ;
String aux ;
aux = String . valueOf ( d . getNumerador ( ) ) ;
tNumR . setText ( aux ) ;
int x = d . getDenominador ( ) ;
aux = String . valueOf ( x ) ;
tDenR . setText ( aux ) ;
tResul . setText ( " " + d . resultado ( ) ) ;
}
}
else
Figura 8.2. Cdigo fuente de la clase GUI_Fraccion(3/5)
Fuente: propia



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
JOptionPane . showMessageDialog ( null , " Error los campos
son obligatorios " ) ;
}
public void resta r( ) {
if ( isLleno ( ) ) {
Fraccion a = toma ( tNum1 , tDen1 ) ;
Fraccion b = toma ( tNum2 , tDen2 ) ;
if ( a != null && b != null ) {
a . restar ( b ) ;
tNumR . setText ( String . valueOf ( a . getNumerador( ))) ;
tDenR . setText ( String . valueOf ( a . getDenominador( ))) ;
tResul . setText ( String . valueOf ( a . resultado ( ) ) ) ;
}
}
else
JOptionPane . showMessageDialog ( null , "Error los campos
son Obligatorios " ) ;
}
public void multiplicar ( ) {
if ( isLleno ( ) ) {
Fraccion a = toma ( tNum1 , tDen1 ) ;
Fraccion b = toma ( tNum2 , tDen2 ) ;
if ( a != null && b != null ) {
a . multiplicar ( b ) ;
tNumR . setText ( String . valueOf ( a . getNumerador( ))) ;
tDenR . setText( String . valueOf ( a . getDenominador())) ;
tResul . setText ( String . valueOf ( a . resultado ( ) ) ) ;
}
}
else
JOptionPane . showMessageDialog ( null , " Error los campos
son obligatorios " ) ;
}
public void dividir ( ) {
if ( isLleno ( ) ) {
Fraccion a = toma ( tNum1 , tDen1 ) ;
Fraccion b = toma ( tNum2 , tDen2 ) ;
if ( a != null && b != null ) {
Figura 8.2. Cdigo fuente de la clase GUI_Fraccion(4/5)
Fuente: propia


136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
Fraccion d ;
d = Fraccion . dividir ( a , b ) ;
tNumR . setText ( String . valueOf( d . getNumerador ())) ;
tDenR . setText ( String . valueOf( d . getDenominador ())) ;
tResul . setText ( String . valueOf ( d . resultado ( ) ) ) ;
}
}
else
JOptionPane . showMessageDialog ( null , " Error los campos
son obligatorios " ) ;
}
public void resultado ( ) {
if( ! tNumR . getText( ) . equals( " " )&& ! tDenR . getText( ) . equals( " " ))
if ( Integer . parseInt ( tDenR . getText ( ) ) != 0 ) {
Fraccion d = toma ( tNumR , tDenR ) ;
tResul . setText ( String . valueOf ( d . resultado ( ) ) ) ;
}
else
JOptionPane . showMessageDialog ( null , " El denominador
no puede ser cero ! " ) ;
}
public Fraccion toma ( JTextField a , JTextField b ) {
int x = 0 , y = 0 ;
try {
x = Integer . parseInt ( a . getText ( ) ) ;
y = Integer . parseInt ( b . getText ( ) ) ;
return new Fraccion ( x , y ) ;
}
catch ( Exception ex ) {
JOptionPane . showMessageDialog ( null , " Error los campos
deben ser nmeros " ) ;
return null ;
}
}
}
Figura 8.2. Cdigo fuente de la clase GUI_Fraccion(5/5)
Fuente: propia





A continuacin la explicacin del cdigo de la Figura 8.2.
En las lneas 1 a 3 se importan todos los paquetes necesarios para
desarrollar el applet, java.awt tiene la clase Container, ButtonGroup,
FlowLayout, el java.awt.event tiene las interfaces ActionListener e
ItemListener, y javax.swing a todas las de los componentes JLabel , JButton ,
JTextField.
En la lnea 4 se declara la clase que hereda de JApplet e implementa la
interface ActionListener, con la palabra reservada implements, para el
manejo de eventos.
Luego en las lneas 5 a la 7 se declaran todos los componentes a usar
en el applet, siete (7) etiquetas, siete (7) campos de texto, y cinco (5)
botones; fjese que los nombres comienzan con una l si son JLabel, con una
t si son JTextField y as para lo dems, para poder identificar de que tipo es
un objeto; en la lnea 8 se declara el contenedor de los componentes con el
identificador c.

En la lnea 9 se encuentra el mtodo init que no retorna ni recibe
ningn valor, ste mtodo es heredado de la clase JApplet, y se ejecuta
cuando se carga la pagina web contenedora del applet, as que aqu se crea
el contenedor y todos los componentes de la GUI. Como se observa en la
lnea 10, se le asigna al contenedor lo que retorna el mtodo
getContentPane( ), que se hereda de la clase JApplet y devuelve una
referencia al objeto del panel de contenido del applet. El programa utiliza
esta referencia para adjuntar los componentes de la GUI, a la interfaz de
usuario del applet.

Luego en la lnea 11 se especifica el administrador de esquema para la
interfaz de usuario del applet, con el mtodo setLayout ( ) de la clase
Container, envindole como parmetro un objeto de tipo FlowLayout ver


Tabla 8.2. De la lnea 12 a la 30 se crean todos los componentes a utilizar en
el ejercicio, fjese que el constructor usado para los JLabel reciben la cadena
a mostrar, y el usado para los JTextField recibe la cadena inicial y el nmero
de caracteres que se mostrar, mientras para los JButton recibe la cadena a
mostrar. Es importante mencionar que la clases de los componentes la gran
mayora tienen sobrecargados los constructores de las mismas.

En las lneas 31 a 35, se le aade a los botones un ActionListener, con
el mtodo addActionListener , indicando que para stos, va a existir un
oyente de eventos, o se va a escuchar los eventos producidos por el botn,
para el manejo de eventos.

En la lnea 36 del mtodo init, se comienzan a adjuntar los
componentes al panel de contenido del applet, como el administrador de
esquemas es FlowLayout, se deben aadir en el orden que se desea que
aparezcan en la GUI, como en la Figura 6.1 se observa que lo primero que
esta de izquierda a derecha es le etiqueta de Fraccin 1:, seguido del
campo de texto para el numerador de la primera fraccin, entonces esa
etiqueta lfraccion1es la primera que se adjuntar al panel, seguida del
campo de texto tNum1; y as sucesivamente con todos los componentes de
la GUI.

En las lneas de 56 a 58, se encuentra el mtodo paint, que es
heredado de la clase JApplet, que recibe un Objeto Graphics, este mtodo es
usado para dibujar en el applet, tambin se puede escribir cadenas en una
determinada posicin. En este caso particular se llama al mtodo paint de
la superclase, esto es para actualizar el panel.



En las lneas 59 a la 70, est el mtodo manejador de eventos, el
actionPerformed, que recibe un objeto ActionEvent con toda la informacin
del evento que acaba de ocurrir, como en este applet hay cinco (5) botones
con oyente de eventos, entonces se debe verificar con cual fue que el
usuario interacto, para esto se usa el mtodo getSource ( ), para saber la
fuente de donde proviene el evento, con el mtodo equals de la clase Object,
y as se compara con cual de los cinco (5) botones es el origen del evento.
Para cada uno se crea un mtodo en la clase PruebaFraccion, que gestione
las acciones correspondientes con la eleccin del usuario; en las lneas 80 a
157.

En las lneas 71 a 79, se encuentra el mtodo isLleno ( ), que no
recibe parmetros pero retorna un valor de tipo boolean; ste mtodo es para
verificar que todos los campos de texto tengan algo escrito, y validar que no
se trate de hacer operaciones con fracciones vacas, es decir, /4 y tambin
que los denominadores sean diferentes de cero; en la lnea 74, esta un
bloque try que se utiliza para manejar excepciones; por ejemplo que el
usuario escriba un carcter alfabtico o especial donde debe ir un nmero,
entonces cuando el cdigo intente traducir esa cadena a entero (con el
mtodo de clase parseInt perteneciente a la clase Integer, que recibe un
objeto tipo String y devuelve un dato int) se lanzar una excepcin, para
manejarla y mostrarle al usuario su error, se utilizan los bloques try y catch.
El bloque catch recibe un objeto perteneciente a la jerarqua de herencia de
las Excepciones, donde la superclase es Exception y se encuentra en el
paquete java.lang, que es importado en todas las clases por defecto. El
mtodo getText devuelve el texto de un campo de texto (casi todos los
componentes de la GUI lo tienen).



En las lneas de la 80 a 157, estn los mtodos invocados en el mtodo
actionPerformed, stos no devuelven ningn valor, ni reciben parmetros;
en la lnea 80 esta definido el primero de ellos el mtodo sumar, donde se
manda a ejecutar el mtodo isLleno, y depende del valor devuelto por ste,
se suman las dos fracciones o se muestra un mensaje al usuario dicindole
que todos los campos son obligatorios (lnea 98); en el caso que el valor
devuelto sea verdadero, entonces se declaran dos objetos tipo Fraccin a y
b, y se le asigna una fraccin que devuelve el mtodo toma, que recibe dos
objetos tipo JTextField y los convierte en un objeto de tipo Fracion y lo
retorna (Lnea 158); luego se verifica que han sido creados, es decir, que sea
diferente de null, si han sido creados, entonces se declara y crea un objeto
d tipo Fraccion con valores arbitrarios de 1/1(lnea 86), para luego mandar
un mensaje al mtodo sumar envindole las dos Fracciones que ingreso el
usuario (lnea 87), ahora se necesita mostrar el resultado de la suma que
esta almacenado en el objeto d, en los campos de texto tNumR para el
numerador (lnea 90), tDenR para el denominador (lnea 93) y tResul para el
resultado en nmeros reales(lnea 94); el mtodo setText recibe un String y
lo fija en el texto que se muestra en un JTextField, para convertir un int a
String, se usa el mtodo de clase valueOf de la clase String, este mtodo
est sobrecargado y el valor que reciba lo convierte a String y lo
devuelve(Lnea 92), en la lnea 89 se puede observar que el int que
representa el numerador de la Fraccion d, se convierta en String y se le
asigna a una variable aux de tipo String, para luego fijarlo como el texto del
JTextField tNumR; fjese que para mostrar el denominador de esta
Fraccion se hace paso a paso, primero se guarda el valor en una variable x
de tipo int, luego se convierte a String y se asigna a la variable aux, y por
ultimo se asigna al texto del objeto tDenR; en la lnea 94 se realiza de otra
forma, se concatena una cadena vaca con el float que retorna el mtodo
resultado de la clase Fraccion, porque en Java cuando se usa un String y el


operador + el valor que preceda a este operador es convertido
implcitamente a String; en este mtodo se presento tres formas diferentes
de convertir un valor numrico a un String.

En la lnea 101 se encuentra el mtodo resta, al igual que el mtodo
anterior(mtodo sumar), primero se verifica que los campos de texto no
estn vacios (lnea 102), con el mtodo isLleno, en el caso de estar todo
como se espera, se enva un mensaje al mtodo restar de la clase Fraccion
(lnea 106), que reste de la Fraccion a, la Fraccion b, y el resultado es
almacenado en el objeto que invoca el mtodo, es decir, el objeto a, para
mostrar el resultado en los campos de texto tNumR, tDenR y tResul se
hace de una forma directa (lneas 107, 108 y 109).

En la lnea 116, esta el mtodo multiplicar, muy parecido al mtodo
restar, pero el mtodo de la clase fraccin invocado es multiplicar, de todo
lo dems es muy parecido.

En la lnea 131, se encuentra el mtodo dividir, ste es parecido al
mtodo sumar de la lnea 80, porque el mtodo dividir de la clase Fraccion
devuelve un objeto Fraccion y es un mtodo de clase, por lo tanto no es
necesario que se invoque con un objeto de ese tipo, sino con el nombre de la
clase (lnea 137).

En la lnea 147, sta el mtodo resultado, este mtodo ser ejecutado
cuando se escriba una Fraccion en los campos de texto para la Fraccion
resultante estos son tNumR y tDenR, y el usuario presione el botn
bIgual; lo primero que se hace en ste mtodo es verificar que esos
campos de texto no estn vacios (lnea 148), y el denominador sea distintito
de cero (lnea 149), luego se declara el objeto Fraccion y se le asigna la


Fraccion devuelta por el mtodo toma, y el resultado se muestra en el
JTextField tResul.

Y por ultimo pero no menos importante se encuentra el mtodo toma,
que recibe dos objetos tipo JTextField a y b; y devuelve un objeto tipo
Fraccion conformado por el numerador y denominador de los valores que se
encuentren en los campos de texto que recibe, eso en el caso de que el
usuario haya escrito en los campos de texto valores numricos, porque si no
muestra un mensaje de error y devuelve un valor nulo.

Y con esto termina el anlisis del cdigo fuente de la clase
GUI_fraccion.

Resolucin de problemas usando interfaz grfica y manejo de
eventos en programacin orientada a objetos.

Realice las clases necesarias para la siguiente jerarqua de
herencia: medios de comunicacin, televisoras y emisoras
radiales. Por cada medio de comunicacin se manejan un
nombre; las televisoras tienen una seal (nmero de canal),
estn ubicadas en un pas; las emisoras de radio se
encuentran en una regin y se pueden sintonizar por una
frecuencia. Las operaciones que Ud. desarrollar, son las
siguientes:

o Obtener el total de canales que se hayan creado en
Venezuela.


o Obtener en cualquier momento el nombre de la emisora
que tenga la frecuencia mas baja.

Disee y desarrolle una GUI usando JApplet(con una interfaz agradable
y de fcil manejo), para probar las clases de la mencionada jerarqua.




CAPTULO IX: INTRODUCCIN A ALGORITMOS
RECURSIVOS

9.1 Objetivos

Definir que es recursin, segn una discusin en clases.
Identificar los tipos de problemas que se pueden resolver
mediante el uso de la recursin, usando programacin orientada
a objetos.
Diferenciar funciones recursivas con funciones iterativas,
partiendo de las ventajas y desventajas de cada una.
Reconocer algoritmos resueltos usando funciones recursivas en
programacin orientados a objetos.

9.2 Contenido

Definicin de recursividad.
Tipos de problemas que pueden resolverse usando recursividad
en programacin orientada a objetos.
Comparacin de una funcin recursiva con respecto a una
funcin iterativa segn las ventajas y desventajas de cada
funcin.
Problemas resueltos con algoritmos en programacin orientada a
objetos usando funciones recursivas.




9.2.1 Definicin de recursividad

La recursividad es aquella propiedad que posee un mtodo por la cual
puede llamarse a s mismo.

La recursin es un proceso extremadamente potente, pero consume
muchos recursos, De este anlisis se deducir que aunque un problema por
definicin sea recursivo, no siempre ser el mtodo de solucin ms
adecuado.

Antes de poner en marcha un proceso recursivo es necesario demostrar
que el nivel mximo de recursin, esto es, el nmero de veces que se va a
llamar a s mismo, es no slo finito, sino realmente pequeo. La razn es que
se necesita cierta cantidad de memoria para almacenar el estado del proceso
cada vez que se abandona temporalmente, debido a una llamada para
ejecutar otro proceso que es l mismo. El estado del proceso de clculo en
curso hay que almacenarlo para recuperarlo cuando se acabe la nueva
ejecucin del proceso y haya que reanudar la antigua.

En el diseo recursivo siempre se debe avanzar hacia un caso base.
Las llamadas recursivas simplifican el problema y, en ltima instancia, los
casos base nos sirven para obtener la solucin. Los casos base
corresponden a situaciones que se pueden resolver con facilidad, mientras
los dems casos se resuelven recurriendo, antes o despus, a alguno(s) de
los casos base.

Un mtodo recursivo es un mtodo que se invoca a s mismo de forma
directa o indirecta. En recursin directa, el cdigo de un mtodo f ( ) contiene
una sentencia que invoca al mtodo f ( ), mientras que en recursin indirecta,


el mtodo f ( ) invoca a un mtodo g ( ) que a su vez invoca al mtodo p ( ), y
as sucesivamente hasta que se invoca de nuevo al mtodo f ( ).
Un requisito para que un algoritmo recursivo sea correcto es que no
genere una secuencia infinita de llamadas sobre s mismo. Cualquier
algoritmo que genere una secuencia de este tipo no puede terminar nunca,
es decir se hace infinitas veces. En consecuencia la definicin recursiva debe
incluir una condicin de salida, que se denomina caso base, en el que f (n)
se defina directamente (es decir no recursivamente) para uno o ms valores
de n.
En definitiva, debe existir una forma de salir de la secuencia de
llamadas recursivas.

9.2.2 Tipos de problemas que pueden resolverse usando recursividad
en programacin orientada a objetos.

Una de las tcnicas ms importantes para la resolucin de muchos
problemas de computadora es la denominada divide y vencers. El diseo
de algoritmos basados en esta tcnica consiste en transformar (dividir) un
problema de tamao n en problemas ms pequeos, de tamao menor que
n, pero similares al problema original, de modo que resolviendo los
subproblemas y combinando las soluciones se pueda construir fcilmente
una solucin del problema completo (vencers).

Normalmente, el proceso de divisin de un problema en otros de
tamao menor va a dar lugar a que se llegue al caso base, cuya solucin es
inmediata. A partir de la obtencin de la solucin del problema para el caso
base, se combinan soluciones que amplan el tamao del problema resuelto,
hasta que el problema original queda tambin resuelto.



Un algoritmo divide y vencers se define de manera recursiva, de tal
modo que se llama a s mismo sobre un conjunto menor de elementos.
Normalmente, se implementa con dos llamadas recursivas, cada una con un
tamao menor. Se alcanza el caso base cuando el problema se resuelve
directamente.

Problemas clsicos resueltos mediante recursividad son la Torres de
Hanoi, el mtodo de bsqueda binaria, la ordenacin rpida, la ordenacin
por mezclas, entre otras.

Se va a explicar el algoritmo de las torres de Hanoi, los dems quedan
para su investigacin.
Este juego (un algoritmo clsico como se menciono) tiene sus orgenes
en la cultura oriental y en una leyenda sobre el Templo de Brahma, cuya
estructura simulaba una plataforma metlica con tres varillas y discos en su
interior. El problema en cuestin supona la existencia de 3 varillas (A, B y C)
o postes en los que se alojaban discos (n discos) que se podan trasladar de
una varilla a otra libremente, pero con las siguientes condiciones:

Slo se puede mover un disco a la vez.
No se puede poner un disco encima de otro ms pequeo.
Despus de un movimiento todos los discos han de estar en
alguno de las tres varillas.

En la Figura 9.1, se ilustra el problema con tres varillas con cuatro
discos en la varilla A, y se desea trasladar a la varilla C conservando la


condicin de que cada disco sea ligeramente inferior en dimetro al que tiene
situado debajo de l.




Figura 9.1. Ilustracin de las Torres de Hanoi
Fuente: propia


Diseo del algoritmo:

Las varillas se nombrarn: varilla Inicial, varilla Central y varilla Final.
En la varilla Inicial se sitan n discos que se apilan en orden
decreciente de tamao con el mayor en la parte inferior. El objetivo del juego
es mover los n discos desde la varilla Inicial a la varilla Final. Los discos se
mueven uno a uno respetando las reglas mencionadas anteriormente. El
mtodo tHanoi( ) declara las varillas como datos de tipo char. En la lista de
parmetros, el orden de las variables es:

varIni, varCent, varFinal

e implica que se estn moviendo discos desde la varIni a la final utilizando la
varCent como auxiliar para almacenar los discos. Si n = 1 se tiene el caso
base, se resuelve directamente moviendo el nico disco desde la varilla
inicial a la varFinal. El algoritmo es el siguiente:






Si n = 1, entonces
- Mover disco 1 de varIni a varFinal, para
n = 1
tHanoi(varIni, varCentral, varFinal, n)=
sino
- Mover n-1discos desde varIni a varCent
utilizando varFinal como auxiliar
- Mover el disco n desde varIni a varFinal.
- Mover n 1 discos desde varCent a
varFinal utilizando como auxiliar varIni.



Es decir, si n es 1, se alcanza el caso base, la condicin de salida o
terminacin del algoritmo. Si n es mayor que 1, las etapas recursivas son tres
sub-problemas ms pequeos, uno de los cuales es la condicin de salida.
Observe la Figura 8.2.











Figura 9.2. Representacin grfica de la solucin del mtodo tHanoi.
Fuente: propia


9.2.3 Comparacin de una funcin recursiva con respecto a una
funcin iterativa segn las ventajas y desventajas de cada
funcin.

Tanto la iteracin como la recursin se basan en una estructura de
control: la iteracin utiliza una estructura repetitiva y la rechijaaaahhursin
utiliza una estructura de seleccin. Tanto la iteracin como la recursin
implican repeticin: la iteracin utiliza explcitamente una estructura repetitiva
mientras que la recursin consigue la repeticin mediante llamadas repetidas
al mtodo. La iteracin y la Recursin implican cada una un test de
terminacin (condicin de parada). La iteracin termina cuando la condicin
del bucle no se cumple, mientras que la recursin termina cuando se
reconoce un caso base o se alcanza la condicin de parada.

La recursin tiene muchas desventajas. Se invoca repetidamente al
mecanismo de llamadas a mtodos y, en consecuencia, se necesita un
tiempo suplementario para realizar cada llamada.

Esta caracterstica puede resultar costosa en tiempo de procesador y
espacio de memoria. Cada llamada recursiva produce una nueva creacin y
copia de las variables de la funcin, esto consume ms memoria e
incrementa el tiempo de ejecucin. Por el contrario, la iteracin se produce
dentro de un mtodo, de modo que las operaciones suplementarias en la
llamada al mtodo y en la asignacin de memoria adicional son omitidas.

Entonces cules son las razones para elegir la recursin? La razn
fundamental es que existen numerosos problemas complejos que poseen
naturaleza recursiva y, en consecuencia, son ms fciles de implementar con
algoritmos de este tipo. Sin embargo, en condiciones crticas de tiempo y de


memoria; es decir, cuando el consumo de tiempo y memoria sean decisivos o
concluyentes para la resolucin del problema, la solucin a elegir debe ser,
normalmente, la iterativa.

Cualquier problema que se puede resolver recursivamente tiene, al
menos, una solucin iterativa. Un enfoque recursivo se elige, normalmente,
con preferencia a un enfoque iterativo cuando resulta ms natural para la
resolucin del problema y produce un programa ms fcil de comprender y
de depurar. Otra razn para elegir una solucin recursiva es que una
solucin iterativa puede no ser clara ni evidente.

Criterios en la toma de decisin iteracin/recursin

1. Considrese una solucin recursiva slo cuando una solucin
iterativa sencilla no sea posible.
2. Utilcese una solucin recursiva slo cuando la ejecucin y eficiente
de la memoria de la solucin est dentro de lmites aceptables, considerando
las limitaciones del sistema.
3. Si son posibles las dos soluciones, iterativa y recursiva, la solucin
recursiva siempre requerir ms tiempo y espacio debido a las llamadas
adicionales a los mtodos.
4. En ciertos problemas, la recursin conduce a soluciones que son
mucho ms fciles de leer y de comprender que su alternativa iterativa. En
estos casos, los beneficios obtenidos con claridad de la solucin suelen
compensar el coste extra (en tiempo y memoria) de la ejecucin de un
programa recursivo.



9.2.4 Problemas resueltos con algoritmos en programacin orientada a
objetos usando funciones recursivas.

Ejemplo de un mtodo recursivo. Supngase el mtodo m1(),
entonces
m (){

m ();

}
Ahora se estudiara un ejercicio recursivo para una funcin matemtica
que sume los n primeros nmeros enteros positivos.

Se puede definir que para n = 1 entonces la suma es s(1) = 1, y para n
=2, s( 2 ) = s( 1 ) + 2; en general y aplicando la induccin matemticas, se
tiene:

s( n ) = s(n-1)+n
El algoritmo debe tener en cuenta el caso base,

1 si n = 1
s(n) =
s(n-1) si n>1


A continuacin en la Figura 9.3 se puede observar el cdigo fuente del
mtodo s(n):








Figura 9.3. Cdigo fuente del mtodo s.
Fuente: propia

En la lnea 2, est el caso base, que garantiza que el mtodo tiene su
punto de ruptura, es decir, va a dejar de hacer la recursividad, y en la lnea 4
se verifica que n sea positivo, y en la lnea 5 con la instruccin: s ( n 1 ),
donde se garantiza que n va a llegar a ser uno (1).

Para la ejecucin del mtodo s. obsrvese la Tabla 9.1., para n igual
a 4.

Tabla 9.1. Ejemplo de ejecucin del mtodo s ( n ), para n = 4.
Nmero de
iteracin
Proceso de ida N s(n) Proceso de vuelta
10
1 s(4) 4 4+s(3) 4+6
2 s(3) 3 3+s(2) 3+3
3 s(2) 2 2+s(1) 2+1
4 s(1) 1 1
Fuente: propia

La forma correcta de ver la Tabla 9.1, es el proceso de ida porque
corresponde a la llamada del mtodo, y fjese lo que debe retornar el mtodo
el valor de n sumado a lo que devuelva el mtodo s(n-1), entonces se ejecuta
1
2
3
4
5
6
public int s ( int n ) {
if ( n == 1 )
return 1;
else if ( n > 1 )
return n + s ( n - 1) ;
}


ste ( s(n-1) ), pasa a otra iteracin, as hasta que se ejecute el mtodo s(1)
que devuelve el valor de 1, pero este valor es retornado a donde se hizo la
llamada del mtodo con n=1, es decir, a la iteracin 3, se suma el valor de n
de esa iteracin (2), y as se va regresando hasta llegar a la iteracin 1, y
devuelve el valor de 10 a donde invocaron la primera vez a ste mtodo.

Otro ejercicio es calcular el factorial de un nmero x, recordando que el
factorial de x (x!) es: x!= x*(x-1)*(x-2)**2*1. Entonces

1 si x=1
factorial (x) =
factorial(x-1) si x>1


El cdigo puede verse en la Figura 9.4.

Este ejercicio es muy parecido al anterior lo nico es que en ste se
multiplica, mientras que en el de la Figura 9.1 la operacin aritmtica que se
realiza es la suma.






Figura 9.4. Cdigo fuente del mtodo factorial
Fuente: propia
1
2
3
4
5
6
public int factorial ( int x ) {
if ( x == 1 )
return 1;
else if ( x > 1 )
return x * factorial ( n - 1) ;
}


Todos los ejercicios que se deseen resolver usando recursividad, se
debe estudiar el caso base, y los dems casos para acertar en la llamada(s)
al mismo mtodo.

Por ejemplo para definir la naturaleza recursiva de la serie fibonacci: 0,
1, 1, 2, 3, 5, 8, 13, 21,..

En esta serie que comienza con 0 y 1, y tiene la propiedad de que cada
elemento es la suma de los dos elementos anteriores. Entonces se puede
establecer que:

fibonacci(0) = 0
fibonacci(1) = 1

fibonacci(n) = fibonacci (n 1) + fibonacci(n 2)
Y la definicin recursiva ser:


n si n = 0 n = 1

fibonacci(n) =
fibonacci(n - 1) + fibonacci(n 2) si n > 1


En la Figura 9.5. Se puede observar el cdigo del mtodo fibonacci ( n).










Figura 9.5. Cdigo fuente del mtodo fibonacci.
Fuente: propia


1
2
3
4
5
6
public int fibonacci ( int n ) {
if ( n == 0 || n == 1 )
return n;
else if ( n > 1 )
return fibonacci (n 1) + fibonacci ( n 2) ;
}



CAPTULO X: INTRODUCCIN A LAS ESTRUCTURAS DE
DATOS FUNDAMENTALES.

10.1 Objetivos
Definir una estructura de datos.
Definir funciones propias de las estructuras de datos
fundamentales.
Resolver un problema usando estructuras de datos
fundamentales.

10.2 Contenido
Definicin de las estructuras de datos fundamentales
Definicin de la Funciones propias de las estructuras de datos
fundamentales
Resolucin de problemas usando estructuras de datos
fundamentales

10.2.1 Definicin de las estructuras de datos fundamentales.

10.2.1.1 Estructuras de datos

Segn Luis Joyanes en Estructuras de datos. Ao 2008.
Una estructura de datos es cualquier representacin de datos y sus
operaciones asociadas. Bajo esta ptica, cualquier representacin de datos,
incluso un nmero entero o un nmero de coma flotante almacenado en la
computadora, es una sencilla estructura de datos. Es un sentido ms
especfico, una estructura de datos es una organizacin o estructuracin de


una coleccin de elementos dato. As, una lista ordenada de enteros
almacenados en un arreglo es un ejemplo de dicha estructuracin.

Una estructura de datos es una agregacin de tipos de datos
compuestos y atmicos en un conjunto con relaciones bien definidas. Una
estructura significa un conjunto de reglas que contienen los datos juntos.

Las estructuras de datos pueden estar anidadas: se puede tener una
estructura de datos que conste de otras.

Una estructura de datos es un conjunto de variables de un(os)
determinado(s) tipo(s) agrupadas y organizadas de alguna manera para
representar un comportamiento. Lo que se pretende con las estructuras de
datos es facilitar un esquema lgico para manipular los datos en funcin del
problema que haya que tratar y el algoritmo para resolverlo. En algunos
casos la dificultad para resolver un problema radica en escoger la estructura
de datos adecuada. Y, en general, la eleccin del algoritmo y de las
estructuras de datos que manipular estar muy relacionada.

Segn su comportamiento durante la ejecucin del programa
distinguimos estructuras de datos:

Estticas: su tamao en memoria es fijo durante la ejecucin del
programa. Ejemplo: array.
Dinmicas: su tamao en memoria es variable durante la ejecucin del
programa. Ejemplo: pilas, colas, listas enlazadas con punteros,
ficheros, etc.



Las estructuras de datos que se tratarn son las pilas y las listas; en el
Captulo 6 se estudiaron los arrays; y en las asignaturas posteriores se
ahondara en el tema.

En los arreglos se debe conocer la cantidad de elementos que lo
conformarn, antes de su creacin, porque es una estructura de datos
esttica, y son almacenados en posiciones secuenciales de memoria;
mientras las estructuras que se estudiarn en esta unidad la cantidad de
elementos que tendrn se definir en la ejecucin, se puede aadir y eliminar
elementos, y con esto aumenta o disminuye la cantidad de elementos en la
estructura, y los elementos no son almacenados en posiciones secuenciales
de memoria.

A continuacin las definiciones de pilas y listas.

10.2.1.2 Pilas

Una pila es una estructura de datos en la cual solo se pueden hacer dos
operaciones: colocar un elemento al final, o quitar un elemento del final. Lo
nico que se puede hacer en una pila es colocar un objeto hasta arriba, o
quitar el objeto que est arriba; es como una pila de platos que se toma el
ultimo que se coloco, ya que si se quita uno de abajo o del centro (lo mismo
que si se intenta aadir uno), la pila colapsara.
Una pila es una estructura dinmica tipo LIFO ( last in-firts out, ultimo en
entrar- primero en salir). Ver Figura 10.1.



N
odo 1
N
odo 2
N
odo 3
N
odo 4
Figura 10.1. Ilustracin de una pila (de platos).
Fuente: propia

De la Figura 10.1, se puede observar que para retirar un plato debe ser
el Nodo 4, luego el Nodo 3, y as hasta llegar a retirar el primer plato que
se ingreso a la pila, es decir, el Nodo 1.

10.2.1.3 Colas

Cola es una estructura que Una cola es una estructura de datos que
almacena elementos en una lista y permite acceder a los datos por uno de
los dos extremos de la lista, al igual que las pilas, almacena y recupera sus
elementos atendiendo a un orden estricto. Un elemento se inserta en la cola
(parte final) de la lista y se suprime o elimina por el frente (parte inicial,
frente) de la lista. Las aplicaciones utilizan una cola para almacenar
elementos en su orden de aparicin.

Las colas se conocen como estructuras FIFO (firts-in, firts-out, primero
en entrar-primero en salir).

Un ejemplo es una fila para pagar en un supermercado, el cajero
atiende primero a la persona que se encuentra al frente de la cola, mientras
los dems clientes entran a la cola por la parte final de la misma. Ver Figura
10.2.








Figura 10.2. Ilustracin de una cola (de supermercado)
Fuente: propia

10.2.1.4 Listas

Una lista enlazada es una coleccin lineal de objetos de una clase
autorreferenciada, conocidos como nodos, que estn conectados por enlaces
de referencia, es por ello que se utiliza el trmino lista enlazada, estos
nodos se componen de dos partes: la primera contiene la informacin y es,
por consiguiente, un valor de un tipo genrico (denominado Dato,
TipoElemento, Info, etc), y la segunda es una referencia o enlace que
apunta al siguiente elemento de la lista, llamado a menudo siguiente o ste.
Ver Figura 10.3.

Figura 10.3. Ilustracin de una lista enlazada.
Fuente: propia

En la Figura 10.3, se puede ver que cada Nodo esta conformado por las
dos partes descritas anteriormente.
Caja
Cajero Primero.
Al frente
Ultimo
Parte final
Nodo
1
s
te
Nodo
2
s
te
Nodo
3
s
te
Primera
parte
Segunda
parte



Clasificacin de las listas enlazadas:
Listas simplemente enlazadas: Cada nodo contiene un nico enlace
que lo conecta al nodo siguiente.
Listas doblemente enlazadas: Cada nodo contiene dos enlaces, uno a
su nodo predecesor y otro a su nodo sucesor.
Lista circular simplemente enlazada: Una lista simplemente enlazada
en la que el ltimo nodo se enlaza al primero, de modo que queda
como un anillo.
Lista circular doblemente enlazada: Una lista doblemente enlazada
donde el ltimo nodo se enlaza al primero, y ste se enlaza al ltimo.

En esta asignatura se estudiarn las dos primeras.

10.2.2 Definicin de la Funciones propias de las estructuras de datos
fundamentales.

Para los ejemplos aqu ilustrados, los nodos o elementos que
conforman las estructuras de datos (pilas, colas, y listas) estarn compuestos
por la referencia al siguiente tambin va a contener un dato, este dato ser
de tipo entero, aunque puede ser de cualquier tipo, primitivo (char, boolean,
byte, int, short, long, float, double), o referenciado (String, arreglos, objetos
de clases propias desarrolladas con anterioridad).





10.2.2.1 Clases autorreferenciadas

Estas clases son una clase referenciada que contiene una variable de
instancia que hace referencia a otro objeto del mismo tipo de clase. Por
ejemplo.
class A{
//atributos
A objeto1;

}
10.2.2.2 Funciones propias de las estructuras de datos fundamentales

Las funciones propias de las estructuras de datos, son las operaciones
que sirven para definir y manipular su contenido, aunque no todas se
implementan al definir una estructura de datos.

Funciones de una pila
A continuacin en la Tabla 10.1. Ee puede observar las funciones
propias de una Pila
Tabla 10.1. Funciones de una Pila
Funcin Descripcin
Crear pila Inicia (constructor)
Insertar elemento (push) Aade un nodo en la pila
Retirar elemento (pop) Retira un nodo de la pila
Pila vaca Comprueba si la pila no tiene elementos
Limpiar pila Borra todos los elementos, y deja la pila vaca
Cima pila Obtiene el elemento cima o tope de la pila
Tamao de la pila Nmero de elementos que contiene la pila.
Fuente: propia


Entonces se debe definir una clase llamada NodoPila, con los datos, y
la referencia al siguiente. Observe Figura 10.4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class NodoPila {
//atributos necesarios, para este ejemplo un entero
private int dato ;
private NodoPila ste ;
public NodoPila ( int d ) {
dato = d ;
//porque por ahora no hay un siguiente.
ste = null ;
}
public void setDato ( int d ) {
dato = d ;
}
public int getDato ( ) {
return dato ;
}
public void setSte ( NodoPila n ) {
ste = n ;
}
public NodoPila getSte(){
return ste ;
}
}
Figura 10.4. Cdigo fuente de la clase NodoPila
Fuente: propia

De la Figura 10.4. Fjese que es una clase con dos atributos uno tipo
int, y el otro del mismo tipo de la clase (Nodopila), es decir, esta clase es
autorreferenciada. Con su constructor, donde se le asigna un valor al
atributo entero, y se le asigna null a el objeto ste; y los mtodos set y get
para manipular los atributos desde fuera de esta clase.



Tambin se debe definir la clase Pila, donde estar el tope de la pila,
con las operaciones que se le puedan aplicar. Ver la Figura 10.5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Pila {
private NodoPila tope ;
//crear pila
public Pila ( ) {
tope = null ; }
public String push ( NodoPila n ) {
if ( pilaVacia ( ) ) {
tope = n ;
return " El nodo " + tope . getDato ( ) + " es el primero " ;
}
else {
n . setSte ( tope ) ;
tope = n ;
return "Ahora el nodo " +tope.getDato( )+" es el primero " ;
}
}
public NodoPila pop ( ) {
if ( ! pilaVacia ( ) ) {
NodoPila x = new NodoPila ( tope . getDato ( ) ) ;
tope = tope . getSte ( ) ;
return x ;
}
return null ;
}
public boolean pilaVacia ( ) {
if ( tope == null )
return true ;
return false ;
}
public void limpiarPila ( ) {
tope = null ;
}
Figura 10.5. Cdigo fuente de la clase Pila (1/2)
Fuente: propia



33
34
35
36
37
38
39
40
41
42
43
44
45
public NodoPila cimaPila ( ) {
return tope ;
}
public int tamanoPila ( ) {
NodoPila nodo = tope ;
int cont = 1 ;
while ( nodo . getSte ( ) != null ){
cont ++ ;
nodo = nodo . getSte ( ) ;
}
return cont ;
}
}
Figura 10.5. Cdigo fuente de la clase Pila (2/2)
Fuente: propia

Observe que en la Figura 10.5. Slo se declara un atributo, un objeto de
la clase NodoPila (Figura 9.4), con el nombre de tope, porque va a indicar el
tope de la pila, que slo se modificara en dos de los mtodos, el push (Lnea
6) y pop (Lnea 17).

En la lnea 4, esta ubicado el constructor de la clase, que no recibe
ningn valor y coloca el tope en null.

Luego todas las funciones definidas anteriormente; en la lnea 6 esta el
mtodo push, para ingresar un nuevo nodo a la pila (el n que recibe), en el
se verifica que la pila no este vaca, si lo esta, el nuevo nodo es el tope; y si
la pila no esta vaca, entonces se dice que el tope es el siguiente del nuevo
nodo y este ultimo pasa a ser el tope.

En la lnea 17, el mtodo pop ( ), que saca el ultimo nodo insertado en
la pila, para esto se verifica que la pila tenga al menos un elemento, es decir,


no este vaca; se guarda el tope en una objeto auxiliar x para luego asignar
el nuevo tope como el nodo que le segua a ste, y se devuelve el antiguo
tope. En el caso que la pila este vaca se devuelve una referencia nula (null).

En la lnea 25, esta el mtodo pilaVacia, que verifica como su nombre
lo indica el estado de la pila en cuanto a elementos se refiere. En la lnea 30,
el mtodo limpiarPila, hace lo que su nombre describe, coloca el tope de la
pila en null. As en la lnea 33, el mtodo cimaPila, devuelve el tope de la
pila.

Luego como ultimo mtodo de la clase se encuentra tamanoPila ( ),
donde se cuenta cuantos elementos tiene la pila, con la ayuda del objeto
nodo de tipo NodoPila, y se retorna.

Funciones de una cola
En la Tabla 10.2. Se describen las funciones propias para una Cola.

Tabla10.2. Funciones propia de una Cola
Funcin Descripcin
Crear cola Inicia la cola como vaca (constructor)
Insertar Aade un elemento por el final de la cola
Retirar Retira (extrae) el elemento frente de la cola
Cola vaca Comprueba si la cola no tiene elementos
Frente Obtiene el elemento frente o primero de la cola
Tamao de la cola Nmero de elementos que contiene la cola.
Fuente: propia

Para definir una cola, se desarrollara una clase ElementoCola, para
luego desarrollar la clase Cola con las funciones descritas anteriormente.


Observe la Figura 10.6. Que se encuentra el cdigo fuente de la clase
ElementoCola.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ElementoCola {
private int dato ;
prvate ElementoCola ste ;
public ElementoCola ( int d ) {
dato = d ;
ste = null ;
}
public void setDato ( int d ) {
dato = d ;
}
public void setSte ( ElementoCola e ) {
ste = e ;
}
public int getDato( ){
return dato ;
}
public ElementoCola getSte ( ){
return ste ;
}
}
Figura 10.6. Cdigo fuente de la clase ElementoCola
Fuente: propia

Como se puede apreciar en la Figura 10.6. La clase ElementoCola es
similar a la clase NodoPila, con un atributo int, y una referencia a un objeto
del mismo tipo de la clase (ElementoCola), con el constructor, y los mtodos
para poder manipular los atributos desde fuera de esta clase.

A continuacin el cdigo correspondiente a la clase Cola. Ver Figura
10.7.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Cola {
private ElementoCola frente , fin ;
public Cola ( ) {
frente = null ;
fin = null ;
}
public void insertar ( ElementoCola nuevo ) {
if ( colaVacia ( ) ) {
frente = nuevo ;
fin = nuevo ;
}
else {
fin . setSte ( new ElementoCola ( nuevo . getDato ( ) ) ) ;
fin = fin . getSte ( ) ;
}
}
public ElementoCola retirar ( ) {
if ( colaVacia( ) )
return null ;
else {
ElementoCola x = new ElementoCola( frente. getDato( ) ) ;
frente = frente . getSte ( ) ;
return x ;
}
}
public boolean colaVacia ( ) {
if ( frente == null )
return true;
return false;
}
public ElementoCola Frente ( ) {
if ( colaVacia ( ) )
return null ;
return frente ;
}
Figura 10.7. Cdigo fuente de la clase Cola (1/2)
Fuente: propia


36
37
38
39
40
41
42
43
44
45
46
47
public int tamaoCola ( ) {
ElementoCola x = frente ;
int cont = 1;
if ( ! colaVacia ( ) ){
while ( x != fin ) {
cont ++ ;
x = x . getSte ( ) ;
}
return cont;
}
return -1 ;
} /* fin del mtodo*/ } //fin de la clase
Figura 10.7. Cdigo fuente de la clase Cola (2/2)
Fuente: propia

De la Figura 10.7. Se observa, la clase Cola, con dos atributos, frente y
fin, para manipular la cola, respetando as los principios de la misma; en el
constructor (Lnea 3) se le asigna una referencia nula a los dos objetos.

El mtodo insertar (Lnea 7), se verifica el estado de la cola; si est
vaca, entonces el nuevo elemento ser el primero y el ultimo de la cola; en
el caso que la cola tenga al menos un elemento, entonces se agrega al final
de la misma (Lneas 13 y 14).

Para retirar un elemento de la cola se tiene el mtodo retirar en la
lnea 17; si la cola no tiene elementos, este mtodo devuelve una referencia
nula; si la cola posee al menos uno, se retira el que se encuentre de primero
en la cola (Lneas 21 y 22) y se retorna.

El mtodo colaVacia, como su nombre lo indica, verifica el estado de
la cola y devuelve un valor de tipo boolean, verdadero si no tiene elementos;
y falso, si tiene al menos uno.


En la lnea 31, el mtodo Frente, que devuelve el primer elemento de
la cola, si ta no esta vaca, y una referencia nula si lo est.

Por ultimo se encuentra el mtodo tamaoCola (Lnea 36), que
devuelve la cantidad de elementos de la cola; usando una variable local x
de tipo ElementoCola, para recorrer la cola, y una variable cont de tipo
entero, para contar los elementos, y luego devolver esta ultima variable
(cont) con el valor obtenido; si este mtodo retorna el valor de -1, indica que
la cola no contiene ningn elemento.

Funciones de una Lista
Las funciones de una estructura de datos dinmica como la lista, lo
primero es definir la clase que definir el nodo, con los datos necesarios y la
referencia o enlace al siguiente; luego la clase para definir la lista con su
tope; la clase Nodo, y las instrucciones de los mtodos perteneciente a la
clase lista dependern de si es simple o doblemente enlazada, se estudiar
primero la simplemente enlazada.

Las funciones bsicas en este tipo de estructuras de datos, depende de
las caractersticas de la aplicacin que se va a realizar con los datos de la
lista. Sin embargo a continuacin en la Tabla 10.3, se presentan las
funciones ms usadas.

Tabla 10.3. Funciones para una Lista(1/2)
Funcin Descripcin
Crear lista Inicializa la lista como vaca (constructor)
Es Vacia Determina si la lista est vaca
Insertar de primero Inserta un nodo, al principio de la lista
Fuente: propia


Tabla 10.3. Funciones para una Lista(1/2)
Insertar de ltimo Inserta un nodo, al final de la lista
Insertar en medio
Inserta un nodo, entre dos nodos existentes de la lista
Localizar
Devuelve la posicin donde est el campo buscado
Suprimir
Elimina de la lista el nodo que se indica
Primero
Devuelve la posicin del primer nodo de la lista
Anula
Vaca la lista
Fuente: propia

A continuacin la clase NodoListaS, ver Figura 10.8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class NodoListaS {
private int dato ;
private NodoListaS ste ;
public NodoListaS ( int d ) {
dato = d ;
ste = null ;
}
public void setDato ( int d ) {
dato = d ;
}
public void setSte ( NodoListaS s ) {
ste = s ;
}
public int getDato ( ) {
return dato ;
}
public NodoListaS getSte ( ) {
return ste ;
}
}
Figura 10.8. Cdigo de la clase NodoListaS
Fuente: propia

En la Figura 10.8. Observe que la clase NodoListaS, es muy parecida a
las clases nodo o elementos vistos en las Figuras 10.4 y 10.6.


Las funciones de insertar de primero, insertar de ltimo, insertar en
medio y suprimir; con listas enlazadas, se ilustran grficamente, para facilitar
su comprensin.

El mtodo insertar de primero: supngase la lista simplemente
enlazada de la siguiente figura con los elementos 5, 8, 6, y se desea insertar
el elemento 1.

Paso 1




Paso 2










5 8 6
primero
nuevo 1
5 8 6
primero
1 nuevo


Paso 3:







El cdigo de este mtodo puede apreciarlo en la Figura 10.9, lnea 11.

Para el mtodo insertar de ltimo, de la lista anterior, supngase que
se desea insertar el elemento (9), entonces

Paso 1:






Paso 2:








5 8 6
primero
1
primero
5 8 6
1 nuevo
5 8 6
primero
1
9
nuevo


Paso 3:






El cdigo de este mtodo puede ser apreciado en la Figura 10.9, lnea
19.

Para el mtodo insertar en medio, de la lista anterior, supngase que
se desea insertar el elemento (4) despus del elemento (5), entonces

Paso 1:



Paso 2:




5 8 6
primero
1
4
nuevo
9

5 8 6
primero
1
9

5 8 6
primero
1
9
nuevo


Paso 3:


Paso 4:




El cdigo de este mtodo puede ser apreciado en la Figura 10.9, lnea
29.

Para el mtodo suprimir, son posibles cuatro casos:

1.- El elemento a eliminar este de primero
2.- El elemento a eliminar sea el ltimo nodo
3.- El elemento este entre dos elementos ms, y
4.- El elemento a eliminar no se encuentre en la lista.

Caso 1. El elemento a eliminar es el (1)

5 8 6
primero
1
4
nuevo
9

5 8 6
primero
1
4
nuevo
9



Paso 1:




Paso 2:



Paso 3:



Caso 2. El nodo a eliminar es (9)

Paso 1:

5 8 6
primero
4

9

5 8 6
primero
1
4

9

5 8 6
primero
1
4

9

5 8 6
primero
4

9



Paso 2:




Paso 3:



Caso 3. El elemento a eliminar es el (8)

Paso 1:


Paso 2:



5 8 6
primero
4

5 8 6
primero
4

5 8 6
primero
4

5 8 6
primero
4

9



Paso 3:




Caso 4 elemento a eliminar no existe en la lista
En este caso el mtodo devuelve null.

A continuacin, se define la clase ListaS en la Figura 10.9. Con todas
las funciones antes mencionadas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class ListaS {
private NodoListaS primero ; //primer elemento de la lista
public ListaS ( ) {
primero = null ;
}
public boolean esVacia ( ) {
if ( primero == null )
return true ;
return false ;
}
public void insertarPrimero ( NodoListaS n ) {
if ( esVacia ( ) )
primero = n ;
else{
n . setSte ( primero ) ;
primero = n ;
}
}
Figura 10.9. Cdigo fuente de la clase ListaS (1/3)
Fuente: propia
5 6
primero
4



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
45
46
47
48
49
50
51
52
public void insertarFinal ( NodoListaS n ) {
if ( esVacia ( ) )
primero = n ;
else{
NodoListaS x = primero ;
while ( x.getSte ( ) != null )
x = x . getSte ( ) ;
x . setSte ( n ) ;
}
}
public void insertarMedio ( NodoListaS despuesDe , NodoListaS n )
{
if( !esVacia() ) { //inserta en nodo n, despus del nodo despuesDe
NodoListaS x = localizar ( despuesDe . getDato ( ) ) ;
if ( x != null ){
n . setSte ( x . getSte ( ) ) ;
x . setSte ( n ) ;
}
}
}
public NodoListaS localizar ( int d ) {
NodoListaS x = primero ;
if ( !esVacia() )
while ( x != null) {
if ( x . getDato() == d)
return x ;
x = x . getSte() ;
}
return null ;
}
public NodoListaS suprimir ( int d ) {
NodoListaS x = localizar ( d ) ;
NodoListaS y ;
if ( x != null ){
if( x . equals( primero)){ //si el nodo a eliminar es el primero
y = new NodoListaS ( x . getDato ( )) ;
primero = primero . getSte ( ) ;
}
Figura 10.9. Cdigo fuente de la clase ListaS (2/3)
Fuente: propia


53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
else
if( x. getSte()== null){// si el nodo a eliminar es el ultimo
y = primero ;
while ( !y . getSte ( ) . equals ( x ) )
y = y . getSte ( ) ;
y . setSte ( null ) ;
}
else {//si el nodo a eliminar esta en medio de dos nodos
y = primero ;
while ( !(y . getSte ( ) . equals ( x ) ) )
y = y . getSte ( ) ;
y . setSte ( x . getSte ( ) ) ;
}
return x ;
}
return null ;
}
public NodoListaS primero ( ) {
if ( !esVacia() )
return primero ;
return null;
}
public void anula ( ) {
primero = null ;
}
}
Figura10.9. Cdigo fuente de la clase ListaS (3/3)
Fuente: propia

En la Figura 10.9. En el cdigo fuente de la clase ListaS; se puede
observar que sta contiene un solo atributo (primero), que almacena el
primer nodo de la lista, este atributo se inicia con una referencia nula en el
constructor.

Luego en la clase, estn desarrollados las funciones descritas
anteriormente (esVacia(), insertarPrimero(NodoListaS),
insertarFinal(NodoListaS), insertarMedio(NodoListaS , NodoListaS),


localizar (int), suprimir (int), primero( ), y anula( )). Por la naturaleza de
los mtodos insertar, localizar y suprimir, sern estos los explicados, ya
que los dems son muy sencillos, y elementales.

En la lnea 11, se encuentra el mtodo insertarPrimero (NodolistaS);
en este mtodo si la lista no contiene elementos pues el nodo recibido n
ser el primer nodo de la lista; en el caso que la lista tenga al menos un
elemento, entonces el primer nodo (actual) pasa a ser el segundo y el nuevo
nodo n es el primero de la lista.

En la lnea 19, esta el mtodo insertarFinal (NodoListaS); ocurre
similar que en el mtodo anterior (insertarPrimero), si la lista no tiene
elementos, lgicamente el nuevo nodo n ser el primer elemento; si la lista
tiene al menos un elemento, se recorre toda la lista con la ayuda del objeto
x de tipo NodoListaS, hasta llegar al final de la misma, para entonces
guardar el nuevo nodo n.

En la lnea 29, el mtodo insertarMedio (NodoListaS , NodoListaS); en
este mtodo la lista debe tener al menos un elemento, recibe el nodo que
estar antes del nuevo despuesDe, y el nuevo nodo n, se busca el nodo
despuesDe en la lista, para luego insertar el nuevo nodo, entre el nodo
buscado y que le segua, de esta forma se enlaza el nuevo.

En la lnea 45. Esta ubicado el mtodo suprimir (int), se busca en la
lista el nodo que contenga el dato a eliminar d y se almacena en el objeto x
(lnea 46); para la eliminacin de un nodo en una lista, existen tres posibles
casos, que el nodo a eliminar se encuentre de primero en la lista, de ultimo, o
en medio de otros dos nodos. En el primer caso (lnea 49) se le asigna al
primer nodo el segundo de la lista. En el segundo caso (lnea 54), se recorre


la lista con el objeto y, hasta llegar al penltimo nodo y hacer la referencia
del siguiente igual a nulo. El tercer y ltimo caso (lnea 60), que el nodo a
eliminar est entre dos nodos ms, se recorre la lista con ayuda del objeto y,
hasta el nodo que se encuentre antes del nodo a eliminar, para luego enlazar
la referencia ste de ese nodo, con el nodo que le sigue al eliminar; por
ltimo se retorna el nodo x, que contiene el nodo que se elimino.

Las listas doblemente enlazadas tambin necesitan una clase
NodoListaD, sta vara de la anterior que se usan dos enlaces, al siguiente
nodo y al anterior. Ver Figura 10.10.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class NodoListaD {
private int dato ;
private NodoListaD ant , ste ;
public NodoListaD ( int d ) {
dato = d ;
ant = null ;
ste = null ;
}
public void setDato ( int d ) {
dato = d ;
}
public void setAnt ( NodoListaD a ) {
ant = a ;
}
public void setSte ( NodoListaD s ) {
ste = s ;
}
public int getDato ( ) {
return dato ;
}
public NodoListaD getAnt ( ) {
return ant ;
Figura 10.10. Cdigo fuente de la clase NodoListaD (1/2)
Fuente: propia


23
24
25
26
27
}
public NodoListaD getSte ( ) {
return ste ;
}
}
Figura 10.10. Cdigo fuente de la clase NodoListaD (2/2)
Fuente: propia

La clase NodoListaD, varia de la clase NodoListaS en que esta nueva
clase tiene dos referencias a objetos, el nodo que le antecede y el nodo que
sigue.

La clase ListaD, se define en la Figura 9.11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ListaD {
private NodoListaD primero ;
public ListaD ( ) {
primero = null ;
}
public boolean esVacia ( ) {
if ( primero == null )
return true ;
return false ;
}
public void insertarPrimero ( NodoListaD n ) {
if ( esVacia ( ) )
primero = n ;
else{
n . setSte ( primero ) ;
primero . setAnt ( n ) ;
primero = n ;
}
}
public void insertarFinal ( NodoListaD n ) {
Figura 10.11. Cdigo fuente de la clase ListaD (1/3)
Fuente: propia



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
if ( esVacia ( ) )
primero = n ;
else{
NodoListaD x = primero ;
while ( x . getSte ( ) != null )
x = x . getSte ( ) ;
x . setSte ( n ) ;
n . setAnt ( x ) ;
}
}
public void insertarMedio ( NodoListaD despuesDe , NodoListaD n )
{
if( !esVacia() ) {
NodoListaD x = localizar ( despuesDe . getDato ( ) ) ;
if ( x != null ){
x . getSte ( ). SetAnt ( n ) ;
n . setSte ( x . getSte ( ) ) ;
n . setAnt ( x ) ;
x . setSte ( n ) ;
}
}
}
public NodoListaD localizar ( int d ) {
NodoListaD x = primero ;
if ( !esVacia() )
while ( x != null) {
if ( x . getDato() == d)
return x ;
x = x . getSte() ;
}
return null ;
}
public NodoListaD suprimir ( int d ) {
NodoListaD x = localizar ( d ) ;
NodoListaD y ;
if ( x != null ){
if ( x . equals ( primero ) ){
Figura 10.11. Cdigo fuente de la clase ListaD (2/3)
Fuente: propia



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
y = new NodoListaD ( x . getDato ( )) ;
primero = primero . getSte ( ) ;
primero . setAnt ( null ) ;
}
else
if ( x . getSte() == null ){
y = primero ;
while ( !y . getSte ( ) . equals ( x ) )
y = y . getSte ( ) ;
y . getSte ( ) .setAnt ( null ) ;
y . setSte ( null ) ;
}
else {
y = primero ;
while ( !(y . getSte ( ) . equals ( x ) ) )
y = y . getSte ( ) ;
y . setSte ( x . getSte ( ) ) ;
x . getSte ( ) . setAnt ( y ) ;
x . setAnt ( null ) ;
x . setSte ( null ) ;
}
return x ;
}
return null ;
}
public NodoListaD primero ( ) {
if ( !esVacia() )
return primero ;
return null;
}
public void anula ( ) {
primero = null ;
}
}
Figura 10.11. Cdigo fuente de la clase ListaD (3/3)
Fuente: propia




De la Figura 10.11. Se aprecia que estn ilustrados los mtodos
equivalentes a la clase ListaS, de la Figura 9.9, los mtodos que fueron
alterados en esta nueva clase ListaD, son los de insertar, y suprimir, porque
a esta clase se le aadi una referencia ms, la de ant que representa el
enlace al nodo anterior, por esta razn en los mtodos donde se ingresa o
elimina un nodo, hay que actualizar las dos referencias de los nodos o
elementos involucrados en el cambio.

10.2.3 Resolucin de problemas usando estructuras de datos
fundamentales.

Implemente al concepto de pilas para que permita que el usuario
pueda hacer el llamado de los mtodos push y pop segn lo desee. El
mximo de la pila ser de 10 posiciones.
Realice un programa que usando el concepto de lista doble permita
reproducir el ejemplo mostrado en la Figura 10.12.


Figura 10.12. lista doblemente enlazada
15
12
22
1
14
25
42


Basndose en las siguientes clases, desarrolle un mtodo que permita
ordenar la lista, tomando como parmetro para esta tarea el atributo
duracin (ordene toda la lista utilizando dicho atributo).

class CNodo {
String nombre , autor , interprete ;
int duracin;
CNodo ant , ste;
CNodo ( ) {
Nombre = ;
autor = ;
interprete = ;
duracion = 0 ;
ste = null ;
ant = null ; } }
class CLista {
CNodo nodoInicial ;
CLista ( ) {
nodoInicial = null ;
}
public void ordenar ( ) {
//Desarrolle aqu.
}
}





CONCLUSIONES

Se analizo el contenido de la asignatura, para tener las consideraciones
necesarias con cada uno de los temas que conforman las unidades, este
anlisis permiti reconocer los temas mas difciles de explicar y asi darle mas
nfasis a la bsqueda de material relacionado con ellos.

En la revisin bibliografica relacionada al paradigma de programacin
orientado a objetos, se recopilo conceptos, definiciones y ejemplos para
ampliar la comprensin del contenido de las unidades de la asignatrura; de
esta forma ilustrar conceptos mas comprensibles para los estudiantes de la
asignatura.

Esta gua didctica fue desarrollada con altsimo cuidado, referente a la
programacin orientada a objetos con la finalidad de que los estudiantes
inscritos en la asignatura cuenten con un material de fcil comprensin, con
el contenido de la asignatura y asi puedan consultar todos los temas en una
sola gua; Se elaboro respetando el paradigma, y sus caractersticas,
logrando una alta calidad en su contenido.


RECOMENDACIONES


Fomentar el uso de la gua didctica en la asignatura de Objetos y
Abstraccin de Datos, tanto en el Nleo de Anzotegui, como en los dems
ncleos de la Universidad de Oriente donde se dicte la carrera de Ingenirera
de Sistemas.

Actualizar la gua didctica conforme a la publicacin de nuevas
ediciones de libros, para que asi siempre este renovado su contenido,
evitando que la informacin de esta se vuelva obsoleta.

Elaborar una gua de probemas que se adapte a las necesidades de los
estudiantes de dicha asinatura, para asi complementar esta gua didctica.

Elaborar guias didcticas para las dems asignaturas del Departamento
de Computacin y Sitemas, agrupando la informacin necesaria de los temas
que las conforman.

Convertir la gua didctica en un material multimedia que sea mas
atractivo a los estudiantes de la asignatura, donde se facilite el conocimiento
y ellos puedan usar varios sentidos reforzando el aprendizaje.



BIBLIOGRAFA

Arias, F. (1999). EL PROYECTO DE INVESTIGACION.Gua para su
elaboracin. (3RA. EDICIN) Editorial Episteme. Caracas.

Bruer, J.T. (1999): Escuelas para pensar, una ciencia de aprendizaje en
el aula, Madrid, Ediciones Paids.

Ceballos, J. (2003). Java 2 curso de programacin. Cuarta
edicin.Editorial RA-MA. Madrid.

Deitel, H. y Deitel, P. (2004). Java cmo programar. Quinta edicin.
Editorial Pearson. Mxico.

Drozdek, A. (2007).Estructura de datos y algoritmos en Java. Segunda
edicin.Mexico.

Edwards, D.; y Mercer, N. (1988). El conocimiento compartido. El
desarrollo de la comprensin en el aula. Barcelona: Paids/MEC.

Garca, L. (2002): La Educacin a Distancia, de la teora a la prctica,
Madrid, Ed. Ariel, S.A.

Groussard, T.(2010). Java 6 Las bases del lenguaje y de la
Programacin orientada a objetos. Ediciones Eni. Barcelona, Espaa

Martinez, M (1998). El contrato del profesorado. Condiciones para una
nueva escuela. Ed. Desclee de brouwer. Bilbao Solera, L. Araya, F. Hugo, V.


(2008). La Benemrita Universidad estatal a distancia en la sociedad del
conocimiento. Editorial Universidad Estatal a Distancia. San Jos, Costa
Rica.

Weiss, M. (2000). Estructuras de datos en Java.Editorial Pearson
Madrid.


METADATOS PARA TRABAJOS DE GRADO, TESIS Y ASCENSO:



TTULO

GUIA DIDCTICA PARA LA ASIGNATURA OBJETOS Y
ABSTRACCIN DE DATOS, DICTADA A LOS ESTUDIANTES
DE ING. EN COMPUTACIN Y DE ING. DE SISTEMAS, EN LA
UNIVERSIDAD DE ORIENTE


SUBTTULO



AUTOR (ES):

APELLIDOS Y NOMBRES

CDIGO CULAC / E MAIL
VERACIERTA TOVAR, GABRIELA
MARA
CVLAC: V-14.616.683
E MAIL:
gabrielaveraciertat@hotmail.com
CVLAC:
E MAIL:
CVLAC:
E MAIL:


PALBRAS O FRASES CLAVES:
GUIA INSTRUCCIONAL_
PROGRAMACIN ORIENTADA A OBJETOS
LENGUAJE JAVA
OBJETOS Y ABSTRACCIN DE DATOS_
HERENCIA
POLIMORFISMO
RECURSIVIDAD
ESTRUCTURAS DE DATOS





METADATOS PARA TRABAJOS DE GRADO, TESIS Y ASCENSO:


REA SUBREA
Trabajo de Ascenso
Profesor Asistente










RESUMEN (ABSTRACT):

La asignatura Objetos y Abstraccin de Datos es muy
importante, base fundamental en el rea de desarrollo de
software, usando el paradigma orientado a objetos que es uno
de los ms usados actualmente; a los estudiantes se les dificulta
investigar en bibliografas bien sea por la dificultad de adquirir
libros actualizados, encontrarlos en la sala de lectura del
departamento y en la biblioteca; porque en internet no
encuentran informacin adecuada o es expuesta de una forma
entendible para principiantes, por tal motivo se desarrollo una
gua didctica con la informacin necesaria para que el
estudiante pueda comprender de una manera precisa todo el
contenido de la asignatura; y de esta forma poder consultarla en
cualquier momento y disipar dudas referente a un tema
perteneciente a las unidades, con un lenguaje comprensible para
nivel de conocimiento; tambin pueden consultarla antes de
clases, o simplemente repasar el contenido discutido.


METADATOS PARA TRABAJOS DE GRADO, TESIS Y ASCENSO:


CONTRIBUIDORES:

APELLIDOS Y NOMBRES ROL / CDIGO CVLAC / E_MAIL

ROL CA AS TU x JU
CVLAC:
E_MAIL
E_MAIL

ROL CA AS TU JU x
CVLAC:
E_MAIL
E_MAIL

ROL CA AS TU JU x
CVLAC:
E_MAIL
E_MAIL
ROL CA AS TU JU
CVLAC:
E_MAIL
E_MAIL


FECHA DE DISCUSIN Y APROBACIN:


2012
AO

05
MES


DA




LENGUAJE. SPA



METADATOS PARA TRABAJOS DE GRADO, TESIS Y ASCENSO:


ARCHIVO (S):
NOMBRE DE ARCHIVO TIPO MIME
Guia Didctica Para La Asignatura Objetos Y
Abstraccin De Datos, Dictada A Los Estudiantes De
Ing. En Computacin Y De Ing. De Sistemas, En La
Universidad De Oriente
Application/msword



CARACTERES EN LOS NOMBRES DE LOS ARCHIVOS: A B C D E F G H I J K
L M N O P Q R S T U V W X Y Z. a b c d e f g h i j k l m n o p q r s t u v w x y
z. 0 1 2 3 4 5 6 7 8 9.

ALCANCE

ESPACIAL: ___________________________________ (OPCIONAL)

TEMPORAL: ___________________________________ (OPCIONAL)

TTULO O GRADO ASOCIADO CON EL TRABAJO:
Trabajo de Ascenso a la Categora de Profesor Asistente

NIVEL ASOCIADO CON EL TRABAJO:
Trabajo de Ascenso

REA DE ESTUDIO:
Departamento de Computacin y Sistemas

INSTITUCIN:
Universidad de Oriente Ncleo Anzotegui









Gabriela Mara Veracierta Tovar


_______________ _______________

JURADO JURADO


______________
JURADO