Programacion de algoritmos

18307
Titulación Ciclo
¡ Ingeniero en Informática III
Programación
de Algortimos
Guía didáctica
4 créditos
Departamento de Ciencias de la Computación y Electrónica
SecciónTecnologías Avanzadas de laWeb y SBC
UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA
La Universidad Católica de Loja
MODALIDAD ABIERTA Y A DISTANCIA
Autor:
Ing. Guido Eduardo Riofrío Calderón
Asesoría virtual:
www.utpl.edu.ec
Estimado estudiante recuerde que la presente guía didáctica está disponible en el EVA en formato PDF interactivo,
lo que le permitirá acceder en línea a todos los recursos educativos.

PROGRAMACIÓN DE ALGORITMOS
Guía didáctica
Guido Eduardo Riofrío Calderón
UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA
CC Ecuador 3.0 By NC ND
Diseño, maquetación e impresión:
EDILOJA Cía. Ltda.
Telefax: 593 - 7 - 2611418
San Cayetano Alto s/n
www.ediloja.com.ec
edilojainfo@ediloja.com.ec
Loja-Ecuador
Segunda impresión
Cuarta reimpresión
ISBN-978-9942-08-090-5
Maquetación y diseño digital:
EDILOJA Cía. Ltda.
Segunda edición
ISBN digital- 978-9942-04-272-9
Reservados todos los derechos conforme a la ley. No está permitida la reproducción total o parcial de esta guía, ni su tratamiento informático, ni la transmisión de
ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, por registro u otros métodos, sin el permiso previo y por escrito de los titulares
del Copyright.
Octubre, 2013

2. Índice........................................................................................................................................................ 4
3. Introducción........................................................................................................................................... 6
4. Lineamientos generales del Modelo Educativo basado en competencias y ...........
créditos académicos UTPL- ECTS.................................................................................................... 7
4.1. Competencias genéricas.................................................................................................................... 8
4.2. Competencias específicas.................................................................................................................. 8
5. Bibliografía............................................................................................................................................ 9
5.1. Básica................................................................................................................................................. 9
5.2. Complementaria................................................................................................................................ 9
5.3. Recursos OCW.................................................................................................................................... 10
6. Orientaciones generales para el estudio................................................................................... 12
7. Proceso de enseñanza-aprendizaje para el logro de competencias............................... 14
PRIMER BIMESTRE
7.1. Planificación para el trabajo del alumno......................................................................................... 14
7.2. Sistema de evaluación de la asignatura.......................................................................................... 15
7.3. Orientaciones específicas para el aprendizaje por competencias................................................... 16
Unidad 1: Gestión de excepciones en Java.................................................................................................................... 16
1.1. Fundamentos sobre el manejo de excepciones.................................................................................. 16
1.2. La API de Java................................................................................................................................... 17
1.3. Uso de try y catch............................................................................................................................. 18
1.4. Uso de la instrucción throws.............................................................................................................. 19
1.5. Generar excepciones propias............................................................................................................. 19
Autoevaluación 1......................................................................................................................................... 20
Unidad 2: Algoritmos sobre arreglos............................................................................................................................. 22
2.1. Estructura de un Array....................................................................................................................... 22
2.2. Algoritmos de búsqueda.................................................................................................................... 24
2.3. Algoritmos de ordenamiento.............................................................................................................. 25
2.4. Operaciones adicionales en un arreglo............................................................................................... 26
2.5. Operaciones con la clase Arrays......................................................................................................... 29
Autoevaluación 2......................................................................................................................................... 30
Unidad 3: Algoritmos Recursivos................................................................................................................................... 32
3.1. Introducción y conceptos básicos de recursividad............................................................................... 32
3.2. Aplicación de la recursividad.............................................................................................................. 33
Autoevaluación 3......................................................................................................................................... 35
2. Índice

SEGUNDO BIMESTRE
7.4. Planificación para el trabajo del alumno......................................................................................... 37
7.5. Orientaciones específicas para el aprendizaje por competencias................................................... 38
Unidad 4. Programación con ficheros en Java............................................................................................................... 38
4.1. Conceptos preliminares sobre los datos............................................................................................. 38
4.2. Flujos en Java................................................................................................................................... 39
4.3. Escritura y Lectura de datos en ficheros............................................................................................. 40
4.4. Uso de las clases FileInputStream y FileOutputStream...................................................................... 41
Autoevaluación 4......................................................................................................................................... 42
Unidad 5: Clases y Objetos de Java................................................................................................................ 44
5.1. ¿Qué es Programación Orientada a objetos?.................................................................................... 44
5.2. Clases................................................................................................................................................ 45
5.3. Atributos o Propiedades..................................................................................................................... 46
5.4. Métodos ........................................................................................................................................... 47
5.3. Encapsulamiento, ocultación.............................................................................................................. 47
5.4. Herencia............................................................................................................................................ 47
Autoevaluación 5......................................................................................................................................... 48
8. Solucionario........................................................................................................................................... 49
9. Recursos Multimedia.......................................................................................................................... 55

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja 5
Guía didáctica: Programación de AlgoritmosPreliminares
3. Introducción
Programación de Algoritmos es una asignatura con 4 créditos , forma parte del grupo de materias
troncales de la malla curricular y pertenece al tercer ciclo en la carrera de Sistemas Informáticos y
Computación de la Escuela de Ciencias de la Computación. Modalidad Abierta y a Distancia.
Los algoritmos son muy importantes a la hora de programar ya que son los pasos exactos para resolver
un problema. Esto quiere decir que es un procedimiento computacional bien definido que requiere de
datos de entrada y produce un valor como salida.
Con esta asignatura se pretende que nuestros estudiantes aprendan a resolver cualquier tipo de
problemasyaseanmatemáticosocomputacionales,atravésdeldiseñoyanálisisdealgoritmoseficientes.
Los algoritmos no solo son importantes porque nos ayudan a resolver problemas, nos obligan a pensar
y son la base de la programación, la calidad de un programa computacional depende de la calidad del
algoritmo.
Los contenidos que abarca la asignatura están estructurados en cinco unidades, distribuidos 3 para el
primer bimestre y 2 para el segundo bimestre.
La primera unidad comprende la Gestión de excepciones en Java, donde se explica los fundamentos
sobre el manejo de excepciones, los API de Java y su aplicación; la unidad dos, hablaremos de los
algoritmos sobre arreglos, aquí explicaremos la estructura de un arreglo, los algoritmos de búsqueda y
ordenamiento y las operaciones sobre arreglos; la tercera unidad trata sobre los algoritmos recursivos,
donde revisaremos algunos conceptos básicos de recursividad y ejemplos de aplicación.
En el segundo bimestre, la unidad 4 trata de la programación con ficheros en Java, donde revisaremos
los conceptos preliminares sobre datos, los flujos en Java, la estructura y lectura de datos en los ficheros,
algoritmos con archivos y algunos programas de aplicación; finalmente en la unidad 5 estudiaremos
las clases y objetos en java, donde se aprenderá los mecanismos que dispone el lenguaje Java para
almacenar y recuperar información.
Como docente de la universidad me desempeño en el Instituto de Investigaciones en Ciencias de la
Computación, es muy grato para mí darles la más cordial bienvenida a este nuevo ciclo académico y
recuerden estimados estudiantes que estaré gustoso de acompañarles y orientarles en el proceso de
aprendizaje.
Saludos y éxitos.

Guía didáctica: Programación de Algoritmos
UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja6
Preliminares
4. LineamientosgeneralesdelModeloEducativobasadoen
competenciasycréditosacadémicosUTPL-ECTS
Sr. Estudiante recuerde que usted ha iniciado su formación de tercer nivel con un sistema educativo
basado en el desarrollo de competencias a través de créditos académicos. Este modelo le convierte
a usted en protagonista de su propia formación y al profesor en mediador de las experiencias de
aprendizaje.
Surge entonces la necesidad de que tenga claro dos conceptos fundamentales competencia y crédito
académico.
• ¿Qué es una competencia? Entendemos por competencia el conjunto de actitudes, habilidades
y conocimientos que el alumno adquiere e incorpora según sus características personales y
experiencias laborales y, que se ponen de manifiesto en el desempeño de la actividad profesional.
Las competencias se adquieren a lo largo del proceso formativo de la carrera y se desagregan en
objetivos de aprendizaje propuestos en cada asignatura.
Elementos de una competencia. Tres son los elementos que podemos distinguir en toda
competencia:
¸ Actitudes: son predisposiciones y comportamientos ante situaciones concretas.
¸ Habilidades: son destrezas para ejecutar con éxito tareas, utilizar procedimientos y realizar
trabajos. Se desarrollan a través de la práctica y la experiencia.
¸ Conocimientos:constituyenloscontenidoscientíficos,conceptuales,teóricos,conocidostambién
como el aprendizaje académico.
• ¿Qué es un crédito académico UTPL / ECTS en la Modalidad a Distancia?
Un crédito académico es la unidad de medida del trabajo del estudiante, implica 32 horas de trabajo del
alumno (29 horas de trabajo autónomo y 3 horas de interacción)1
.
Los créditos académicos que el estudiante irá acumulando en el transcurso de la carrera involucran:
aprendizaje autónomo (estudio personal), tareas de investigación, interacción en el Entorno Virtual de
Aprendizaje (EVA), participación en tutorías, videoconferencias y otros eventos académicos (Jornadas,
seminarios, cursos, congresos avalados por la UTPL), prácticas académicas, pasantías preprofesionales
y de vinculación con la colectividad; actividades de evaluación; así como la realización del trabajo de
titulación.
El modelo adoptado por la UTPL contempla dos tipos de competencias: genéricas y específicas.
¸ Competencias Genéricas: Son aquellas capacidades (actitudes, habilidades y conocimientos)
comunes a todas las profesiones que se ofrecen en la UTPL. Constituyen una parte fundamental
del perfil que el estudiante debe desarrollar durante su formación.
1 CONESUP (2008): Reglamento del Régimen Académico del Sistema Nacional de Educación Superior, art. 18.

¸ Competencias Específicas: son propias de la titulación, aportan a la cualificación específica para
la profesión, dándole consistencia social y profesional al perfil formativo.
• Estructura general del programa formativo
Las Unidades Académicas o Escuelas de la UTPL han estructurado el programa formativo contemplando
cinco ámbitos o bloques de asignaturas: Formación Básica (10%); Genéricas de carrera (15%); Troncales
(35%) Complementarias (10%); Libre configuración (10%) y además, el Practicum que comprende las
Pasantías preprofesionales y de vinculación con la colectividad y Practicum Académico (20%).
4.1. Competencias genéricas
- Capacidad para organizar y planificar el tiempo.
- Capacidad de abstracción, análisis y síntesis.
- Habilidades para buscar, procesar y analizar información procedente de fuentes diversas.
- Capacidad de aplicar los conocimientos.
- Capacidad para identificar, plantear y resolver problemas.
- Capacidad creativa e innovadora.
- Capacidad para tomar decisiones.
- Capacidad de trabajo en equipo.
- Habilidades interpersonales.
- Compromiso con la calidad.
- Capacidad para formular, diseñar y gestionar proyectos.
- Compromiso ético.
4.2. Competencias específicas
Estas competencias se encuentran detalladas en la planificación de cada bimestre.

Preliminares
5. Bibliografía
5.1. Básica
• Texto: DEITEL, H. y DEITEL, P. (2010): Como Programar en Java, México, Editorial Pearson Prentice
Hall.
Se ha seleccionado este texto por las ventajas pedagógicas y técnicas que brinda al estudiante, en el
mismo se tratan temas relacionados con el lenguaje desde los conceptos, estructuras y sintaxis básicas,
de esta forma este recurso bibliográfico le servirá al estudiante no solo en el presente ciclo sino durante
el resto de su carrera, adicionalmente en el texto se puede encontrar una gran cantidad de ejercicios los
cuales han sido explicados a detalle por parte de los autores.
• Guía: Riofrío, G. (2011): Guía didáctica de programación de algoritmos, Ecuador, Editorial UTPL.
La guía didáctica contiene las indicaciones que usted debe tener en cuenta para realizar un estudio
eficaz, en este texto también se han colocado ejercicios complementarios a los que están planteados en
el texto base.
5.2. Complementaria
• Ceballos J. (2007): Java 2 Lenguaje y aplicaciones. Madrid: Editorial Alfaomega Grupo Editorial.
LibrodeprogramaciónenJava,queabarcatemasrelacionadosconsentenciasdecontrol,matrices,
métodos, ficheros, programación orientada a objetos, etc. 
• González, A. Programación en Java [En línea]. Disponible en http://issuu.com/arnaldogonzales/
docs/realizaciondemiprimerprogramaennetbeans [Consultada en 23/02/2011].
En este video se explica el uso del IDE NetBeans para realizar programas en java.
• Edualnav. Programación en Java [En línea]. Disponible en http://www.youtube.com/
watch?v=DE521kI-73Q [Consultada en 23/02/2011].
En el video se explica con un ejemplo como empezar a utilizar NetBeans.
• Borysbercley. Programación en Java y modo gráfico [En línea]. Disponible en http://www.youtube.
com/watch?v=8eEtmYrgIJQ [Consultada en 23/02/2011].
El video muestra el uso de interfaz gráfica NetBeans, ejemplos y manejo básico. Parte I.
• KAAF7. Programación en Java y modo gráfico [En línea]. Disponible en http://www.youtube.com/
watch?v=8TSgylhyrNI [Consultada en 23/02/2011].
El video muestra el uso de interfaz gráfica NetBeans, ejemplos y manejo básico. Parte II.

• Gigabytesperu. Programacion en Java y modo gráfico [En línea]. Disponible en http://www.
youtube.com/watch?v=ypDiMOwtwrs [Consultada en 23/02/2011].
El video muestra el uso de interfaz gráfica NetBeans, ejemplos y manejo básico. Parte III.
• carlislemc. Programación en Java y modo gráfico [En línea]. Disponible en http://www.youtube.
com/watch?v=LFr06ZKIpSM [Consultada en 23/02/2011].
Se explica la Programación de GUI en Java.
• Mdumse. Programación en Java y modo gráfico [En línea]. Disponible en http://www.youtube.
com/watch?v=A9ZX5rWcDOE [Consultada en 23/02/2011].
Se muestra como elaborar una calculadora en modo gráfico java.
• Nuverlomm. Programación en Java y modo gráfico [En línea]. Disponible en http://www.youtube.
com/watch?v=nR1Z6waoa_o [Consultada en 23/02/2011].
Se explica la Suma de números en java.
• Pbeltran. Programación de Archivos en Java [En línea]. Disponible en http://www.youtube.com/
watch?v=6E90QsyJbac [Consultada en 23/02/2011].
Se explica el manejo de Archivos en java. Parte I.
watch?v=0foctrktBQw&feature=related [Consultada en 23/02/2011].
Se explica el manejo de Archivos en java. Parte II.
watch?v=yB43khzF-iA&feature=related [Consultada en 23/02/2011].
Se explica el manejo de Archivos en java. Parte III.
5.3. Recursos OCW
• Beltrán, A. y Santamaría, J. (2009): Programación en Java I OpenCourseWare de la Universidad
Politécnica de Madrid [En línea] Madrid. Disponible en: http://ocw.upm.es/lenguajes-y-sistemas-
informaticos/programacion-en-java-i. [Consulta 15-01-2011].
Recurso OCW de la asignatura Programación en Java I que se dicta en la Universidad Politécnica
de Madrid. Abarca temas relacionados con tipo de datos, sentencias condicionales y repetitivas,
programación orientada a objetos.
• Sarriguren, A., Serrano, J y Alonso, L. (2009): Introducción a la programación en java -
OpenCourseWare de la Universidad del País Vasco [En línea]. Madrid. Disponible en: http://ocw.
ehu.es/ensenanzas-tecnicas/introduccion-a-la programacion-en-java/Course_listing. [Consulta
15-01-2011].

Preliminares
Presentación de los elementos básicos de programación y de la programación orientada a objetos,
con vistas a usar adecuadamente esos elementos para desarrollar, adaptar y depurar aplicaciones
con un tamaño moderado, que no precisen de conocimientos algorítmicos avanzados.
• http://ocw.upm.es/lenguajes-y-sistemas-informaticos/programacion-en-java-i/Contenidos/
LecturaObligatoria/9-objetosyclases.pdf
Elcontenidodeesterecursodisponedeinformaciónrelevanteparaestudiarlostemasrelacionados
con Clases y Objetos en Java.
• http://ocw.upm.es/lenguajes-y-sistemas-informaticos/programacion-en-java-i/Contenidos/
LecturaObligatoria/16-herencia.pdf
En este recurso se trata el tema de la herencia en Java, mismo que es muy importante para la
creación de nuevas clases en base al comportamiento de otras ya existentes.

6. Orientacionesgeneralesparaelestudio
Estimado Estudiante:
Para el mejor desempeño en sus actividades académicas y sobretodo de esta materia, la Universidad
pone a su disposición una serie de recursos y estrategias para favorecer la comprensión de los temas a
tratar y lograr un aporte significativo en el conocimiento del modelado de sistemas.
Es importante destacar que para el estudio de la materia usted dispone un texto básico, la guía didáctica
y material adicional que se encuentra especificados en la bibliografía.
Le sugerimos aplicar un esquema de trabajo apropiado, en el cual pueda conjugar sus actividades
académicas, profesionales y familiares. A continuación le presentamos algunos recursos y técnicas de
estudio que le serán de mucha utilidad en el desarrollo de los contenidos de la materia:
• Planifique previamente las actividades de estudio, de manera que pueda avanzar ordenadamente
en cada una de las unidades y temas establecidos en la guía de estudio. Lo alentamos a cumplir
con las actividades planificadas con la finalidad de que no se vea abocado a realizar grandes
jornadas de estudio al final de cada bimestre.
• Lea detenidamente cada uno de los contenidos de la guía didáctica y realice todas las actividades
que se plantean en la misma; no es aconsejable que usted trabaje de manera separada la guía
didáctica y el texto básico.
• Aplique estrategias de aprendizaje como: resúmenes, esquemas, organizar formularios, cuadros,
mentefactos, etc. que le permitan a comprender de mejor manera la temática abordada.
• Participe activamente en el EntornoVirtual de Aprendizaje (EVA), en donde podrá interactuar tanto
con sus profesores – tutores y compañeros; dar criterios y opiniones en los foros de discusión que
en cada bimestre se le propondrán.
• Utilice los recursos web (videos, presentaciones, podcast) que la universidad ha puesto a
disposición y que se encuentran en la página principal de la UTPL a los que se puede acceder
ingresando a la página www.utpl.edu.ec
• Desarrolle las evaluaciones a distancia (una por cada bimestre) recuerde que estas sirven como
estrategia de aprendizaje y preparación para las evaluaciones presenciales y que se califican sobre
6 puntos.
• Nopierdalaoportunidaddecontactarseconsuprofesor,utiliceloshorariosdetutoríadelamateria
para resolver las inquietudes presentadas en relación a los contenidos, desarrollo de trabajos y/o
situaciones de carácter organizativo.
Adicionalmente encontrara a lo largo de la presente guía una serie de focalizadores los cuales le indicaran
que actividades debe desarrollar para reforzar el aprendizaje.

Preliminares
Lectura recomendada
Antes de empezar el estudio de una nueva unidad se le recomienda leer los temas relacionados en el
texto, de esta manera usted se ubicara en el contexto de estudio que se esta tratando.
Actividades y ejercicios para reforzar el aprendizaje
De la misma forma se plantea que el estudiante desarrolle ciertas actividades o ejercicios para
complementar los conocimientos adquiridos.
Estrategia de aprendizaje
Otroaspectoimportanteestransmitiralgunasbuenaspracticaseneldesarrollodeaplicacionesyconsejos
de programación las cuales de la misma forma contribuyen a hacer que el proceso de aprendizaje del
estudiante sea efectivo.
De igual forma se recomienda que el estudiante pruebe diferentes lógicas para resolver un problema,
esto con la finalidad de poder diferenciar las ventajas y desventajas que pueden existir al momento de
resolver un problema.

Guía didáctica: Programación de AlgoritmosPrimer bimestre
7. Proceso de enseñanza-aprendizaje para el logro de competencias
PRIMER BIMESTRE
7.1. Planificación para el trabajo del alumno
COMPETENCIAS
ESPECÍFICAS
OBJETIVOS DE
APRENDIZAJE
CONTENIDOS
CRONOGRAMA
ORIENTATIVO ACTIVIDADES DE
APRENDIZAJE
Unidades/Temas Tiempo estimado
• Definir
requerimientos,
diseñar,
implementar,
integrar,
administrar
y optimizar
soluciones
software
centralizadas,
distribuidas ó
soluciones web.
• Aplicar la lógica
matemática en
el contexto de
las Ciencias de
la Computación,
con proyección,
al diseño
de circuitos,
programación,
análisis y
desarrollo de
algoritmos.
• Definir y calcular
la eficiencia de
los algoritmos
utilizando
pseudocodigo
y midiendo el
desempeño de
los algoritmos
elaborados y
valorando su
utilidad.
• Analizar y diseñar
sistemas digitales
aplicables a
la tecnología
computacional
• Identificarlanaturaleza
y la importancia del
control de excepciones
en Java
• Aplicar las estrategias
de control de
excepciones en
problemas
Unidad 1: Gestión de
Excepciones en java
• Fundamentos sobre el
manejo de excepciones
• La API de Java
• Uso de try y catch
• La instrucción throws
• Generar excepciones
propias
Semana 1 y 2
8 horas de autoestudio.
8 horas de interacción
• Lectura comprensiva de la
primera unidad.
• Desarrollo de actividades
recomendadas en la guía
didáctica.
• Interacción con el EVA
• Inicio del desarrollo de la
evaluación a distancia.
• Revisar los conceptos
y estructura de un
arreglo
• Aplicar los diferentes
algoritmos para
búsqueda y
ordenamiento de
elementos
• Evaluar las técnicas
estudiadas para su
aplicación en ejercicios
específicos.
Capitulo 2: Algoritmos
sobre arreglos
• Estructura de un array
• Algoritmos de búsqueda
• Algoritmos de
ordenamiento
• Operaciones adicionales
en un arreglo
Semana 3 y 4
8 horas de interacción
primera unidad.
didáctica.
• Estudiar los conceptos
y características de los
método recursivos
• Comprender los
ejercicios propuestos
para desarrollar nuevas
propuestas de solución
• Aplicar las técnicas en
la solución de nuevos
ejercicios.
• Evaluar las técnicas
estudiadas para su
aplicación en ejercicios
específicos.
Capitulo 3: Algoritmos
recursivos
• Introducción y
conceptos básicos de
recursividad
• Aplicación de la
recursividad
Semana 5 y 6
8 horas de interacción.
primera unidad.
didáctica.
Unidades 1, 2 y 3 Semana 7 y 8
8 horas
• Repaso general de la materia
• Desarrollo ejercicios adicionales
en el EVA

Primer bimestre
7.2. Sistema de evaluación de la asignatura
1.Autoevaluación*
2. Heteroevaluación
3.Coevaluación
Evaluación a Distancia
Evaluación
Presencial
Parte
Objetiva
Partede
Ensayo
Interacción
conelEVA
Actitudes
Comportamiento ético X X X X X
Cumplimiento, puntualidad, responsabilidad X X X
Esfuerzo e interés en los trabajos X X X X X
Respeto a las personas y a las normas de
comunicación
X
Habilidades
Creatividad e iniciativa X
Contribución en el trabajo colaborativo y de
equipo
Presentación, orden y ortografía X X
Emite juicios de valor argumentadamente
Conocimientos
Dominio del contenido X X X X X
Investigación (cita fuentes de consulta) X X
Aporta con criterios y soluciones X X
Análisis y profundidad en el desarrollo de
temas
PORCENTAJE
Estrategiadeaprendizaje
10% 20% 30%
Máximo1punto
(Completalaevaluacióna
distancia)
70%
Actividadespresencialesy
enelEVA
Puntaje 2 4 6 14
TOTAL 20 puntos
 Para aprobar la asignatura se requiere obtener un puntaje mínimo de 28/40 puntos, que equivale al 70%
* Son estrategias de aprendizaje, no tienen calificación; pero debe responderlas con el fin de autocomprobar su proceso de aprendizaje.
** Recuerde que la evaluación a distancia del primero y segundo bimestre consta de dos partes: una objetiva y otra de ensayo, debe desarrollarla y entregarla en
su respectivo centro universitario.
Sr. estudiante:
Tenga presente que la finalidad de la valoración cualitativa es principalmente formativa; sin embargo,
en circunstancias especiales podría afectarle positiva o negativamente en su calificación cuantitativa.

7.3. Orientacionesespecíficasparaelaprendizajeporcompetencias
Unidad 1: GestióndeexcepcionesenJava
Recursos educativos multimedia
Estimados participantes, a partir de este momento empezamos con el estudio de la presente asignatura,
espero que las indicaciones impartidas por mi persona a través de la presente guía didáctica les sean
de gran utilidad para obtener los conocimientos que nos hemos planteado, adicionalmente recuerden
que disponen de varios medios para solicitar ayuda o explicación de temas puntuales y que necesiten
mayor atención. De la misma forma al empezar cada unidad les hare una presentación del contenido y
su ubicación dentro del contexto de la asignatura.
La gestión de excepciones en un proceso de programación es un tema muy importante si queremos que
nuestras aplicaciones sean robustas, de calidad y sean útiles para nuestros usuarios; pero, ¿qué es una
excepción? a este término en algunos casos lo encontraremos con el nombre de“error”o“problema”, esto
es muy cierto, pues una excepción es una situación poco habitual, aquella situación que se sale de un
procesooflujonormal,esteaspectorepresentaespecialatencióneneláreadedesarrollodeaplicaciones,
puesto que los programas siguen una serie de pasos que fueron programados y en el transcurso del
mismo pueden ocurrir situaciones no previstas; imagínense ustedes como estudiantes de la UTPL que
están realizando una matrícula on-line y repentinamente existe un fallo en la red o se digita mal un dato,
etc. Es evidente que debe existir un mecanismo que controle estas situaciones cuyo principal objetivo en
este caso particular es no dejar el proceso de matrícula inconsistente, con datos perdidos o parcialmente
grabados. En esta unidad estudiaremos las técnicas que proporciona el lenguaje de programación Java
para gestionar y controlar excepciones.
1.1. Fundamentos sobre el manejo de excepciones
Sr. estudiante lea el capítulo 13 del texto base, de la misma forma le
recomiendo que codifique los ejercicios planteados en las secciones
correspondientes
En las secciones 13.1-4 se presentan los fundamentos conceptuales relacionados con el manejo de
excepciones, voy a mencionar algunas: ArrayIndexOutOfBoundsException para controlar el acceso a los
elementos en un arreglo, ArithmeticException la cual controla excepciones generadas en operaciones
matemáticas, y así sucesivamente el lenguaje Java proporciona una gran cantidad de clases para
gestionar estos procesos.
q
Videoconferencia Diapositivas

Primer bimestre
1.2. La API de Java
La documentación dela API de Java es una herramienta valiosa para
conocer y aplicar los recursos que dispone este lenguaje
Antes de continuar con el estudio de las excepciones quisiera hacer una paréntesis para indicarles
algo que considero fundamental en el aprendizaje del lenguaje Java y en cualquier tema que estén
estudiando, a mi me ha servido de forma significativa y personalmente pienso que es una de las grandes
ventajas que presenta este lenguaje para el desarrollo de las aplicaciones, el la“documentación de la API
de Java”, hago esta explicación ahora que estamos iniciando con el presente curso puesto que de aquí
en adelante encontraran en el texto algunas referencias a esta documentación, pero mas allá de eso
ustedes necesitaran saber entre otras cosas lo siguiente:
• Como estas estructuradas las clases,
• A que paquete pertenecen,
• Cuantos constructores tiene una clase,
• Que métodos existen para un objeto dado,
• Que propiedades tiene un objeto dado
• La jerarquía de clases
• La cantidad y tipo de parámetros que recibe un constructor o método
• Que tipo de dato retorna un método
• Una descripción de lo que hace un método
• El tipo de excepción que se debe controlar en un método
• Igualmente es importante saber si un método es static, public, private, etc.
• Todo lo relacionado con el tema de herencia es decir que métodos son propios de una clase y
cuales son heredados
Bueno, todo esto y muchas cosas mas son importantes para un desarrollador.

Figura 1.1 Documentación de la API de Java
En Java toda la gran cantidad de clases existentes heredan de la clase Object y toda esta jerarquía se
muestra en esta documentación. En la Figura 13.3 del texto base se muestra la estructura de herencia de
la clase Exception, pues esta jerarquía se ve reflejada en la figura 1.1.
Les recomiendo que utilicen desde el principio esta documentación, ustedes se pueden dar cuenta que
las clases se encuentran agrupadas en paquetes y cuando utilicemos cualquiera de éstas en nuestros
programas lo primero que se debe hacer es importar el paquete que la contiene.
1.3. Uso de try y catch
Sr. estudiante lea la sección 13.4 del texto base, en la cual existe un ejercicio
explicativo de los bloques try y catch.
El uso de las sentencias try y catch es la principal forma de controlar las excepciones en java, tal como se
indica en el texto base en el bloque try se coloca las instrucciones que potencialmente podrían generar
esta situación, la sintaxis de estas instrucciones es la siguiente:

Primer bimestre
try {
. . . . . . . . . . . .
. . . . . . . . . . . .
}
catch(TipoException1 e1) {
. . . . . . . . . . . .
. . . . . . . . . . . .
}
catch(TipoException2 e2) {
. . . . . . . . . . . .
. . . . . . . . . . . .
}
Luego de una instrucción try se debe colocar por lo menos un bloque catch cuyo código se ejecuta si
y solamente si se ha generado una excepcionen en el bloque try correspondiente. En la Figura 13.2 del
texto base se podrá dar cuenta que puede existir mas de un bloque catch, es decir se pueden gestionar
diferentes tipos de excepciones a la vez.
1.4. Uso de la instrucción throws
A continuación revisemos el uso de la instrucción “throws” misma que sirve para declarar que en un
determinado método puede ocurrir una excepción, esto quiere decir que el control de la excepción
se la debe realizar en la línea de código que llama a este método, en la Figura 13.2 del texto base se
muestra el uso de la instrucción “throws” en el método denominado “cociente”, algo importante que se
debe mencionar es que si en un método se declara una o mas excepciones con esta instrucción pues es
obligatorio utilizar las instrucciones try y catch en la línea que llama a este método, en caso contrario nos
dará un error de compilación.
1.5. Generar excepciones propias
Dependiendo de la naturaleza de la aplicación que se este desarrollando se puede requerir lanzar una
excepción especifica para un caso puntual, en estos casos es posible crear una clase que describa la
excepción, la nueva clase debe heredar directa o indirectamente de “Exception”, en la Figura 17.4 se
presenta la codificación de un ejemplo.

Autoevaluación 1
Conteste verdadero (V) o falso (F)
N. Pregunta
1
Una excepción es la indicación de un problema que ocurre durante la ejecución de
un programa
( )
2 El manejo de excepciones ayuda a mejorar la tolerancia a las fallas de un programa ( )
3
Un intento por acceder a un elemento más allá del fin del arreglo, es un ejemplo de
excepción.
( )
4 La clase Scanner, es un tipo especial de clase que no produce excepciones. ( )
5
El manejo de excepciones permite mejorar la claridad y la capacidad de modificación
de un programa
( )
6 El lenguaje de programación Java no soporta el manejo de excepciones. ( )
7
Las excepciones pueden surgir a través de código mencionado en forma explícita en
un bloque try, a a través de llamadas a otros métodos.
( )
8 El bloque catch es el que maneja una excepción, dentro de un programa. ( )
9
Es un error de sintaxis colocar código entre un bloque try y su correspondiente
bloque catch
( )
10 Cada instrucción catch puede tener varios parámetros. ( )
11
Con el manejo de excepciones un programa puede seguir ejecutándose después de
lidiar con un problema.
( )
12
Si se sabe que un método podría lanzar una excepción, se debe incluír en el programa
el código apropiado para manejar excepciones.
( )
13
El manejo de excepciones está diseñado para procesar errores sincrónicos que
ocurren cuando se ejecuta una instrucción.
( )
14 Un ejemplo de error sincrónico es el desbordamiento aritmético. ( )
15
Java clasifica a las excepciones en dos categorías: excepciones verificadas y
excepciones no verificadas
( )
16
LasexcepcionesquesonsubclasesdirectasoindirectasdelaclaseRuntimeExcepction
son excepciones verificadas.
( )
17
El compilador verifica cada una de las llamadas a un método, junto con su declaración,
para determinar si el método lanza excepciones verificadas.
( )
18 La cláusula throws especifica las excepciones que lanza un método. ( )

Primer bimestre
19
Limpiar la pila de llamadas a métodos significa que el método en el que no se atrapó
la excepción termina, todas las variables en ese método quedan fuera de alcance y el
control regresa a la instrucción que invocó originalmente a ése método.
( )
20
Una excepción que no sea atrapada en una aplicación hará que se ejecute el
manejador de excepciones predeterminado de Java.
( )
21
El método printStackTrace sirve para imprimir un mensaje de error, cuando una
excepción es atrapada.
( )
22
Las excepciones encadenadas permiten que un objeto de excepción mantenga la
información completan sobre el rastreo de la pila
( )
23
Por convención, todos los nombres de las clases de excepciones deben terminar con
la palabra throws.
( )
24 Una precondición debe ser verdadera cuando se invoca a un método. ( )
25 Una poscondición es falsa una vez que el método regresa con éxito. ( )
26
Las aserciones son condiciones que deben ser verdaderas en un punto específico de
un método.
( )
Ejercicios propuestos
Desarrolle los siguientes ejercicios planteados al final del capítulo 13 del texto base: 13.17, 13.19, 13.20,
13.22
Ir a solucionario

Unidad 2: Algoritmossobrearreglos
Bien, continuemos con el estudio de nuestra asignatura, en esta ocasión empezaremos con el estudio
de una estructura muy importante en el área de la programación, ¡los arreglos! estos tipos de datos
pertenecen al grupo de las estructuras compuestas, es decir se forman en base a las estructuras
fundamentales, y tal como indique anteriormente son muy importantes puesto que están presentes
en cualquier aplicación por mas pequeña o de tipo corporativa que ésta sea, si bien es cierto ustedes ya
realizaron el ciclo anterior un estudio preliminar de este tema, pues en la presente unidad empezaremos
haciendo un repaso y posteriormente nos centraremos en el estudio de varios algoritmos para manipular
los valores incluidos en un arreglo, los procesos mas importantes que se realizan sobre estas estructuras
son: búsqueda de elementos, ordenamiento, inserción. Quiero indicar que el propósito principal de
este tema es que usted señor estudiante aprenda a dominar y mantener la información existente en
un arreglo cuya aplicación sea en contextos específicos, tales como análisis de datos temporales, en
el campo de la educación para almacenar notas de estudiantes y realizar proyecciones, almacenar los
datos de las cosechas para calcular costos de producción, etc. Bien, luego de esta pequeña introducción
iniciemos con el estudio, y ya saben mucha suerte, recuerden que la clave para tener éxito y comprender
estos temas es: en primer lugar entender y seguir la indicaciones que se proponen y luego realizar los
ejercicios planteados.
2.1. Estructura de un Array
Sr. estudiante lea el capítulo 7 del texto base en el cual se presenta los con-
ceptos fundamentales de los arreglos
Fuente: http://www.google.com/imgres?imgurl=http://4.bp.blogspot.com
Figura 2.1 Arreglo de paneles solares
q

Primer bimestre
Antes de empezar con el estudio de los algoritmos para manipular los datos almacenados en un arreglo,
recordemos algunas características importantes de este tipo de datos, adicionalmente ustedes pueden
ver la Figura 7.1 del texto base en el cual se muestra gráficamente los componentes de un array:
• Se diferencia claramente dos componentes; los índices y los datos, en el lenguaje Java estos índices
empiezan desde 0.
• Son estructuras de longitud fija, es decir conservan la misma longitud desde el momento que son
creados.
• Los datos almacenado son del mismo tipo.
• En Java también se los conoce como tipos de referencia, puesto que una variable de tipo arreglo en
realidad lo que almacena es una referencia a memoria y no los datos propiamente, esto se puede
comprobar puesto que no es posible comparar directamente dos variables, es decir si tengo los
arreglos a y b, la expresión a==b no seria valida, en su lugar se debe utilizar el método“equals”.
• Para acceder al valor de un arreglo se debe especificar entre corchetes el índice de la posición,
el cual debe ser un número entero, este valor puede ser el resultado de cualquier operación
matemática.
Una vez que hemos recordado estas características, revisemos los aspectos relacionados con la
declaración e inicialización:
• Comoustedeshabránvistoeneltextobase,paracrearunarregloesnecesarioutilizarlainstrucción
new, esto se debe a que este tipo de dato es en realidad un objeto y las variables almacenan la
referencia a este objeto en memoria tal como lo indique anteriormente.
• Otro aspecto importante es el relacionado con la inicialización, fíjense que es posible asignarle
valores al arreglo al momento de su declaración o creación, en este caso ya no se utiliza la
instrucción new puesto que la máquina virtual de Java crea el objeto con la cantidad de elementos
especificados entre las llaves (en la sección 7.4 hay un ejemplo de esta inicialización).
Esmuyimportantequeusteddomineampliamenteestostemasdebase,puesto
que los mismos son fundamentales para la comprensión de los algoritmos de
búsqueda, ordenamiento y otros relacionados con arreglos, por lo tanto le
recomiendo codificar los ejemplos que se muestran en esta sección del texto
base, son ejercicios muy cortos pero que le ayudaran mucho en su proceso de
aprendizaje.
Algo que me parece interesante es lo que se muestra en la sección 7.6 del texto base, les comento que yo
como profesor de la UTPL he utilizado tradicionalmente los ciclos for clásicos para recorrer los elementos
de un arreglo << for (int i=0; i<arreglo.length; i++) >>, pero en esta ocasión se presenta una estructura
for mejorada, mas simple y que además evita caer en los típicos errores de acceder a elementos fuera de
rango, en la figura 7.12 se muestra el código y particularmente en la líneas 12 y 13 se ve como se declara
una variable (numero) la cual recoge los elementos del arreglo en cada iteración e internamente en el
ciclo for se utiliza esta variable.
Bien, para terminar con este repaso, en la sección 7.9 se presentan los arreglos multidimensionales,
particularmente los bidimensionales, de la misma forma les recomiendo que revisen estos contenidos,
si bien es cierto que todas las características que revisamos en los arreglos de una dimensión se aplican

en esta parte, pero obviamente en este caso existen diferencias en cuanto a la codificación para recorrer,
inicializar, crear matrices; puesto que ahora se tiene dos subíndices, la Figura 7.16 muestra la estructura
de una matriz.
2.2. Algoritmos de búsqueda
Sr. estudiante lea el capítulo 16, la sección 2 del texto base en el cual se explica
las técnicas relacionadas con los algoritmos de búsqueda
Esta claro que un arreglo hace referencia a un conjunto de datos, por lo tanto existe una seria de
operaciones que son típicas de realizar en esta estructura, empecemos con el estudio de los algoritmos
de búsqueda puesto que estos algoritmos son la base para la realización de otras operaciones como son
eliminación, modificación, etc.
Los algoritmos de búsqueda básicamente pueden ser de dos tipos:
• Búsqueda secuencial o lineal
• Búsqueda binaria
La idea básica de la búsqueda secuencial es recorrer el arreglo e ir comparando cada elemento del
arreglo con la clave o valor buscado, se puede aplicar tanto en arreglos desordenados como en arreglos
ordenados, aunque para el caso de los arreglos ordenados se recomienda la búsqueda binaria puesto
que es mas eficiente en este caso, en la sección 16.2 del texto base se muestra el código correspondiente
a estos dos algoritmos de búsqueda.
En lo relacionado a la búsqueda binaria esta se aplica exclusivamente en arreglos ordenados puesto que
la idea básica de esta técnica es dividir el arreglo en dos partes e ir ubicando el elemento en la primera
mitad o en la segunda, dependiendo de su valor, si es mayor o si es menor que el elemento central del
arreglo, en la siguiente imagen se puede observar de forma grafica como trabaja este algoritmo.
El código para la búsqueda binaria se encuentra disponible en el texto base, a continuación les presento
una imagen para entender gráficamente la lógica de este algoritmo; veamos que los datos en este arreglo
se encuentran ordenados y se pide buscar el elemento número 44, usted se puede dar cuenta que se
necesitan únicamente 5 iteraciones hasta encontrar el elemento buscado a diferencia de la busque
secuencial en al cual se requerirían por lo menos 14 comparaciones hasta encontrar el elemento.
Figura 2.2 Búsqueda binaria

Primer bimestre
2.3. Algoritmos de ordenamiento
Sr. estudiante lea el capítulo 16, la sección 3 del texto base en el cual se explica
las técnicas relacionadas con los algoritmos de ordenamiento en arreglos.
Otra de las tares fundamentales en el trabajo con arreglos es el ordenamiento de sus elementos, en la
sección 16.3 del texto base se describen 3 técnicas:
• Ordenamiento por selección
• Ordenamiento por inserción
• Ordenamiento por combinación
Cada uno de estos métodos tiene sus ventajas y sus desventajas, en unos casos la sencillez de su
implementación pude resultar un factor favorable, en otros casos se debe tener en cuenta la eficiencia o
el tiempo y cantidad de recursos de memoria que requieren para ejecutar su trabajo.
Por otra parte quiero mostrarles la técnica conocida como“método burbuja”la cual no consta en el texto
base pero seria interesante conocerla puesto que es un método simple y la idea principal consiste en
acarrear los elementos menores hasta ubicarlos en su posición correcta
Figura 2.3 Algoritmo de Burbuja

Análisis del programa “AlgoritmoBurbuja” (Figura 2.3)
Línea Descripción
6 Se declara e inicializa el arreglo llamado números
7
Se obtiene la cantidad de elementos del arreglo para lo cual se utiliza el atributo length del
objeto
9,10 Para ordenar un arreglo siempre se utilizan dos ciclos repetitivos
12,13,
14
Si do elementos consecutivos (j y j-1) no están en el orden correcto, estos se cambian, para
lo cual se utiliza una variable auxiliar
17
En cada iteración queda ordenado el último elemento por lo tanto en cada iteración se
disminuye el limite
20, 21 Se recorre el arreglo para presentar sus elementos mediante una estructura“for”mejorada
2.4. Operaciones adicionales en un arreglo
Existenotrasoperacionesquesedeberealizarfrecuentementeenunarray,lespuedomencionaralgunas:
eliminar un elemento, insertar un elemento en un arreglo ordenado o en una posición especifica, etc.
Veamos en primer lugar la lógica para eliminar elementos, el aspecto clave en este proceso es que se
deben mover los elementos para llenar el casillero del elemento eliminado, este proceso se debe repetir
hasta el último elemento, veamos el código.
Figura 2.4 Algoritmo de eliminación

Primer bimestre
Análisis del programa “Eliminar” (Figura 2.4)
Línea Descripción
9,10,
11,12,
13
Mediante una estructura while se busca la posición del elemento que se quiere eliminar
para lo cual se compara cada elemento del arreglo con el valor almacenado en la variable
x.
14,15,
16,17
El proceso de eliminación consiste en recorrer los elementos desde la posición del datos
hasta el final del arreglo y moverlos una posición hacia la izquierda, para lo cual se coloca
el elemento pos+1 en la posición pos .
Otra de las operaciones que son muy comunes cuando trabajamos con arreglos es la inserción de nuevos
elementos, en este caso se debe tener en cuenta que si el arreglo ya esta lleno el ultimo elemento se
perderá, y la lógica es muy similar al problema presentado anteriormente puesto que los elementos se
deben mover para crear el espacio para el nuevo elemento.
Figura 2.5 Algoritmo para insertar elementos en un arreglo ordenado
Análisis del programa “Insertar” (Figura 2.5)
Línea Descripción
7 Se especifica el elemento que se quiere insertar
9,10,
11
Se busca la posición de inserción, y teniendo en cuenta que el arreglo esta ordenado
ascendentemente, en este caso se recorre el arreglo mientras el elemento que se quiere
insertar sea menor que cada valor recorrido
12,13,
14
Se recorre el arreglo desde el último elemento hasta la posición de inserción y se va
moviendo cada elemento una posición a la derecha
16
Finalmente se copia el valor que se quiere insertar en la posición encontrada en el proceso
anterior.

Como se puede dar cuenta el trabajo con arreglos no es complicado puesto que lo mas importante es
manejar de forma consistente la información, antes de escribir el código se debe analizar la solución
para de esta manera tener la idea clara del algoritmo que se desea programar, para finalizar esta unidad
revisemos un ejercicio específico, en esta ocasión vamos a presentar la frecuencia de ocurrencia de cada
valor en un arreglo.
Figura 2.6 Número de ocurrencias de los elementos en un arreglo
Análisis del programa “Frecuencia” (Figura 2.6)
Línea Descripción
11
La idea de este ejercicio es presentar cuantas veces esta cada elemento en el arreglo, para
lo cual se recorren todos sus elementos
Análisis del programa “Frecuencia” (Figura 2.6)
Línea Descripción
12 A cada elemento que lo vamos a comparar con el resto le llamaremos valorPrincipal
13,14,
15,16,
17
Es necesario verificar si cada valor principal que visitemos ya existe anteriormente en el
arreglo es decir ya ha sido contabilizado o analizado, esto para evitar presentar dos o mas
veces dicho valor, en este caso se recorre los elementos desde la posición de valor principal
hastaelprimerelemento,sielementoyaexistesecolocatrueenlavariablecorrespondiente.
18
El proceso de contabilidar los valores se realiza únicamente si el elemento no existe
previamente, es decir si la variable yaExiste esta en false
19 Se inicializa el contador de elementos en 0

Primer bimestre
20,21,
22,23,
24
Finalmente se visita cada casillero del arreglo para contabilizar únicamente aquellos
elementos que son iguales al valor principal
2.5. Operaciones con la clase Arrays
La API de Java proporciona una amplia cantidad de recursos para facilitar el trabajo del programador,
ahora quiero presentarles un ejemplo para trabajar con arreglos utilizando la clase Arrays la cual
proporciona varios métodos para realizar tareas de búsqueda y ordenación principalmente:
Figura 2.7 Uso de la clase“Arrays”
Análisis del programa “EjercicioArrays” (Figura)
Línea Descripción
4
Importamos la clase Arrays, recordemos que únicamente las clases que están en java.lang
se importan automáticamente
Análisis del programa “EjercicioArrays” (Figura)
Línea Descripción
10
La clase Arrays dispone de un método llamada sort, ejecutamos este método enviándole
como parámetro el nombre del arreglo, la posición inicial y final que nos interesa que se
ordene, en nuestro caso queremos que se ordene todo el arreglo
12,13 Se presentan los elementos ordenados
16,17
En esta segunda parte se busca un elemento mediante la técnica de búsqueda binaria dis-
ponible en la clase Arrays.
19
Tenga en cuenta que la posición presentada corresponde al arreglo ordenado
Puesto que la búsqueda binaria se efectúa sobre arreglos ordenados

Le recomiendo que profundice el estudio de esta clase para lo cual revise
la documentación en la API de Java y vea que métodos adicionales existen
y pruebe su funcionamiento en una aplicación. Adicionalmente seria
recomendable que revise las clases “ArrayList” y “Vector” las cuales están
orientadas también para trabajar con colecciones de datos
Autoevaluación 2
N. Pregunta
1
Los arreglos son estructuras de datos que consisten de elementos de datos
relacionados, del mismo tipo.
( )
2 Los arreglos una vez creados, son entidades de longitud variable. ( )
3 Un ejemplo de la declaración de un arreglo es: int c [ ] = new int [ 12] ( )
4
Los arreglos multidimensionales de dos dimensiones de utilizan con frecuencia para
representar tablas de valores, que consisten de información de filas y columnas.
( )
5
Los arreglos que requieren dos subíndices para identificar un elemento específico se
llaman arreglos tridimensionales
( )
6 Paraalmacenarlascalificacionesdelosestudiantes,seutilizaunarreglobidimensional. ( )
7
El primer elemento en cada arreglo tiene el subíndice cero, y algunas veces se llama
elemento cero.
( )
8
Para hacer referencia a un elemento específico en un arreglo, especificamos el
nombre de la referencia al arreglo y el índice (subíndice) del elemento en el arreglo.
( )
9
Cuando se crea un arreglo , cada elemento del mismo de recibe un valor
predeterminado , cero para los elementos numéricos de tipo primitivo, false para los
elementos booleanos y null para las referencias.
( )
10
Un programa puede crear un arreglo e inicializar sus elementos con un inicializador
de arreglos.
( )
11
La instrucción for mejorada permite a los programadores iterar a través de los
elementos de un arreglo o de una colección, sin utilizar un contador.
( )
12
Para pasar a un método una referencia a un objeto, simplemente se especifica en la
llamada al método el nombre de la variable que hace referencia al objeto.
( )
13
El número de argumentos en el arreglo se puede obtener mediante el campo string
del arreglo.
( )
14 Las listas y tablas de valores pueden guardarse en arreglos. ( )
15
La búsqueda de datos implica determinar si una clave de búsqueda está presente en
los datos y, de ser así, encontrar su ubicación.
( )

Primer bimestre
16
El algoritmo de búsqueda lineal busca cada elemento en el arreglo en forma
secuencial, hasta que encuentra el elemento correcto.
( )
17
Una de las principales diferencias entre los algoritmos de búsqueda es la cantidad de
esfuerzo que requieren para poder devolver un resultado.
( )
18 El algoritmo de búsqueda binaria es menos eficiente que la búsqueda lineal. ( )
19
La búsqueda binaria se ejecuta en un tiempo O(log n), ya que cada paso elimina la
mitad de los elementos restantes.
( )
20
El ordenamiento por selección es un algoritmo de ordenamiento simple, pero
eficiente.
( )
21
El ordenamiento por combinación es un algoritmo de ordenamiento que es más
rápido, pero más complejo de implementar que el ordenamiento por selección y el
ordenamiento por inserción.
( )
22
En el ordenamiento por inserción, después de la i-ésima iteración quedan ordenados
los primeros i elementos del arreglo original.
( )
23
Una invariante es una aserción que es verdadera antes y después de la ejecución de
una parte del código de un programa.
( )
24 En el ordenamiento por inserción se utiliza una clave de búsqueda ( )
25 El algoritmo de ordenamiento por inserción, se ejecuta en un tiempo )( 2
nO ( )
1. Desarrolle un programa para modificar un elemento en un arreglo ordenado.
2. Desarrolle un programa para invertir los elementos de un arreglo
3. Desarrolle un programa para ordenar cada una de las filas de una matriz
4. Desarrolle un algoritmo para buscar un elemento en una matriz
Ir a solucionario

Unidad 3: AlgoritmosRecursivos
Hola estimados participantes, estamos entrando al estudio de nuestra tercera unidad, espero que los
temas tratados anteriormente estén claros. La presente unidad esta orientado al tratamiento de una
técnica muy especial de programación,“la recursividad”en primera instancia puede ser algo complicado
entender su funcionamiento, lo importante en este aspecto es empezar el estudio con ejemplos
pequeños, en este punto vale la pena comentarles que si bien es cierto existen algunos programas
que se pueden resolver tanto de forma recursiva como de forma iterativa (mediante ciclos for o while),
existen otros problemas que son netamente recursivos, en la sección 15.1 del texto base se mencionan
algunos ejemplos de los cuales quiero resaltar que el tratamiento de arboles binarios, Torres de Hanoi,
Fractales, entre otros son de naturaleza recursiva y en algunos casos es muy complicado resolverlos de
forma iterativa como mencione anteriormente, bueno vamos a empezar y como siempre deseándoles
éxitos en el presente estudio y adicionalmente les recomiendo que lean el texto base en las secciones
indicadas, recuerde que la programación es como las matemáticas, debe hacer ejercicios para entender
los contenidos.
3.1. Introducción y conceptos básicos de recursividad
Sr. estudiante lea el capítulo 15, las secciones 2,3,4,5 en el cual existe la funda-
mentación teórica de la recursividad y adicionalmente ejercicios explicados
sobre este tema.
Fuente: http://lanza-un-d100000.blogspot.com/
Figura 3.1 Recursividad
Tal como usted se pudo dar cuenta en la lectura realizada la recursividad es una técnica de programación
en la cual un método se llama a si mismo, esa es la idea principal en este tema, a continuación quiero
mostrarles algunos aspectos claves en el tratamiento de un algoritmo recursivo.
q

Primer bimestre
• El 99%(por no decir el 100%) de los métodos recursivos deben tener una estructura condicional
(if).
• Uno de los bloques de la estructura condicional (ya sea el bloque if o el bloque else) contiene la
instrucción de terminación del algoritmo, es decir en esta parte el algoritmo ya no realiza llamadas
a si mismo, lo cual implica el fin de las llamadas recursivas.
• En el otro bloque de la estructura condicional, se implementa la llamada recursiva, es decir se
llama al mismo método con nuevos valores en los parámetros.
• Cada llamada recursiva implica que en la memoria del computador se están guardando copias
de los valores que tienen las variables en ese momento, esto es muy importante puesto que un
numero excesivo de llamadas recursivas puede hacer más lento el equipo.
Recuerde algo importante, todo método recursivo debe tener una condición de finalización, la ausencia
de este componente puede causar que el programa realice un número infinito de llamadas a si mismo,
es decir el programa nunca terminará su ejecución y tendríamos que terminar el programa de forma
inesperada, saliendo de la plataforma de desarrollo y en algunos casos es necesario reiniciar el equipo
puesto que la memoria del computador ha sido saturada.
Recuerde que es necesario leer los temas indicados en el texto base, esta actividad reforzara su
aprendizaje.
3.2. Aplicación de la recursividad
Sr. estudiante en la sección 15.3 existe un ejercicio explicado sobre factoriales,
adicionalmente en la guía se propone otro problema para que refuerce su
estudio
En el texto base se ha desarrollado como primer ejemplo el desarrollo del cálculo de factorial mediante
un método recursivo, adicionalmente quiero mostrarles otro ejercicio, el desarrollo de la búsqueda
binaria, pienso que este ejemplo es mas claro y sobre todo objetivo desde el punto de vista gráfico para
entender el funcionamiento de los métodos recursivos.

Figura 3.2 Arreglo de búsqueda binaria
Análisis del programa “BusquedaBinaria” (Figura 3.2)
Línea Descripción
11
Se llama a la función de búsqueda binaria para lo cual se envía la posición del primero y
último elemento del arreglo, adicionalmente se envía el valor que se quiere buscar.
16
La condición para terminar las llamadas recursivas es que la posición del elemento final sea
mayor que la posición del elemento inicial, en este caso se calculan nuevos valores para
estas variables y se realiza otra llamada al mismo método con estos nuevos valores.
27 En caso contrario no se realizan llamadas recursivas.

Primer bimestre
Autoevaluación 3
Conteste verdadero (V) o falso (F).
N. Pregunta
1
Un método recursivo de llama a sí mismo en forma directa o indirecta a través de otro
método.
( )
2
Si se llama a un método recursivo con un problema más complejo que el caso base,
por lo general, divide el problema en dos piezas conceptuales: una pieza que el
método sabe cómo resolver y otra pieza que no sabe cómo resolver.
( )
3
Una llamada recursiva puede ser una llamada a otro método, que a su vez realiza una
llamada de vuelta al método original.
( )
4 La obtención del factorial de un número, es un ejemplo de recursividad. ( )
5
La serie Fibonacci, se puede resolver aplicando algoritmos recursivos, esta serie
empieza con 0 y 1 , y tiene la propiedad de que cada número subsiguiente de
Fibonacci es la suma de los dos anteriores.
( )
6
Una pila es una estructura de datos en la que sólo se pueden agregar o eliminar datos
de la parte inferior.
( )
7
Las pilas se conocen como estructuras de datos“último en entrar, primero en salir”, el
último elemento que se insertó en la pila, es el primero que se elimina de ella.
( )
8
Sihaymásllamadasométodosrecursivosoanidadasdelaspuedenalmacenarseenla
pila de ejecución del programa, se produce un error conocido como desbordamiento
de pila.
( )
9
Tanto la iteración como la recursividad se basan en una instrucción de control: la
iteración utiliza una instrucción de repetición, la recursividad una instrucción de
selección.
( )
10
Tanto la iteración como la recursividad no implican repetición ni prueba de
terminación
( )
11 Tanto la iteración como la recursividad pueden ocurrir en forma infinita. ( )
12
Los problemas que se pueden resolver en forma recursiva, no se pueden resolver de
forma iterativa.
( )
13
Se prefiere un método recursivo en vez de uno iterativo cuando el primero refleja el
problema con más naturalidad, y produce un programa más fácil de comprender y
de depurar.
( )
14
Un fractal es una figura geométrica que se genera a partir de un patrón que se repite
en forma recursiva, un número infinito de veces.
( )
15
Los fractales tienen una propiedad de auto - similitud; las subpartes son copias de
tamaño reducido de toda la pieza.
( )
16
Al uso de la recursividad para regresar a un punto de decisión anterior se la conoce
como“vuelta atrás”recursiva.
( )

17
Si un conjunto de llamadas recursivas no `produce como resultado una solución al
problema , el programa retrocede hasta el punto de decisión anterior y toma una
decisión distinta.
( )
18
Un método que se llama a sí mismo en forma indirecta no es un ejemplo de
recursividad.
( )
19
La recursividad puede ser eficiente en la computación, debido a la reducción en el
uso del espacio en memoria.
( )
20
Cuando se llama a un método recursivo para resolver un problema, es capaz de
resolver solo el caso base o simple.
( )
21 Para terminar la recursividad se requiere de un caso base. ( )
Desarrolle los siguientes ejercicios planteados al final del capítulo 15 del texto base: 15.7, 15.8, 15.9,
15.12, 15.13, 15.17
Ir a solucionario

Guía didáctica: Programación de AlgoritmosSegundo bimestre
SEGUNDO BIMESTRE
7.4. Planificación para el trabajo del alumno
COMPETENCIAS
ESPECÍFICAS
OBJETIVOS DE APREN-
DIZAJE
CONTENIDOS
CRONOGRAMA
ORIENTATIVO
ACTIVIDADES
DE APREN-
DIZAJEUnidades/Temas Tiempo estimado
• Definir
requerimientos,
diseñar, implementar,
integrar, administrar
y optimizar
soluciones software
centralizadas,
distribuidas ó
soluciones web.
• Aplicar la lógica
matemática en
el contexto de
las Ciencias de
la Computación,
con proyección, al
diseño de circuitos,
programación,
análisis y desarrollo
de algoritmos.
• Definir y calcular
la eficiencia de los
algoritmos utilizando
pseudocodigo
y midiendo el
desempeño de
los algoritmos
elaborados y
valorando su utilidad.
• Analizar y diseñar
sistemas digitales
aplicables a
la tecnología
computacional
• Conocer los conceptos
relacionados con
el almacenamiento
permanente en Java
• Aplicar las técnicas de
acceso a ficheros
• Evaluar las técnicas de
manejo de archivos para
seleccionar las mejor
opción en función de datos
y aplicaciones especificas.
Unidad 4: Programación de ficheros
con Java
• Conceptos preliminares sobre los
datos
• Flujos en Java
• Escritura y lectura de datos en
ficheros.
• Uso de las clases FileInputStream y
FileOutputStream
Semana 9, 10 y 11:
12 horas de
autoestudio.
12 horas de
interacción.
• Lectura
comprensiva
de la primera
unidad.
• Desarrollo de
actividades
recomendadas
en la guía
didáctica.
• Interacción con
el EVA
• Inicio del
desarrollo de
la evaluación a
distancia.
• Entender la filosofía de la
POO.
• Aplicar los conceptos de
POO en el desarrollo de
programas en lenguaje Java
• Aplicar el concepto de
herencia en el desarrollo de
aplicaciones
Unidad 5: Clases y Objetos en
JavaFactores Humanos y motivación.
• Que es programación orientada a
objetos
• Clases
• Atributos o Propiedades
• Métodos
• Encapsulamiento, ocultación
• Herencia
Semana 12, 13 y 14
12 horas de
autoestudio.
12 horas de
interacción.
• Lectura
comprensiva
de la primera
unidad.
• Desarrollo de
actividades
recomendadas
en la guía
didáctica.
• Interacción con
el EVA
• Inicio del
desarrollo de
la evaluación a
distancia.
Unidades de la 4 a la 5 Semana 15 y 16
8 horas de
autoestudio.
8 horas de interacción.
Preparación para la
evaluación presencial
correspondiente al
primer bimestre

Segundo bimestre
7.5. Orientaciones específicas para el aprendizaje por competencias
Unidad 4. ProgramaciónconficherosenJava
Una vez que hemos estudiado los temas relacionados con el control de excepciones, arreglos y
algoritmos recursivos; revisemos los mecanismos de almacenamiento de datos, tal como se indica en el
texto base la información que se procesa en un programa es volátil puesto que los datos se almacenan
temporalmente en la memoria del computador y la información esta disponible mientras la aplicación
se este ejecutando, para tener disponibles los datos de forma permanente es necesario guardarlos
en los dispositivos de almacenamiento secundarios tales como un disco duro o un flash memory, en
esta unidad estudiaremos los mecanismos que dispone el lenguaje Java para almacenar y recuperar
información de estos dispositivos.
4.1. Conceptos preliminares sobre los datos.
Sr. estudiante lea el capítulo 14 del texto base, las secciones 1,2,3,4,5,6
se presentan bases teóricas para el manejo de archivos y ejercicios,
adicionalmente en la guía didáctica se presenta otros ejemplos mas simples,
le recomiendo codificarlos para ver los resultados.
http://4.bp.blogspot.com/_jlIpEQ2vSNo/SRM6ORmt2RI/AAAAAAAAACE/5oqzKDCgrYg/s200/
Figura 4.1 Ficheros físicos
q

En la sección 14.2 del texto base se presentan ciertas indicaciones sobre los datos y su organización
jerárquica desde la perspectiva informática, se puede ver como esta estructurada la información desde
el elemento mas pequeño que es un bit hasta los niveles superiores y que agrupan mayor cantidad de
información como son los registros y los archivos, es muy importante tener claro este modelo puesto
que este es la base para crear aplicaciones que guarden información de forma ordenada y sobre todo
estructurada, preste principal atención al ejemplo de registro (Número, Nombre, Dirección, …) que se
indica en esta parte del texto base puesto que la información se guarda mediante un formato de registro
en los archivos.
4.2. Flujos en Java
Sr. estudiante lea la sección 14.3 para reforzar el estudio de los flujos.
Antes de entrar al estudio de los archivos propiamente, revisemos un concepto que es fundamental en
este tema; los flujos, desde el punto de vista del lenguaje Java un flujo es un objeto que se encuentra en
un punto intermedio entre nuestra aplicación y el punto de origen o destino de la información, esto se
puede entender mediante la siguiente ilustración.
Figura 4.2 Flujos en Java
Cualquier aplicación por simple que sea utiliza por lo menos estos flujos de información: para entrada de
datos (in) el teclado y para salida de datos (out) la pantalla, a continuación les presento un programa que
utiliza estos flujos básicos, espero que el mismo aclare de mejor manera el concepto relacionado con
este tema, se podrán dar cuenta que en el mismo se crean dos objetos: “teclado” y “pantalla” los cuales
representan los flujos de entrada y salida respectivamente.

Segundo bimestre
Figura 4.3 Demostración de los flujos
Análisis del programa “Flujos” (Figura 4.2)
Línea Descripción
7,8 Declaramosdosobjetoscomoflujosdeentradaysalida,tecladoypantallarespectivamente.
12 Creamos un objeto de esta clase
13,14,
15,16
Se realiza la llamada al método leer
17 Se realiza la llamada al método escribir
20
El método leer declara explícitamente que puede ocurrir un error del tipo IOException, por
lo tanto en las líneas 13,14,15 y 16 es necesario atrapar este tipo de Excepción
13,14,
25,25
En este proceso se recogen los caracteres digitados en el teclado, este proceso se realiza
hasta que se digita el carácter de fin de línea (“n”) o tecla “Enter”. Adicionalmente estos
caracteres se están concatenando en la variable texto.
27 Finalmente se debe cerrar el flujo correspondiente.
30,31,
32,33
En el método escribir se utiliza el flujo de salidad de datos para presentar información en la
pantalla, la información esta en la variable texto, finalmente se cierra este flujo.
4.3. Escritura y Lectura de datos en ficheros
Para la lectura o escritura desde o hacia un archivo, es necesario tomar en cuenta algunos parámetros
comoporejemplo:eltipodedatosylaformadeaccederaestos,enestaseccióndelcursonosocuparemos
del acceso y escritura a los datos de un archivo de forma secuencial.

Tal como indique en el párrafo anterior se debe tener en cuenta el tipo de dato que se va ha escribir o
leer del archivo:
• Flujos de bytes
• Flujos de caracteres
• Flujos de datos primitivos
El paquete java.io contiene todas las clases necesarias para desarrollar aplicaciones que manipulen estos
tipos de datos; el siguiente gráfico muestra algunas clases de este paquete, podrá darse cuenta que en
la mayoría de los casos existen clases correspondientes para el acceso y para la escritura de datos en los
ficheros:
4.4. Uso de las clases FileInputStream y FileOutputStream
Estas clases se utilizan para grabar o leer datos de tipo byte; a continuación presento el código necesario
para escribir datos en un archivo utilzando la clase FileOutputStream.
Figura 4.4 Guardar datos en un archivo de texto

Segundo bimestre
Análisis del programa “EscribirBytes” (Figura 4.3)
Línea Descripción
8 Declaramos un arreglo de datos de tipo byte
12,13 Se crea un objeto de esta clase y seguidamente se ejecuta el método Escribir
19
El método read se utiliza para recoger datos del teclado, los datos se guardan en el arreglo
datos, y este método retorna la cantidad de bytes ingresados
20
Se crea el flujo datosOut con el nombre del archivo para guardar los datos, el parámetro
false indica que la información se guarda desde el inicio y no desde el final en caso que el
archivo ya exista.
21,22 Finalmente se escriben los datos en el archivo a través del flujo y finalmente se cierra este.
Autoevaluación 4
N. Pregunta
1
Los datos que se almacenan en variables y arreglos son temporales; se pierden cuando
una variable local queda fuera de alcance o cuando el programa termina.
( )
2
Las computadoras utilizan archivos para la retención a largo plazo de grandes
cantidades de datos , incluso después de que los programas que crearon los datos
terminan de ejecutarse.
( )
3
Los datos persistentes que se mantienen en archivos existen más allá de la duración
de la ejecución del programa.
( )
4
Las computadoras procesan todos los elementos de datos como combinaciones de
ceros y unos.
( )
5
Los caracteres en Java son Unicode y están compuestos de dos bytes, cada uno de los
cuales se compone de ocho bits.
( )
6 Un campo es un grupo de caracteres o bytes que transmite un significado. ( )
7
La unión de campos dan como resultado un registro, que se implementan como class
en Java.
( )
8 Un registro es un grupo de campos que no tienen relación ( )
9 Un archivo es un grupo de registros que no guardan relación entre sí. ( )
10
Una clave de registro identifica que un registro pertenece a una persona o entidad
específica y es única para cada registro.
( )
11 A un grupo de archivos relacionados se denomina base de datos. ( )
12 Java ve a cada archivo como un flujo secuencia de bytes. ( )
13 Los flujos basados en caracteres representan datos en formato binario. ( )
14 Los archivos que se crean usando flujos basados en bytes son archivos binario. ( )
15 Los archivos que se crean usando flujos basados en caracteres son archivos de texto. ( )

16
Los archivos de texto se pueden leer mediante editores de texto, mientras que los
archivos binarios se leen mediante un programa que convierte esos datos en formato
legible para los humanos.
( )
17 La clase File se utiliza para obtener información acerca de los archivos y directorios. ( )
18
Las operaciones de entrada y salida basadas en caracteres se pueden llevar a cabo
con las clases Scanner y Formatter.
( )
19
Para obtener datos de un archivo en forma secuencial, los programas comúnmente
empiezan a leer desde el principio del archivo y leen todos los datos en forma
consecutiva, hasta encontrar la información deseada.
( )
20
El objeto System.err normalmente permite a un programa imprimir mensajes de error
en la pantalla.
( )
21
El programador debe crear explícitamente los objetos flujo System.in, System. Out y
System.err
( )
22
El mecanismo de serialización de objetos permite escribir o leer objetos completos
mediante un flujo.
( )
23 El uso de búfer es una técnica para mejorar el rendimiento de E/S. ( )
24
La clase JFileChooser se utiliza para mostrar un cuadro de diálogo, que permite a los
usuarios de un programa seleccionar archivos con facilidad , mediante una GUI
( )
25 Los archivos binarios pueden ser leídos por los humanos ( )
26 Los dígitos, letras y símbolos especiales se conocen como caracteres ( )
1. Desarrolle un programa en Java para almacenar los números generados por la función seno,
coseno y tangente, desde 0 hasta 360 grados.
2. Desarrolle un programa en java para grabar y recuperar los datos de un registro definido por usted.
Ir a solucionario

Segundo bimestre
Unidad 5: Clases y Objetos de Java
Estimados participante estamos iniciando el estudio de la última unidad de nuestro curso así es
que ¡ánimo!, les comento que de una u otra forma ya hemos utilizado estos conceptos en unidades
anteriores, pues el lenguaje java es eminentemente orientado a objetos, es decir para cualquier
programa que usted desarrolle lo que debe hacer es definir una o varias clases con sus respectivos
métodos, adicionalmente ya les explique en la primera unidad sobre el uso de la API de Java en la cual se
podrán dar cuenta la jerarquía de clases existentes, relaciones de herencia, etc. Bien, empecemos con el
estudio de esta unidad el mismo que mas conceptual, finalmente quiero indicarles que en el texto base
guía existen varios capítulos que tratan el tema de la POO desde diferentes nieves.
5.1. ¿Qué es Programación Orientada a objetos?
Sr. estudiante lea el capítulo 3, las secciones 1-8 para reforzar los conceptos
relacionados con POO
Fuente:=http://4.bp.blogspot.com/_jlIpEQ2vSNo/SRM6ORmt2RI/AAAAAAAAACE/5oqzKDCgrYg/s200/
AprendiendoJava_html_
Figura 5.1 Clase y Objetos
Tradicionalmentelosprogramadoreshandesarrolladosusaplicacionesutilizandolatécnicaestructurada
de programación; la POO es una forma especial de programar en la cual se expresa nuestro desarrollo
como cosas del mundo real, esto implica una filosofía y forma de pensar diferente, pues los objetos o
mecanismos que están en nuestro entorno tienen unas características (atributos) y un comportamiento
o forma de actuar (métodos) , y esta visión debe verse reflejada en nuestra programación.
q

Bajo estos términos pensemos en un “Automóvil” para tratar de modelarlo en un esquema de POO.
Diríamos que este tiene sus atributos como son color, marca, tamaño, número de puertas, año de
fabricación, velocidad (en un determinado instante)etc.; estas características vendrían a ser los datos;
mientras que las funcionalidades o métodos (en términos de POO) serian arrancar, parar, girar, acelerar,
etc. Como podrá darse cuenta en un objeto se encapsula tanto datos como la programación de su
funcionamiento; otro ejemplo más cercano a nuestro medio informático, sería modelar con orientación
a objetos una ventana del“Sistema Operativo Windows”:
Figura 5.2 Clase“Ventana“
En un ejemplo anterior se presenta el objeto“ventana”y se ha definido algunos atributos respectivos, por
otra parte tengo definidos tres métodos, tenga en cuenta que los métodos definen un comportamiento
el mismo que puede involucrar un cambio de valor de los atributos.
5.2. Clases
Hemos visto que los objetos son:
• Definición de datos o atributos, y
• Programación, por otra parte.
La declaración de todos estos componentes del objeto es una clase, también se podría decir que una
clase de abstracción de objetos o que es la generalización de un tipo específico de objetos; siendo
más prácticos podríamos comparar a una clase como un molde de hacer pasteles, con el cual se crean
pasteles que vendrían a ser los objetos los mismos que se crean de acuerdo a las características del
molde, en realidad una clase es algo así como una plantilla que se utiliza para crear objetos.

Segundo bimestre
Hablando desde el punto de vista informático y concretamente en Java se crean objetos cuando se
define e instancia una variable de un tipo de clase, es decir de la siguiente manera:
Cuenta Ahorros cliente1 = new Cuenta Ahorros ( );
En el siguiente gráfico la clase“Barras Estadísticas”la cual define algunas propiedades como“cantidad de
barras”, “color”, “valor”, “aumentar_barras”, etc. En la parte inferior del gráfico se podrá dar cuenta que se
han creado objetos los cuales tienen diferentes valores para cada uno de los atributos.
Figura 5.3 Clase“Barras Estadísticas”
5.3. Atributos o Propiedades.
Tal como lo hemos comentado anteriormente los atributos o propiedades son las características de un
objeto, retomando el ejemplo del automóvil las características serán : color, año de fabricación, marca,
velocidad en un determinado instante, entre otras; podrá darse cuenta que las características siempre
están asociadas con su respectivo valor, ya sea este, de tipo texto o de tipo numérico; dicho de otra
forma, los atributos almacenan los datos de los objetos, o también son los datos encapsulados en un
objeto. Pueden existir dos tipos de atributos:
• Propios: Son aquellos que han sido declarados explícitamente en la clase que crea el objeto.
• Heredados:Sonaquellosquepertenecenalobjetoperoquenohansidodeclaradosexplícitamente
en la clase dueña del objeto, sino mas bien han sido el resultado de un proceso de herencia de
clases antecesoras.

5.4. Métodos
Igualmente ya lo hemos comentado que un objeto no solo está compuesto de funcionalidades o
lógica de comportamiento; los métodos en POO son lo que para la programación estructurada son los
procedimientos o funciones; ósea que estos pueden recibir parámetros e igualmente pueden devolver
algún dato. Adicionalmente también pueden ser propios y heredados como los atributos.
5.3. Encapsulamiento, ocultación
Tal parece que “Encapsulamiento” viene de palabra “capsula”; en todo caso esta define claramente lo
que es un objeto, en lo cual tanto los datos como sus funcionalidades están encerradas dentro de esta
cápsula; esto permite el ocultamiento de estos datos; permitiéndole al objeto relacionarse con el exterior
únicamente a través de mensajes; la respuesta a estos mensajes será la información que otros objetos
requieren.
5.4. Herencia.
Sr. estudiante lea el capítulo 9, en esta parte del texto base se explica lo rela-
cionado con herencia en Java
La herencia es la característica que permite crear clases a partir de otras ya existentes; con lo cual
reutilizamos los componentes (atributos y métodos) de la clase inicial.
Existen dos tipos de herencia, tal como se muestra en el siguiente gráfico:
Herencia Simple Herencia Múltiple
Figura 5.2 Herencia simple y herencia múltiple
Por otra parte es importante mencionar que Java implementa el tipo de herencia Simple lo que permite
ser más práctico y ordenado. Una alternativa al uso de herencia múltiple en Java es el uso de“Interfaces”

Segundo bimestre
Autoevaluación 5
N. Pregunta
1 Una clase y objeto es lo mismo. ( )
2 Para realizar una tarea en una aplicación orientada a objetos se requiere un método. ( )
3 El constructor de una clase permite inicializar los valores de cada objeto. ( )
4 Los objetos de una misma clase deben tener los mismos datos. ( )
5 Las clases se pueden declarar como public. ( )
6
Un método describe los mecanismos que se encargan de realizar sus tareas y oculta
al usuario las tareas complejas que realiza.
( )
7 El nombre del archivo (.java) debe ser el mismo que el nombre de la clase principal. ( )
8 La instrucción javac se utiliza para compilar una aplicación. ( )
9 A los atributos también se los llama campos. ( )
10
Los campos prívate de una clase pueden manipularse solo mediante los métodos de
esa clase; para lo cual se utilizan los métodos“establecer”y“obtener”.
( )
11 Los atributos de una clase pueden ser atributos de instancia y atributos de clase. ( )
12 Los tipos de datos en Java pueden ser primitivos y por referencia. ( )
13 La palabra clave new se utiliza para llamar a un constructor de clase. ( )
14 Superclases y subclases son términos utilizados en Herencia en Java. ( )
15
Para llamar al constructor de la superclase se puede utilizar las palabras super y this
indistintamente.
( )
16
Declarar variables de instancia como public es una mala práctica de ingeniería del
software.
( )
Ir a solucionario

Guía didáctica: Programación de AlgoritmosSolucionario
8. Solucionario
UNIDAD 1
Pregunta Respuesta
1 V
2 V
3 V
4 F
5 V
6 F
7 V
8 V
9 V
10 F
11 V
12 V
13 V
14 V
15 V
16 F
17 V
18 V
19 V
20 V
21 V
22 V
23 F
24 V
25 F
26 V
Ir a autoevaluación

Solucionario
UNIDAD 2
Pregunta Respuesta
1 V
2 F
3 V
4 V
5 F
6 V
7 V
8 V
9 V
10 V
11 V
12 V
13 F
14 V
15 V
16 V
17 V
18 F
19 V
20 F
21 V
22 V
23 V
24 V
25 V

UNIDAD 3
Pregunta Respuesta
1 V
2 V
3 V
4 V
5 V
6 F
7 V
8 V
9 V
10 F
11 V
12 F
13 V
14 V
15 V
16 V
17 V
18 F
19 F
20 V
21 V

Solucionario
UNIDAD 4
Pregunta Respuesta
1 V
2 V
3 V
4 V
5 V
6 V
7 V
8 F
9 F
10 V
11 V
12 V
13 F
14 V
15 V
16 V
17 V
18 V
19 V
20 V
21 F
22 V
23 V
24 V
25 F
26 V

UNIDAD 5
Pregunta Respuesta
1 F
2 V
3 V
4 F
5 V
6 V
7 V
8 V
9 V
10 V
11 V
12 V
13 V
14 V
15 F
16 V

SOLUCIONARIO
ESTRATÉGIAS PARA SOLUCIÓN DE LOS EJERCICIOS PROPUESTOS
Unidad 1: Gestión de excepciones en java
en el texto base.
Unidad 2: Algoritmos sobre arreglos
1. Para este ejercicio le recomiendo que tome como base la lógica para búsqueda de elementos,
debe quedar el elemento en la posición correcta.
2. Recorra los elemento hasta la mitad e intercambie cada elemento de la primera mitad con el
correspondiente de la segunda mitad.
3.
independiente.
4. Igualmente tome como base la lógica estudiada para el caso de los arreglos
Unidad 3: Algoritmos Recursivos
en el texto base.
1.
repetitivo y almacene en cada iteración el valor de la función solicitada.
2. Construya una clase con los datos del registro, luego cree un objeto de esta clase y guarde estos
datos.
Unidad 5: Clases y Objetos en java
Los ejercicios planteados en esta unidad los puede resolver revisando los contenidos planteados tanto
en la guía como en los capítulo correspondientes del texto base, adicionalmente tenga en cuenta que la
opinión personal de lo que usted comprendió en este tema es muy importante.
GERC/ymtm/15-07-2011/47
gg/2013-05-22

Programacion de algoritmos

Más contenido relacionado

La actualidad más candente

Similar a Programacion de algoritmos

Más de Ricardo ALVARADO FANO

Último

Programacion de algoritmos