Guia

Informática
Modalidad Abierta y a Distancia
Programación de Algoritmos
Guía Didáctica
4 créditos
Ciclo Carrera
3 ¡ Informática
La Universidad Católica de Loja
Área Técnica
MODALIDAD ABIERTA Y A DISTANCIA
Departamento de Ciencias de la Computación y Electrónica

Sección Tecnologías Avanzadas de la Web y SBC
Programación de Algoritmos
Guía Didática
4 créditos
Carrera Ciclo
- Informática III
Autor:
Pedro Daniel Irene Robalino
La Universidad Católica de Loja

Asesoría virtual:
www.utpl.edu.ec
PROGRAMACIÓN DE ALGORITMOS
Guía didáctica
Pedro Daniel Irene Robalino
UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA
4.0, CC BY-NY-SA
Diagramación y diseño digital:

EDILOJA Cía. Ltda.
Telefax: 593-7-2611418.
San Cayetano Alto s/n.
www.ediloja.com.ec
[email protected]
Loja-Ecuador.
Primera edición.
ISBN digital - 978-9942-25-579-2
La versión digital ha sido acreditada bajo la licencia Creative Commons 4.0, CC BY-NY-SA:
Reconocimiento-No comercial-Compartir igual; la cual permite: copiar, distribuir y comunicar
públicamente la obra, mientras se reconozca la autoría original, no se utilice con fines comerciales
y se permiten obras derivadas, siempre que mantenga la misma licencia al ser divulgada. https://
creativecommons.org/licenses/by-nc-sa/4.0/deed.es
24 de marzo, 2020
Índice
2. Índice 4
3. Introducción 6
4. Bibliografía 8
4.1. Básica 8
4.2. Complementaria 9
4.3. Direcciones de Internet: 9
5. Orientaciones generales para el estudio 11
6. Proceso de enseñanza-aprendizaje para el logro de competencias 14
PRIMER BIMESTRE
UNIDAD 1. CLASES Y OBJETOS EN JAVA 14
1.1. Qué es programación orientada a objetos. 15
1.2. Atributos (primitivos/por referencia), niveles de acceso. 19
1.3. Métodos, propiedades (set, get), constructores y sobrecarga. 22
1.4. Encapsulamiento, ocultación y paquetes. 27
1.5. Herencia. 29
1.6. Polimorfismo. 40
Autoevaluación 1 45
UNIDAD 2. GESTIÓN DE EXCEPCIONES EN JAVA 55
2.1. Fundamentos sobre el manejo de excepciones. 55
2.2. Las excepciones en el API de Java. 58
2.3. Uso de try-catch-finally. 62
2.4. La instrucción throw-throws. 64
2.5. Generar excepciones propias. 67
SEGUNDO BIMESTRE
UNIDAD 3. ARCHIVOS, FLUJOS Y SERIALIZACIÓN DE OBJETOS 80
3.1. Conceptos preliminares sobre los datos. 81
3.2. Flujos en Java. 82
3.3. Escritura y lectura de datos en ficheros secuenciales. 83
3.4. Serialización de objetos. 90
UNIDAD 4. ALGORITMOS RECURSIVOS 100
4.1. Introducción y conceptos básicos de recursividad. 100
4.2. Aplicación de la recursividad. 102
4.3. Comparación entre recursividad e iteración. 106
UNIDAD 5. ALGORITMOS SOBRE ARREGLOS 114
5.1. Estructura de un arreglo. 114
5.2. Algoritmos de búsqueda. 118
5.3. Algoritmos de ordenamiento. 121
5.4. Operaciones adicionales en un arreglo. 126
5.5. Operaciones con la clase Arrays. 128
7. Solucionario 135
8. Referencias bibliográficas 159

Guía Didáctica: Programación de Algoritmos PRELIMINARES
3. Introducción
Programación de Algoritmos es una asignatura troncal del tercer ciclo con un peso
de 4 créditos a la malla curricular de la carrera de Informática de la Modalidad
Abierta y a Distancia de nuestra Universidad Técnica Particular de Loja.
Con esta asignatura se pretende que usted resuelva problemas computacionales

haciendo uso principalmente de Programación Orientada a Objetos (POO),
herencia/polimorfismo, de técnicas de Gestión de Excepciones, tratamiento de
Archivos, Recursividad y Manejo de Arreglos (con los métodos de búsqueda y
ordenamiento).
Los contenidos que abarca la asignatura están estructurados en cinco unidades; 2

en el primer bimestre y 3 para el segundo bimestre.
La primera unidad, el estudio se enfoca en las Clases y Objetos en Java (POO

– herencia y polimorfismo), luego de la cuál: “Entenderá y aplicará los conceptos
de Programación Orientada a Objetos/Herencia/Polimorfismo para el desarrollo de
programas en el lenguaje Java.”
Luego en la segunda unidad (última del primer bimestre) estudiaremos la

Gestión de Excepciones en Java, con la que se pretende: “Identificar y aplicar
las estrategias de control de excepciones en flujos de código propenso a fallos.”
En el segundo bimestre tercera unidad (primera del segundo bimestre), el tema

de estudio es Archivos, flujos y serialización de objetos, con la cuál: “Evaluará
técnicas de gestión de archivos de acceso secuencial adoptando la más eficiente
para la entrada y salida de datos persistentes.”
Para la cuarta unidad miraremos algunos Algoritmos Recursivos, de forma

que: “Comprenda y evalúe los conceptos, características y ejercicios de los
métodos recursivos.”
6 MODALIDAD ABIERTA Y A DISTANCIA

Y finalmente en la quinta unidad revisaremos algunos Algoritmos sobre

Arreglos, luego de la cuál estará en la capacidad de: “Revisar y aplicar los
conceptos y estructuras de arreglos en los diferentes algoritmos de búsqueda y
ordenamiento.”
Debo puntualizar que esta asignatura no es para aprender la lógica ni los

fundamentos de programación, ya que esas competencias le fueron adquiridas
en las dos asignaturas que antecedieron a la presente; esta asignatura tiene un
tinte más práctico y de aplicabilidad de esta lógica y fundamentos, por lo cual, se
recomienda haber aprobado previamente: Lógica de la Programación (primer
ciclo) y Fundamentos de la Programación (segundo ciclo).
Poniéndome a su entera disposición, le dejo un pensamiento de Carlos

Cuauhtémoc S. que me ha motivado ante retos que a veces me han parecido algo
inalcanzables. “Valemos lo que tenemos en la mente y en el corazón, alcanzamos
lo que soñamos con toda intensidad”.

4. Bibliografía
4.1. Básica
Texto: Deitel, P. y Deitel, H. (2016). Cómo programar en Java. México: Pearson

Educación.
Se ha seleccionado este texto básico por las ventajas pedagógicas y

técnicas que brinda, ya que presenta las tecnologías de computación de
vanguardia enfocadas en las mejores prácticas de ingeniería de software
y explicando cada concepto con el método de “código activo” que permite
tener una visión total de los ejemplos y no solo de fragmentos específicos.
Gracias a este texto, podrá escribir instrucciones que ordenen a las
computadoras a realizar diferentes tipos de tareas. Aprenderá sobre la
programación orientada a objetos, la principal metodología de programación
en la actualidad, ya que Java es el lenguaje preferido para satisfacer las
necesidades de programación empresariales de muchas organizaciones. Ud.
puede revisar los recursos en línea del texto básico en este enlace.
Guía: Irene, P. (2020). Guía didáctica de Programación de Algoritmos. Loja,

Ecuador: EdiLoja – Universidad Técnica Particular de Loja.
La guía didáctica contiene las indicaciones que debe tener en cuenta

para realizar un estudio eficaz, también se han colocado ejercicios
complementarios a los planteados en el texto básico con el fin de reforzar
sus competencias.

4.2. Complementaria
Cadenhead, R. (2014). Java 8. Madrid: Ediciones Anaya.
La obra cuenta con un sencillo enfoque paso a paso que le ayudará a

dominar los conceptos y la tecnología que necesita para crear programas
en general. Es ideal para desarrolladores de todos los niveles que requieran
aprender a programar en Java, con las herramientas de desarrollo del IDE
de programación NetBeans.
Montero, M. R. (2014). Java 8. Madrid: Multimedia Anaya.
Java 8 es una obra puntual que presenta los conceptos de Programación

Orientada a Objetos de manera sencilla y ejemplificados, desde estructuras
de control básicas hasta tecnologías avanzadas de programación.
4.3. Direcciones de Internet:
Beltrán, A. y Santamaría, J. (2009): Programación en Java I OpenCourseWare de

la Universidad Politécnica de Madrid. Madrid. [Consultado 26-07-2019].
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. Madrid.
[Consultado 26-07-2019].
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

Pearson Español (2019): Sitio Web del texto básico: Cómo programar en Java
10e. Deitel. [En línea]. Enlace Web http://www.pearsonenespanol.com/
mexico/educacion-superior/deitel_index/como-programar-en-java-10e
Corresponde al sitio web del texto básico “Cómo programar en Java” de

Deitel P. que, con una introducción, resumen el contenido del texto básico,
los capítulos en español restantes y otros recursos adicionales en ingles.
Deitel & Associates (2017): Sitio Web del texto básico – Java How to Program,
10/e (Early Objects). [Consultado 28-08-2019].
En este sitio web del texto básico en ingles, podrá encontrar y descargar los
ejercicios desarrollados en cada capítulo del texto básico “Cómo programar
en Java” de Deitel P. así como otros recursos adicionales en ingles.
Pearson Español (2012): Sitio Web del texto básico – Cómo programar en Java
9/e. [Consultado 28-08-2019].
En este sitio web del texto básico en español, novena edición, podrá
encontrar y descargar los recursos para el profesor, código en español y
material adicional.
Jaor Software (2019): Un vistazo al Nuevo Apache NetBeans Versión 11.

Este video muestra como usar el nuevo Apache NetBeans versión 11.
Deitel & Associates (2019): Red social Deitel y de alguna de sus obras.
Red social de Facebook para seguidores de Paul Deitel, eventos, y algunas

de sus más importantes obras.

5. Orientaciones generales para el estudio
Estimado estudiante, para mejorar su proceso de auto aprendizaje en

“Programación de Algoritmos”, le sugiero las siguientes recomendaciones:
• Considere que para la asignatura dispone de: un texto básico, guía

didáctica, plan de estudio y material adicional, que se encuentra
especificado en la bibliografía.
• Aplique un esquema de trabajo apropiado, en el cual pueda conjugar

sus actividades académicas, profesionales y familiares.
• 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. Le aliento 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.
• Al realizar el estudio de su texto básico, aplique estrategias de

aprendizaje como: resúmenes, esquemas, formularios, cuadros,
mentefactos, etc. que le permitan comprender de mejor manera la
temática abordada.
• Participe de cada una de las actividades especificadas en su plan de

estudios dentro de los componentes: Aprendizaje en contacto con
el docente (CD), Aprendizaje autónomo (CA) y Aprendizaje práctico
experimental (CPE).

• Participe activamente en el Entorno Virtual de Aprendizaje (EVA),

en donde podrá interactuar tanto con sus tutores y compañeros;
dar criterios y opiniones en los foros de discusión y de anuncios
académicos que en cada bimestre y semanalmente se le publicarán.
• Solo una vez finalizado el estudio de cada unidad, conteste a los

cuestionarios obligatorios publicados dentro de su (EVA). No olvide que
estos cuestionarios le permiten medir su grado de comprensión en el
tema tratado.
• Utilice los recursos web (videos, presentaciones, podcast, etc.) que la

universidad ha puesto a disposición y que se encuentran dentro de su
EVA.
• No pierda la oportunidad de contactarse con su profesor, utilice

los horarios de tutoría de la materia para resolver las inquietudes
presentadas en relación con los contenidos, desarrollo de trabajos y/o
situaciones de carácter organizativo.
Adicionalmente encontrará a lo largo de la presente guía una serie de

focalizadores los cuales le indicaran que actividades debe desarrollar para
reforzar el aprendizaje.
Entre ellos tenemos:
Focalizadores Descripción
Lectura recomendada
Antes de empezar el estudio de una nueva unidad se le

recomienda leer los temas relacionados en el texto básico, de
esta manera usted se ubicará en el contexto de estudio que se
esta tratando.

Focalizadores Descripción
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.
Estrategias de aprendizaje
Otro aspecto importante es transmitir algunas buenas practicas

en el desarrollo de aplicaciones y consejos de programación las
cuales contribuyen a hacer que el proceso de aprendizaje del
estudiante sea efectivo.

Guía Didáctica: Programación de Algoritmos PRIMER BIMESTRE
6. Proceso de enseñanza-aprendizaje para el logro de competencias
PRIMER BIMESTRE
UNIDAD 1. CLASES Y OBJETOS EN JAVA
“La voluntad necesita un aprendizaje gradual, que

se consigue con la repetición de actos en donde
uno se vence, lucha y cae, y vuelve a empezar”.
- Anónimo
Estimado estudiante, iniciamos esta maravillosa aventura en el mundo de

la informática, y precisamente lo hacemos con uno de los paradigmas de
programación que hasta la actualidad se mantiene vigente, y es precisamente la
orientación a objetos, el cual interpreta a todo el mundo real (visible o invisible),
como un objeto automatizable, programable, capaz de describirse a si mismo
(atributos del objeto), y realizar acciones (métodos del objeto), así como,
comunicarse con otros objetos (llamadas entre objetos, colecciones de objetos,
etc.), heredarse, encapsularse, para lograr todos en común, un determinado fin,
por ejemplo: matricular nuestro vehículo, hacer la compra de la semana en el
súper mercado, matricularse en la universidad, etc. es decir, todas las actividades
del día a día, pueden ser automatizadas con este paradigma de programación.
De hecho, y sin exagerar, hoy en día podemos ver evidencias de un conjunto de
tecnologías en los países de Asia Oriental y Estados Unidos, que realizan casi
todas las actividades del ser humano, desde las más simples (como lavar vajilla)
hasta las más avanzadas o criticas (como transportarnos de un lugar a otro sin
un piloto al volante). Todos estos sistemas, no solo son tecnologías, sino también
programación, y apuesto a que, en su gran mayoría fueron concebidos con este
paradigma orientado a objetos, conocido por sus siglas OOP (object-oriented
programming) o POO. Ahora si entonces motivados, iniciamos con su estudio,

desde los fundamentos teóricos (Clases, Objetos, Atributos, Métodos, etc.),

hasta sus casos más avanzados de aplicabilidad (Herencia, Encapsulamiento,
Polimorfismo, etc.).
1.1. Qué es programación orientada a objetos.
Tradicionalmente los programadores han desarrollado sus aplicaciones utilizando

la técnica estructurada 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.
Figura 1.1 Representación del objeto Auto
Bajo estos términos pensemos en un Automóvil (ver Figura 1.1 Representación

del objeto Auto) 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”:

ATRIBUTOS VALOR ACTUAL MÉTODOS FUNCIONAMIENTO

Título Test 1 Mover Se cambia el valor
Dirección /Usuario/.../Test 1 de la posicionX y

posicionY
Ancho 15.6 mpx
Cambiar Cambia el valor de
Alto 11.6 mpx
tamaño los atributos ancho
Posición X 100 px
y alto
Posición Y 50 px Cambiar Permite a la
Estado Normal (o estado ventana cambiar
maximizado, el estado entre:
minimizado) normal, maximizado,
Color fondo Blanco minimizado.
Figura 1.2 Representación del objeto ventana
En el ejemplo anterior (ver Figura 1.2 Representación del objeto Ventana) se

presenta el objeto ventana con sus atributos (que describen/definen al objeto) y
métodos (que permiten accionar sobre el objeto).
Programacion Orientada en Objetos

Ahora bien, la declaración de todos estos componentes – del objeto – se los
realiza dentro de lo que la POO define como una CLASE, por tanto, la clase es
quien define al objeto, y no al revés. Una vez definida nuestra clase, podremos
– a partir de ella – crear la cantidad de objetos que se requiera, es decir, se

necesita de una sola clase, para crear n objetos; siendo más prácticos podríamos
comparar a una clase como un molde de 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. O como Deitel & Deitel dirían, “una CLASE es a un
Plano de Construcción, lo que un Objeto es a una Casa”
Para comprender claramente este tema (como es que un objeto es la abstracción

de una clase). Miremos la siguiente representación gráfica:
Figura 1.3 Representación de la clase Transporte
La presente (ver Figura 1.3 Representación de la clase Transporte) ejemplifica

clara y gráficamente el por que “una clase es un molde para crear uno, o varios
objetos”, ya que no puede existir un objeto sin que apunte, instancie, referencie
o pertenezca a una clase especifica. Es decir, todo objeto debe estar contenido
dentro de una clase. Por ello, los objetos avión, avioneta, jet, pertenecen a la
clase Aeronave y los objetos autoBus, auto, motobomba, pertenecen a la clase
Vehículo.

Cuando creamos una clase, se crea un nuevo “tipo de dato” llamado tipo de dato
por referencia, ya que, a una clase se puede acceder solo por medio de un objeto.
El concepto de una clase puede abstraerse aún más y volverse objeto; para
ello, dicho nuevo objeto (aeronave, vehículo), debe estar dentro de una clase
que los contenga, en esta representación gráfica, la clase que los contiene es:
Transportes.
Perfecto, me parece que hasta aquí es suficiente para introducirnos al estudio

teórico de este paradigma de programación; llego la hora de dedicarnos a estudiar
nuestro texto básico.
Entonces, le invito a revisar detenidamente dichos

fundamentos y ejemplos en su texto básico: Capítulo 3,
Secciones 3.1 a la 3.3, y luego a reflexionar al respecto del
siguiente resumen:
¿Como le fue en el estudio de los apartados anteriores de su texto básico?,

si lo hizo bien, estoy seguro de que comprendió como se define una Clase –
con sus atributos y métodos – en el lenguaje de programación Java, y como,
por medio de la definición de los objetos, se instancia (accede, encapsula,
referencia) una Clase. Adicional seguro se entero a que se refieren las siglas
UML (Unified Modeling Language), un lenguaje gráfico que permite modelar no
solo Clases, sino, sistemas completos (el potencial de UML lo explotaremos en
el tema Herencia). Pero, por si le quedo alguna duda, estoy seguro de que con la
siguiente ilustración las despejará a todas:

Figura 1.4 Representación UML y en Java, de la clase Personas
En la Figura 1.4 Representación UML y en Java, de la clase Personas, la clase

Personas representada en UML, contiene una lista de atributos y métodos en
el lenguaje Java corresponde al código junto a su diagrama, con sus niveles de
acceso (public +, protected #, y private -) y tipos de retorno para el caso de los
métodos (void = no retorno, int, double, etc. para retornos de tipo numérico, entre
otros).
Existen IDE’s – Integrated Development Environment – u otras herramientas que

permiten dibujar una clase por medio de UML con el cual se genera su código,
o con el código, generar su UML respectivo. Ejemplos de IDE’s usados en estas
entregas son: NetBeans, Eclipse, IntelliJ IDEA.
1.2. Atributos (primitivos/por referencia), niveles de acceso.
Estimado estudiante, en la sección 1.1 anterior de esta guía, le solicite revisar

el apartado 3.3. de su texto básico, referente a los atributos primitivos y por
referencia. ¿Logró identificar la diferencia entre los dos? Espero que si, por que
ello es un tema bastante básico si desea aprender POO en Java. Ahora más
bien, en lo que me deseo detener un poco es en los niveles – modificadores –
de acceso: publico, privado y protegido que se les asigna a los miembros de
una clase – atributos, métodos, etc. – con el fin de dar o restringir la lectura

o asignación de los valores – estados – de la clase, es por lo que, debemos

dirigirnos a nuestro texto básico:
En el Capítulo 8, Secciones 8.1 a la 8.3, del texto básico,

vamos a encontrar un ejemplo práctico de la clase Tiempo,
en el cual se explica como aplicar los niveles de acceso
para los miembros de las clases; haga una pausa aquí para
estudiar su texto básico.
¿Como le fue?, ¿verdad que el método de código activo que Deitel & Deitel,
desarrollan en su texto básico, es muy pedagógico para explicar cada concepto
aplicado en programación?, a mi si me lo parece, es por lo que en esta guía de
estudio he aplicado el mismo método didáctico para resumirle, complementarle
y aclararle cada tema aquí expuesto. Entonces por favor, hagamos la siguiente
reflexión: ¿cómo identificar, que niveles de acceso le debo asignar a los miembros
de mi clase? La respuesta es sencilla dadas las siguientes definiciones:
• Lo +public: es accesibles dentro/fuera de la clase, a través del objeto

que la instancia;
• lo -private: es accesibles solo dentro de la misma clase (ocultamiento
de información)
• y lo #protected: dentro de la clase y otras que pertenezcan al mismo
paquete.
Por tanto, deberá asignar uno u otro acceso, según los privilegios de lectura/
asignación que desea brindar a agentes internos/externos – métodos – para los
miembros de su Clase (atributos, métodos). Si lo confundí, por favor, revisemos
el siguiente ejemplo complementario (ver Figura 1.5 Clase Personas (niveles de
acceso) y Figura 1.6 Clase TestPersonas (niveles de acceso)), en el que explico
esto a detalle, línea a línea de código.

1 public class Personas {

2 //Atributos ó campos
3 public String sexo;
4 protected double edad;
5 public double estatura;
6 private double peso;
7 protected int numIdentidad;
8 public String estado;
9 //Métodos (void), funciones (return)
10 public void respirar() {
11 estado = "respirando";
12 }
13 protected void caminar() {
14 estado = "caminando";
15 }
16 private void alimentar() {
17 estado = "alimentando";
18 }
19 public String investigar() {
20 estado = "investigando";
21 return estado;
22 }
23 }
Figura 1.5 Clase Personas (niveles de acceso)
1 class TestPersona{
2 public static void main(String[] args) {
3 Personas personaA = new Personas();
4 Personas personaB = new Personas();
5 Personas personaC = new Personas();
6 personaA.sexo = "Masculino";
7 personaA.caminar();
8 System.out.println("personaA d sexo <"
9 +personaA.sexo+"> esta <"
10 +personaA.estado+">");
11 }
12 }
Figura 1.6 Clase TestPersonas (niveles de acceso)
▪▪ El atributo estatura (línea de código 5) está definido como público dentro de

la clase Personas, por ello, tanto los miembros de la clase Personas, como
los miembros de la clase TestPersona tiene acceso a él, ya sea para leer su
valor, o para asignar uno.
▪▪ El atributo peso (línea de código 6) de la clase Personas esta definido como

privado, por ello, únicamente los miembros de la clase Personas tendrán
acceso a él, mientras que los miembros de la clase TestPersona, no podrán
ni siquiera saber que la clase Personas posee ese atributo. Parafraseando
un ejemplo, se puede decir que el peso de una persona femenina debería
ser algo secreto, que únicamente ella lo debe conocer.

▪▪ El atribulo numIdentidad (línea de código 7) de la clase Personas tiene un

nivel de acceso protegido, por tanto, todos los miembros, de todas las clases
¡pero que pertenezcan al mismo paquete!, tendrán acceso a este atributo,
lo que confirma que protected es un nivel de acceso intermedio, entre el
publico y privado.
Dada esta explicación, por favor, responda las siguientes

interrogantes:
personaA.estatura = 175.5;
personaA.numIdentidad = 1105467862;
personaA.peso = 70;
De las tres líneas de código anteriores, si estas se codifican

en la clase TestPersonas ¿Cuáles de ellas genera error?
¿Por qué? ¿Cómo se lo soluciona? ¿Al menos hay dos
formas, las puede encontrar?
1.3. Métodos, propiedades (set, get), constructores y sobrecarga.
Para este apartado, debemos volver hacer una pausa para

remitirnos al texto básico, Capítulo 8, Secciones 8.4 a la
8.7, y estudiar los detalles sobre los métodos, propiedades,
constructores, sobrecarga y referencias this.
¿Qué tal estuvo el estudio? Si lo hizo con pausa, estudiando bien, y practicando
con los ejercicios del texto básico (que los puede descargar desde el sitio web
de la editorial del texto básico, para no digitarlos y así compilarlos y ejecutarlos
directamente en consola), de ser así, ya conoce que son los métodos de una
clase, para que sirven, como se los define (para devolver o no, valores), y por que
se configura sus niveles de accesos con las palabras reservadas public, private y
protected.
Es por ello que en este apartado deseo puntualizar más aún, sobre dos tipos
de métodos muy conocidos y que los reviso también con la lectura de su texto

básico, Sección 3.2.; me refiero a los métodos o también llamadas propiedades:

establecer([lista de parámetros opcional]) o set([lista de parámetros opcional]) –
en ingles – y obtener() o get().
Todos los atributos de una clase tienen un fin, y es que un objeto (que nace
desde una clase), no podría ser descrito en “QUE ES”, si la clase que origino
estos objetos no contiene atributos que describan a los objetos. Aquí es donde
entra el método o propiedad establecer([lista de parámetros opcional]) o
set([lista de parámetros opcional]), que es el encargado de recibir en la lista de
sus parámetros entre paréntesis “( … )” los parámetros con valores de entrada
para los atributos de la clase, y set() los asigne, haciendo uso de la palabra
reservada this. Por buena práctica de programación, cada atributo de una clase
debe tener su respectivo setNombreAtributo(…), y así mismo su respectivo
getNombreAtributo(), que no recibe parámetro alguno de entrada, pero que si se
encarga de devolver el contenido o valor actual del atributo.
Adicional a las propiedades setNombreAtributo([lista de parámetros opcional]) y

getNombreAtributo(), existen los constructores, pero antes de resumirle de que
se trata, por favor:
Complementemos el estudio con el Capítulo 3, de

nuestro texto básico, Secciones 3.4 (y 3.5, – opcional),
para comprender el siguiente escenario que le indicare a
continuación, pausa aquí y estudiemos estas secciones del
texto básico citadas.
¿Que le pareció las secciones de estudio complementarias de los Capítulos 3 y

8, de su texto básico, interesante, ¿verdad?; de ser así, seguro podrá contestar a
la siguiente interrogante dadas las siguientes líneas de código:
9 // crear dos objetos Cuenta

10 Cuenta cuenta1 = new Cuenta ("Jane Green")
11 Cuenta cuenta2 = new Cuenta ("John Blue")

En las líneas de código 10 y 11 de la “Fig. 3.6 Uso del constructor de Cuenta para
inicializar la variable de instancia nombre al momento de crear el objeto Cuenta.”
de su texto básico:
1. ¿Se puede confirmas el dicho: “una clase es como un molde para crear
objetos” ?, y
2. ¿Con el mismo molde/clase, se pueden crear n número de objetos?, por
ejemplo, ¿cuáles objetos?
Si respondió bien, seguro va siendo consciente del potencial que tiene la POO en
cuanto a los principios de: encapsulamiento, y un poco de reusabilidad de código.
Bien, para que afiance su comprensión en estos temas, deseo dejarle la siguiente
código de clases (ver Figura 1.7 Clase Persona versión con constructores sobre
cargados y Figura 1.8 Clase TestPersona), y caso de estudio:
1 public class Persona {

2 //Atributos ó campos
3 public String sexo;
4 protected double edad;
5 public double estatura;
6 private double peso;
7 protected int numIdentidad;
8 public String estado;
9 //Constructores
10 public Persona() { }
11 public Persona(String sexo, double edad,
12 double estatura, double peso,
13 int numIdentidad, String estado) {
14 this.sexo = sexo;
15 this.edad = edad;
16 this.estatura = estatura;
17 this.peso = peso;
18 this.numIdentidad = numIdentidad;

19 this.estado = estado;
20 }
21 //Métodos SET (void), funciones GET (return)
22 public String getSexo() {
23 return sexo;
24 }
25 public void setSexo(String sexo) {
26 this.sexo = sexo;
27 }
28 public String getEstado() {
29 return estado;
30 }
31 public void setEstado(String estado) {
32 this.estado = estado;
33 }
34 }
Figura 1.7 Clase Persona versión con constructores sobre cargados
1 public class TestPersona {

2 public static void main(String[ ] args) {
3 Persona personaA = new Persona() ;
4 Persona personaB = new Persona("M", 34, 170,
5 75, 1105678432, "Activo") ;
6 personaA.setPeso(70);
7 System.out.printIn("Peso de PersonaA"
8 + "<"+ personaA.getPeso() +">");
9 System.out.printIn("Peso de PersonaB"
10 + "<"+ personaA.getPeso() +">");//
11 }
12 }
Figura 1.8 Clase TestPersona

Primer caso de estudio:
Cuando creamos un objeto (instanciando, referenciando, encapsulando una

clase), a quien se invoca luego de la palabra clase new, es al constructor de la
clase (sobrecargados o no); la sintaxis general para crear un objeto es:
Personas personaA = new Personas();

Personas personaB = new Personas();
Personas personaC = new Personas();
Nombre de Nombre del Invoca al Nombre del

la clase objeto constructor constructor
Dada esta puntualización, y dados los objetos personaA y personaB de

las líneas de código 3 y 4 de la Figura 1.8 Clase TestPersona, ¿qué se
muestra por pantalla con System.out.println() si dentro se invoca a todos los
getNombreAtributo() para cada objeto (personaA y personaB)?
Pista: por ejemplo, lo que se puede ver en la línea 9-10 de la Figura 1.8 Clase
TestPersona.
Solución
Si se ejecuta dentro de la clase TestPersona las siguientes instrucciones:
11 System.out.printIn(personaA.getSexo( )+","+personaA.getEdad( )+","+.

12 System.out.printIn(personaB.getSexo( )+","+personaB.getEdad( )+","+.
Las líneas de código que devolverán resultados son:
• En la línea de código nro. 11. únicamente el getPeso() devolverá un

valor (por la línea de código nro. 6, que asigna un valor para peso), ya
que el objeto personaA fue creado invocando al constructor vacío, el
cual inicializa a los todos los atributos de una clase, con sus valores
por defecto, 0 (cero) para los numéricos, false para los boléanos, y null
para las atributos de tipo String.

• En la línea de código nro. 12. cada uno de los getNombreAtributo()

si devolverán valores, por que el objeto personaB fue creado con
el constructor sobre cargado que si recibe parámetros y los asigna/
descarga a los atributos de su clase, puntualmente los valores que se
devuelven son: “M”,34,170,75,1105678432,”Activo”
Importante: Cuando una clase no define un constructor explícitamente, el

constructor se crea por defecto o implícitamente, pero vacío. Caso contrario, si
desea sobre carga de constructores, el vacío creado por defecto, en el escenario
anterior, ya no se crea.
Finalmente, y no menos importante, le sugiero revisar en su

texto básico, del capítulo 6, las secciones: 6.1, 6.2, 6.3,
6.4, 6.5, 6.9, 6.12 y del capítulo 8, las secciones: 8.11 a
la 8.13, que le garantizo le van a ser indispensables para
el desarrollo de Actividades, que debe entregar de forma
obligatoria dentro del EVA, con fines de evaluación de esta
asignatura.
1.4. Encapsulamiento, ocultación y paquetes.
Tal parece que “Encapsulamiento” viene de palabra “capsula”; que define

claramente a un objeto, en donde, tanto los datos como sus funcionalidades
están encerradas en la cápsula/objeto; 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.
Ahora bien, en cuanto a los paquetes, en Java un paquete es un contenedor de

clases que permite agrupar las distintas partes de un programa cuya funcionalidad
tiene elementos comunes.

Antes de poder importar una clase en varias aplicaciones, la clase debe colocarse
en un paquete. Solo puede haber una declaración package en cada archivo de
código fuente de Java nomClase.java.
Cada clase en la API de Java pertenece a un paquete que contiene un grupo de

clases relacionadas. Los paquetes ayudan a administrar la complejidad de los
componentes de una aplicación y facilitan la reutilización de software.
Finalmente, no se requiere de import cuando se desea usar una clase que esta
dentro de un mismo paquete, o si accedemos a sus miembros directamente con el
nombre de la clase.
Para ejemplificar en código lo anteriormente dicho, estudiemos la siguiente

imagen (ver Figura 1.9 Creación/distribución de Paquetes):
Figura 1.9 Creación/distribución de Paquetes
La Figura 1.9 Creación/distribución de Paquetes, se puede lograr con el uso de

cualquier IDE (para este se uso NetBeans) y dentro de un proyecto se puede
definir la distribución de cualquier número de paquetes deseados, con el fin de
organizar las clases relacionadas, dentro de un paquete específico. En este
ejemplo, se puede apreciar dos paquetes: PaqueteA y PaqueteB y dentro de

cada uno de ellos, las clases: ClaseA1 y ClaseA2 dentro del PaqueteA, y la
ClaseB1 dentro del PaqueteB.
En el código podemos verificar que dentro de la ClaseA2 que pertenece o esta

dentro del PaqueteA, se esta haciendo uso de la ClaseB1, la cual esta en un
paquete distinto, es por lo que, Java exige la importación de los paquetes, si en
X clase, se invoca una clase que no pertenece al paquete actual; en el ejemplo
anterior, la ClaseA2 debe importar al PaqueteB, y claro que lo hace como se
observa en la figura.
Ahora, antes de continuar con el estudio de los dos últimos

apartados de esta primera unidad del primer bimestre,
le sugiero desarrollar mínimo un ejercicio propuesto de
cada Capítulo (3, 6 y 8) de su texto básico, de hacerlo, le
garantizo el éxito no solo al adquirir las competencias de
esta unidad, sino certeza al aplicar estas habilidades en
escenarios de la vida real:
▪▪ Del Capítulo 3, ejercicios: 3.12, 3.13, 3.16.

▪▪ Del Capítulo 6, ejercicios: 6.8, 6.24, 6.26, y del
▪▪ Del Capítulo 8, ejercicios: 8.6, 8.8.
Y si desea verificar su .java, no dude solicitar las soluciones

al docente tutor de la asignatura.
1.5. Herencia.
La herencia es la característica que permite crear nuevas clases (subClases –

clases hijas) a partir de otras ya existentes (superClase – clases padre), para
reutilizar y mejorar sus componentes: atributos y métodos/funcionalidad.

Existen dos tipos de herencia: simple y múltiple, estas se soportan dependiendo

de las características del lenguaje de programación, por ejemplo, Java no soporta
la herencia múltiple (una alternativa al uso de herencia múltiple en Java son las
interfaces-interface). La herencia simple si esta soportada por Java, es por lo
que nuestro estudio en este apartado lo vamos a realizar en función que ella:
“herencia simple”.
Muy bien, como ya es nuestra costumbre, debemos

remitirnos a nuestra fuente oficial de consulta y estudio.
Este apartado lo vamos ha desarrollar con el Capítulo 9,
Secciones 9.1 a la 9.6. de nuestro texto básico.
Hora de la pausa y dedicación a la lectura y programación

(sobre todo de la Sección 9.4), solo así – programando
– podrá palpar, probar y asimilar cada concepto aquí
expuesto.
¿Listo?, ¿cómo le fue?, si, lo se, el capítulo es largo, pero si lo saltamos, o

revisamos superficialmente, créame que usted no conocerá uno de los pilares
fundamentales en el que se soporta este paradigma de programación orientado
a objetos POO, es por ello que le insisto revisar nuevamente este Capítulo 9,
practique, compile y ejecute los ejercicios expuestos en la Sección 9.4, por favor,
manos a la obra.
Si ya lo estudio de nuevo, estamos listos para hacer las siguientes

puntualizaciones y ejercicios, por que, sino practicamos, todo este paradigma va
ha quedar solo en la teoría.
En resumen, la herencia permite:
• Especializar o extender la funcionalidad de clases.

• Optimizar la cantidad de código.
• Diseño jerárquico de clases.
• Ocultamiento de información (encapsulamiento).

Se preguntará entonces, ¿y como se logra esto?, pues todo es fruto de un buen

diseño inicial de la jerarquía de clases, que parte del modelado del problema
origen e interpretación correcta de la relación “ES UN” a cumplirse entre las
clases hijas (subClases) y padres (superClases). Para comprenderlo, veamos la
siguiente ilustración:
Figura 1.10 Jerarquía de Clases Personal_UTPL
Como puede observar en la Figura 1.10 Jerarquía de Clases Personal_UTPL,

la herencia entre clases debe cumplir con la relación “es un”. Por ejemplo, los
Docentes ¡son! Personal_UTPL y los de Servicio, igual. Y los Investigadores
¡son! Docentes, quienes de igual forma ¡son! (mediante herencia indirecta)
Personal_UTPL. Es un error tratar de heredar de la clase Personal_UTPL hacia
la clase Laboratorios o Carreras (por ejemplo), dijo que es un error, por que aún
que los Laboratorios o Carreras, pertenecen a la UTPL, no es correcto decir
que, un Laboratorio ¡es un! Personal_UTPL, aquí la relación “es un” no se
cumple, es por lo que, el concepto de herencia no se puede aplicar en este caso,
pero agregación si.
Otro de los temas clave son: saber como aprovechar al máximo las capacidades
de la herencia, reutilizando código y ocultando información – con la definición

de los niveles de acceso –. Por ello le invito a reflexionar sobre las siguientes
ilustraciones de la mano de su texto básico.
Figura 1.11 Miembros protected en una jerarquía de herencia
• Dados los niveles intermedios de acceso (+public vs -private) de

cada atributo de cada clase de esta jerarquía: ¿cuales cree que son
heredados, accesibles, y desde donde?
• Lo protected de superClase son usados por la superClase (this), las
subClases (super) y otras clases del mismo paquete.
• Lo public y protected de superClase retienen su modificador de
acceso original cuando se convierten en miembros de subClase (se
heredan).
Figura 1.12 Uso del super

• Los métodos de subClase citan lo public y protected de la superClase

solo usando sus nombres (o this o super).
• Cuando un método de la subClase sobrescribe un método de la
superClase, este último puede utilizarse desde la subClase si se
antepone a su nombre la palabra clave super y un punto (.)
Figura 1.13 Invocando a los constructores
Al instanciar una subClase primero se llamad a los constructores de sus

superClases en cadena, explícita (con super) o implícitamente (constructor
predeterminado o sin argumentos). En esta jerarquía (de la Figura 1.13
Invocando a los constructores), ¿como será que se realiza esto?
Figura 1.14 Invocando a los constructores

• Si la superClase se deriva de otra clase, el constructor de la

superClase invoca primero al constructor de la siguiente clase que se
encuentre a un nivel más arriba (su clase padre). ¿udted podría indicar
como se realiza esto para la clase DirectorB?
• El último constructor que se llama en la cadena es siempre el de la
clase Object.
• El cuerpo del constructor de la subclase original termina de ejecutarse
al último.
Bien, me parece que ahora si esta listo para aplicar todo lo aprendido; es por lo
que le planteo el siguiente Estudio de Caso (1):
Estudio de caso (1):
Defina una jerarquía de herencia en la que se contemplen

los empleados de una empresa (operarios y gerentes),
guarde los nombres y sueldo; para los gerentes como un
tipo especial de empleados, almacene el departamento que
dirige y el nombre de su secretaria, para operarios, horas
laboradas. Realizar la especificación UML con las clases
implicadas.
Solución
Dado este caso lo primero y más importante es el análisis, haciendo la lectura

del caso las veces que sean necesarias, para comprender el problema y de ser
posible ser parte de él. Para esto se acostumbra a realizar apuntes, subrayados,
marcas, etc., a aquellos fragmentos del texto que me parezcan Clases, métodos,
atributos y requerimientos. El resultado del análisis del problema del Estudio de
Caso 1, es el siguiente:
ESTUDIO DE CASO (1) – Análisis: Defina una jerarquía de herencia en la

que se contemplen los empleados de una empresa (operarios y gerentes),
guarde los nombres y sueldo; para los gerentes como un tipo especial de

empleados almacene el departamento que dirige y el nombre de su secretaria,

para operarios, horas laboradas. Realizar la especificación UML con las clases
implicadas.
El paso siguiente es el modelado UML, en donde se diseña la jerarquía de

herencia (clases padre/superClases e hijas/subClases), se enlaza/heredan las
clases y se definen los métodos y atributos de cada una de ellas. Ver la solución
en la siguiente Figura 1.15 Solución de jerarquía de clases Empleado:
Figura 1.15 Solución de jerarquía de clases Empleado
Con el modelado UML, la codificación muy es sencilla, en lugar de pasara

directamente del problema a la codificación saltándose el diseño UML. Lo nuevo
aquí, es el uso de la palabra reservada extends por la cual heredamos lo público
y protegido, desde una clase padre o superclase hacia una clase hija o subClase.
Revisemos entonces la solución en la Figura 1.16 Solución codificada de jerarquía
de clases Empleado.
1 public class Empleado {

2 public String nombres;
3 private double sueldo;
4 public Empleado( ) { }
5 public Empleado(String nombres, double sueldo) {
6 this.nombres = nombres;
7 this.sueldo = sueldo;

8 }
9 public void setSueldo(double sueldo) {
10 this.sueldo = sueldo;
11 }
12 public double getSueldo( ) {
13 return sueldo;
14 }
15 }
16
17 class Gerente extends Empleado {
18 public String departamento;
19 public String secretaria;
20 public Gerente( ) { }
21 public Gerente(String departamento, String secretaria)
22 this.departamento = departamento;
23 this.secretaria = secretaria;
24 }
25 public Gerente(String departamento, String secretaria)
26 String nombre, double sueldo) {
27 super(nombres, sueldo);
28 this.departamento = departamento;
29 this.secretaria = secretaria;
30 }
31 @Override
32 public String toString( ) {
33 return String.format("Nombres: %s \nSueldo: %.2f \n"
34 + "Departamento: %s \nSecretaria: %s"
35 ,this.nombres, this.getSueldo ( ),
36 this.departamento,this.secretaria);
37 }
38 }
39
40 class Operario extends Empleado {
41 private double horasLaboradas;
42 private double costoHora;
43 public Operario ( ) { }
44 public Operario (double horasLaboradas) {
45 this.horasLaboradas = horasLaboradas;
46 }
47 public Operario(double horasLaboradas, String nombres,
48 double sueldo) { }
49 super(nombres, sueldo);
51 }

52 public void setSueldo(double horasLaboradas,Double costoHora) {

54 this.costoHora = costoHora;
55 this.setSueldo(thishorasLaboradas * this.costoHora);
56 }
57 @Override
58 public String toString( ) {
59 return String.format("Nombres: %s \nSueldo: %.2f \n"
60 + "Horas Laboradas: %.2f \n"
61 + "Costo por hora: %.2f"
62 ,this.nombres, this.getSueldo ( ),
63 this.horasLaboradas.
64 this.costoHora);
65 }
66 }
67
68 class Test EmpleadoGerenteOperar {
70 //Valida si el sueldo es mayor a cero para inicializar la variable.a
71 Gerente gerente1 = new Gerente("Comput. y Elect.",
72 "Laydi Sanmartin", "Juan Carrion", 100);
73 Operario operario1 = new Operario (46.50,
74 "Maria Vilareal", 200);
75 operario1.setSueldo(80, 20);
76 System.out.printIn("GERENTE 1\n=========\n"+gerente1);
77 System.out.printIn("\nOPERARIO 1\n=========\n"+operario1);
78
79 }
80 }
Figura 1.16 Solución codificada de jerarquía de clases Empleado

Enlace web: Ver o descargar el código desde este enlace en GitLab

¿Que le pareció?, ¿se cree capaz de resolver un caso de estudio por su cuenta?,
intentémoslo por favor; se lo propongo a continuación:
Estudio de caso (2):
Se desea realizar una aplicación que permita a los

mecánicos de un garaje registrar, consultar y actualizar
los trabajos (reparaciones y revisiones) que han sido
realizados o que están en proceso de realización en el
garaje.
Cada trabajo se identifica unívocamente por su

“identificador de trabajo”. El “identificador de trabajo”
es un número que se asocia con el trabajo en el momento
que se registra. El primer trabajo registrado tendrá el
identificador 0, el segundo el 1 y así sucesivamente. Los
trabajos incluyen una pequeña descripción de la reparación
o revisión a realizar. Al crear un trabajo el número de horas
es 0. El número de horas ira aumentando a medida que los
mecánicos van dedicando tiempo a realizar la reparación
o la revisión. Cuando el trabajo se ha finalizado se marca
como “finalizado” y el número de hora no puede volver a
cambiarse.
Las reparaciones incluyen el precio del material utilizado

(pieza o pintura): Al registrar una reparación el precio del
material es 0 y va aumentando a medida que los mecánicos
van utilizando material en la reparación. Una vez que la
reparación se manca como “finalizada” no se puede
cambiar el precio del material utilizado.
El precio a cobrar para cada trabajo se compone de dos

partes, una fija que resulta de multiplicar el número de
horas empleadas por $30; y la variable que, dependiendo
del tipo de trabajo, su coste varía de la siguiente manera:

▪▪ Reparación mecánica: su precio se calcula como fijo

más el coste del material multiplicado por el 1.1
▪▪ Reparación de chapas y pintura: su precio se

calcula como fijo más el coste del material multiplicado
por 1.3
▪▪ Revisión: su precio se calcula como fijo más un extra

de $20 independiente del número de horas.
El garaje se ha marcado unos plazos máximos en los que

deberían estar terminados los trabajos. Estos plazos son:
14 días para las reparaciones mecánicas, 21 días para las
reparaciones de chapas y pintura, y 7 para las revisiones. La
aplicación se gestionará mediante una aplicación basada en
menús, el cual permitirá: Registrar trabajos, Aumenta horas,
Aumenta coste de piezas, Finaliza trabajo, Muestra trabajo,
Consulta plazo y Muestra todos.
¿Estuvo fácil, difícil?, ¿al menos realizo el intento?, si no, hágalo por favor, las
competencias que se ponen a prueba aquí le van ha ser de total ayuda cuando
usted como Ingeniero Informático este frente a escenarios reales.
Para verificar su solución, le dejo el siguiente enlace, correspondiente a una de

las múltiples soluciones que podría desarrollar, Enlace Web Ver código en GitLab
(con esta solución, puede autogenerar el UML en cualquier IDE). Quedo atento
por los medios oficiales EVA-UTPL ante cualquier duda al respecto.
Para cerrar con broche de oro este importante apartado de

herencia, le sugiero desarrollar los ejercicios propuesto 9.5,
9.6, 9.8 y 9.15, de su texto básico.
Y si desea verificar su .java, no dude solicitar las soluciones

al docente tutor de la asignatura.

1.6. Polimorfismo.
El paradigma de programación orientado a objetos POO tiene muchas ventajas

frente a la programación estructural, estas ventajas se fundamentan en los
siguientes pilares fundamentales:
• Encapsulamiento.
• Abstracción.
• Herencia, y
• Polimorfismo
En los apartados anteriores de esta guía didáctica,

revisamos algunos pilares fundamentales de la POO de
forma implícita (encapsulamiento, abstracción) y explicita
(herencia), en este último ítem (1.6) estudiaremos el
cuarto: Polimorfismo. Para ello vamos a dirigir al Capítulo
10, Secciones 10.1 a la 10.6. de nuestro texto básico, y
haciendo la pausa académica de rigor, leamos, resumamos
y probemos cada definición que ahí se explica, compilando y
ejecutando los .java del texto básico.
¿Cómo le fue?, ¿Estuvo fácil, difícil?, si lo se, no es un tema en extremo sencillo

pero si muy importante, ya que lo va volver aplicar en asignaturas futuras de
nuestra carrera, por ejemplo en patrones de diseño que se estudia en la
asignatura de Arquitectura de Aplicaciones de octavo ciclo, entonces le pregunto:
¿Por qué esperar a estudiarlo en octavo ciclo Polimorfismo, si desde ahora lo
puede conocer y aplicar para la presente asignatura y para la vida profesional?.
Estoy seguro de que su respuesta fue positiva, para iniciar desde ahora
aprendiendo Polimorfismo.

Resumen de polimorfismo:
• Algo polimórfico es aquello que puede adoptar múltiples formas.

Propiedad capaz de atravesar numerosos estados.
• El polimorfismo permite “programar en forma general”, en vez de “forma
específica”.
• Se basa en confiar en que cada objeto sabrá como “hacer lo correcto”.
• Hace posible enviar mensajes sintácticamente iguales a objetos de
tipos distintos.
• El comportamiento de los objetos es individual y no tiene que ver con la
pertenencia del objeto a una jerarquía de clases (tipos de datos).
• “Polimorfismo” = muchas formas.
¿Que le parece este resumen sobre la definición de polimorfismo?, ¿corto pero

comprensible o algo ajeno a sus conocimientos previos obtenidos en la lectura
anterior del Capítulo 10 de su texto básico? De ser así, reflexionemos con las
siguientes ilustraciones:
Figura 1.17 Comportamiento Polimórfico de objetos

En la Figura 1.17 Comportamiento Polimórfico de objetos, las clases hijas

(subClases) Auto, Avioneta, Animal, de la clase padre (superClase) Transporte
tienen un comportamiento Polimórfico, por que pueden realizar las mismas
acciones, pero de diferente forma. Así se cumple la definición del Polimorfirmo,
que es: “hacer algo de muchas formas”.
Figura 1.18 Comportamiento Polimórfico – Clase Animal
Para concretar como se implementa el polimorfismo en el lenguaje Java,

revisemos la Figura 1.18 Comportamiento Polimórfico – Clase Animal, en la cual
se evidencia que la clase Padre (superClase), es abstracta por los siguientes
lineamientos que Deitel & Deitel resume a continuación:
• En algunos casos es conveniente declarar clases para las cuales

no tenemos la intención de crear instancias de objetos. A dichas
clases se les conoce como clases abstractas. Como se utilizan solo
como superclases en jerarquías de herencia, nos referimos a ellas
como superclases abstractas. Estas clases no pueden utilizarse para
instanciar objetos, ya que están incompletas.

• El propósito principal de una clase abstracta es proporcionar una

superclase apropiada, a partir de la cual puedan heredar otras clases y,
por ende, compartir un diseño común.
• Las clases que pueden utilizarse para instanciar objetos se llaman

clases concretas. Dichas clases proporcionan implementaciones de
cada método que declaran (algunas de las implementaciones pueden
heredarse).
Para complementar lo anteriormente dicho, resumamos como se realiza la

codificación en Java del comportamiento polimórfico de la jerarquía de herencia
de la clase padre y subClases, Animal, Pez, Rana, Ave, respectivamente:
Figura 1.19 Codificación de la Clase Animal y subClases
La clase Animal (1) es abstracta por que su método mover() es abstracto,

mover() es abstracto con el fin de delegar a las clases hijas (subClases) de la
clase Animal, que sean ellas las encargadas de implementar la funcionalidad
de este método mover(), ya que solo ellas (las hijas) saben como realizar esta
acción, y no el padre. Por lo tanto, vemos que las clases hijas (subClases) Pez
(2), Rana (3) y Ave (4), implementan particularmente según ellas lo requieran, la
forma de mover los objetos pez, rana y ave.

Figura 1.20 Prueba de la jerarquía de Clases Animal
La definición de polimorfismo “hacer algo de muchas formas” se evidencia en

las lineas:
Animal pez = new Pez();

Animal rana = new Rana();
Animal ave = new Ave();
Por que al presentar el contenido/comportamiento de los objetos pez, rana y

ave, almacenados en el ArraysList animales, confirmamos que efectivamente
cada animal (objeto), se mueve de forma singular, particular o independiente,
como se puede observar en los resultados mostrados por la consola “Output -
NomProyecto (run)”
Es una muy buena práctica de estudio, que al finalizar la

revisión de cada uno de los Capítulos 3, 6, 8, 9 y 10 de su
texto básico, responda a los ejercicios de autoevaluación.
Las respuestas las encuentra dentro del mismo texto
básico (con fines de verificación).

Autoevaluación 1
Estimado estudiante hemos finalizado el estudio de la presente unidad y es el

momento de auto medir su nivel de: conocimiento, comprensión, aplicación,
análisis, síntesis y evaluación, sobre la “Programación Orientada a Objetos”,
con la presente Autoevaluación que busca lograr en usted el siguiente Resultado
de Aprendizaje (R.A):
“Entender y aplicar los conceptos de Programación Orientada a Objetos/

Herencia/Polimorfismo en el desarrollo de programas en el lenguaje Java”
Instrucciones:
▪▪ Lea, revise, analice y evalué cuidadosamente cada uno de los numerales,

luego compare, relacione, aplique, organice y seleccione el literal de la
alternativa que mejor defina, corrija, complete o responda a los conceptos,
códigos, diagramas, etc. que se plantean a continuación.
▪▪ De las cuatro alternativas, más de una le podrá parecer correcta, pero no es

así; existe una única solución: (A), (B), (C), o (D).
▪▪ Anote sus respuestas, para que al final sea usted quien juzgue, califique
y autoevalúe, su nivel de competencias adquiridas, comparando con el
solucionario adjunto al final de esta guía de estudios.
1. Cada declaración de clase que empieza con la palabra clave ________ debe
almacenarse en un archivo que tenga exactamente el mismo nombre de la
clase, y que termine con la extensión de nombre de archivo .java.
A. new
B. extends
C. abstract
D. public
2. Es posible codificar varias class dentro de un mismo archivo .java con el

fin de apreciar en un conjunto todas las clases, sin embargo, solo una clase
debe ser definida como pública (public) y esta debe tener:
A. El mismo nombre del archivo .java con el que se guarda todo el código.
B. Distinto al nombre con el que se guardo el archivo .java.
C. Cualquier nombre, ya que esto no es importante al momento de
compilar.
D. La clase de object como super clase asignada por jerarquía.
3. El diagrama UML ofrece un resumen de la estructura de una clase.

Mostrando en un rectángulo cada grupo de componentes de la clase.
Considerando lo anterior ¿cuál de los siguientes diagramas corresponde al
código adjunto?
1 public class LibroNotas {

2 private String nombreCurso;
3
4 public LibroNotas(String nombre) {
5 nombreCurso = nombre;
6 }
7 public void establecerNombreCurso(Sring nombre) {
8 nombreCurso = nombre;
9 }
10 }
LibroNotas
- nombreCurso: String
<<constructor>> LibroNotas( nombre: String)
A. + establecerNombreCurso( nombre : String)
- nombreDelCurso: String
LibroNotas
+ establecerNombreDelCurso( nombre : String)
B. <<constructor>> LibroNotas( nombre: String)
<<constructor>> LibroNotas( nombre: String)

LibroNotas
+ nombreDelCurso: String
C. + establecerNombreCurso( nombre : String
LibroNotas
+ nombreDelCurso: String
-<<constructor>> LibroNotas( nombre: String)
D. + establecerNombreCurso( nombre : String)

4. Un molde es para un pastel, lo que una clase es para un (a) _______.
A. Atributo
B. Método
C. Objeto
D. Uml
5. La palabra clave _______solicita memoria del sistema para almacenar un

objeto, y después llama al constructor de la clase correspondiente para
inicializarlo.
A. new
B. extends
C. Object
D. class
6. Cada parámetro de entrada hacia los métodos debe especificar un (a)

________ y un (a) ________.
A. nivel de acceso - tipo

B. nivel de acceso - nombre
C. tipo - nombre
D. public, private - nombre
7. Cuando cada objeto de una clase mantiene su propia copia de un atributo, el

campo que representa a este atributo se conoce también como ________.
A. referencia
B. variable global
C. variable local
D. instancia

8. Una clase es como un molde para crear objetos (análogamente hablando),

donde dicho objeto tiene atributos y métodos que definen lo que es y lo que
hace.
Dado ello, algunos de los métodos de la clase Libro son: _______.
A. editorial( ), ciudad( )
B. hojas, letras
C. numeros, anaquel
D. leer( ), abrir( )
9. La siguiente es una lista de palabras arbitrarias, indique cuales de los

siguientes conjuntos de palabras tienen relación directa con los conceptos
de POO en java.
A. int, doublé, String, char

B. set, get, private, public
C. switch, case, while
D. import, javac, main, for
10. Dado el siguiente flujo, indicar cual de las siguientes afirmaciones es

verdadera:
1 public class MiClase {

2 private double a;
3 public String b;
4 protected boolean c;
5 public void setA(double a) {
6 this.a = a;
7 }
8 public double getA( ) {
9 return a;
10 }
11 }

A. El atributo b es accesible solo dentro de la misma clase MiClase().

B. Todos los atributos de la clase, son accesibles solo dentro de la clase.
C. El atributo a es accesible solo dentro de la misma clase MiClase() y no
fuera de ella.
D. this.a = a, es equivalente a poner a = a, y funciona de igual forma.
11. Cada método puede especificar parámetros que representan la información

adicional requerida por el método para realizar su tarea correctamente. La
llamada a un método suministra valores (llamados argumentos) para los
parámetros del método.
Dado la puntualización anterior, ¿cuál es el resultado que se muestra por
pantalla si ejecutamos el siguiente flujo?

2 System.out.printIn(metodoA(3, 1));
3 }
4 public static int metodoA(int a) {
5 return a+a;
6 }
7 public static int metodoA(int a, int b) {
8 return a-b;
9 }
A. 2
B. 3
C. 4
D. 0
12. A los métodos get() se les llama comúnmente _______ o _______.
A. constructores – métodos creados por defecto

B. métodos de inicialización – constructores
C. métodos de inicialización – métodos de asignación
D. métodos de acceso – métodos de consulta

13. Dado el siguiente flujo, ¿Cuál es la sentencia que se debe escribir dentro de
los paréntesis de la línea de código número 5 para invocar al método sumar
enviando num para ser sumado y retornado dicho resultado?
1 class TestCalc {
3 int num[ ] = {1, 2, 3};
4 Calculadora calc = new Calculadora ( );
5 System.out.printIn(_______);
6 }
7 }
8
9 class Calculadora {
10 public int sumar(int arreglo[ ]) {
11 int suma = 0;
12 for(int num : arregle)
13 suma+=num;
14 return suma;
15 }
16 }
A. sumar(num)
B. calc.sumar(num)
C. calc.sumar(num[3])
D. Calculadora.sumar(num[ ])
14. Defina una clase Forma que tenga los siguientes miembros: color,
coordenada del centro, y nombre de la forma; luego derive Rectangulo
que tenga los siguientes miembros/datos: lado menor, lado mayor; y las
funciones: Calcular el área (lado menor * lado mayor); y Calcular el perímetro
(2 * lado menor) + (2 * lado mayor).

Dado este escenario, indique el valor de verdad de las siguientes

afirmaciones.
AFIRMACIÓN
1. Forma es superclase y Rectangulo subclase.
2. Atributos de Rectangulo se inicializan en su constructor.
3. Las funciones de cálculo se heredan hacia Forma
4. Las funciones de cálculo no se deben sobrecargar.
A. Verdadero – Verdadero – Verdadero – Falso

B. Falso – Falso – Falso – Verdadero
C. Verdadero – Falso – Falso – Verdadero
D. Verdadero – Verdadero – Falso – Verdadero
15. Dado el siguiente diagrama de clases, indicar cuál de las operaciones es

correcta a la hora de acceder a los miembros de la jerarquía, pero desde la
clase docente
Nota: en cada clase (diagrama UML), el primer bloque (recuadro) pertenece
al nombre de la clase, el segundo a los atributos o campos de la clase y el
último pertenece a las sus operaciones o métodos.
A. this.sueldo = 0.5 * this.cargo

B. this.sueldo = 0.5 + bonificaciones();
C. this.sueldo = this.horas + 150;
D. empleado.cargo = categoria.publica();

16. Dado el siguiente flujo correspondiente a una jerarquía de clases; una

alternativa para inicializar todos los atributos de la superClase Vehiculo
dentro de la subClase Camioneta es:
1 public class Vehiculo {

2 public String duenio;
3 private int puertas, ruedas;
4 public Vehiculo ( ) { }
5 public Vehiculo(String duenio) {
6 this.duenio = duenio;
7 }
8 public Vehiculo(String duenio, int puertas, int ruedas) {
9 this.duenio = duenio;
10 this.puertas = puertas;
11 this.ruedas = ruedas;
12 }
13 }
14 class Camioneta extends Vehiculo {
15 public double carga;
16 public Camioneta(double carga, String duenio, int puertas, int ruedas) {
17 super (duenio, puertas, ruedas);
18 this.carga = carga;
19 }
20 }
Pista: La alternativa se refiere a una alternativa distinta a la línea de código

nro. 17. ya que ahí, si se inicializan todos los atributos de la supeClase.
A. super(duenio); puertas=puertas; ruedas=ruedas;

B. this.duenio=duenio; this.puertas=puertas; this.ruedas=ruedas;
C. duenio=duenio; puertas= puertas; ruedas=ruedas;
D. super(duenio); super(puertas); super(ruedas);

17. Crear una clase base denominada Punto que conste de las coordenadas
coorX y coorY. A partir de esta clase, definir una clase denominada Circulo
que tenga las coordenadas del centro y un atributo denominado radio. Entre
las funciones miembro de una clase deberá existir una función distancia()
que devuelva la distancia entre dos puntos.
Dado es requerimiento, y con el fin de aprovechar al máximo la herencia; ¿a
que clase debe pertenecer la función distancia().?
A. Circulo
B. Punto
C. Distancia
D. Coordenadas
18. El siguiente, es un diagrama de clases en el cual se modelan las

funciones que tiene los empleados de la empresa “Mi Empresa S.A”. Dado
ello, ¿cuál(es) es(son) el(los) método(s) que administrativo y docente
comparte(n)/heredan?
A. empleado(nombre, numeroHoras, costoHora)

B. calcularSueldoBase()
C. calcularBonificacionCargo()
D. calcularBonificacionCategoria()

19. Dado el siguiente UML de la jerarquía de clases abstracta Animal, indicar

cual de las siguientes sentencias no siguen un comportamiento Polimórfico,
y están mal definidas.
A. Animal pez = new Pez();

B. Animal rana = new Rana();
C. Animal ave = new Ave();
D. Animal pez = new Animal();
20. Dada la siguiente imagen que ilustra el comportamiento polimórfico de la

jerarquía de clases, ¿cuales son los métodos que deberían ser abstractos?
A. Avanzar()
B. Frenar()
C. Avanzar() y Frenar()
D. Auto, Avioneta y Animal

UNIDAD 2. GESTIÓN DE EXCEPCIONES EN JAVA
“La confianza en uno mismo es el resultado de un

riesgo que superamos con éxito”.
- Jack Gibb
Estimado estudiante, continuamos en este mundo de la programación con el

estudio del Manejo de Excepciones en Java. Para ello es importante que
primero comprendamos que es una excepción: algo fuera de lo común, que
no se adapta a una regla o ley específica, es decir, que ocurre casi nunca. En
el mundo de la programación, una excepción es un “error” o “problema” poco
habitual que se sale de un proceso o flujo normal, para los cuales los programas
fueron concebidos. En esta unidad vamos a revisar con más detalle estas
definiciones, algunos ejemplos/escenarios en los cuales podrían ocurrir estos
casos excepcionales y como Java permite gestionarlos para lograr sistemas mas
robustos y tolerantes a fallos, por ello iniciemos con los fundamentos al respecto:
2.1. Fundamentos sobre el manejo de excepciones.
Java permite gestionar errores (situaciones excepcionales) que pueden ocurrir

(lanzarse) en tiempo de ejecución de un programa, gracias a un conjunto de
clases (contenidas en su API paquete java.lang, y otros) por las cuales se
capturan y tratan. Pero antes de gestionar estos errores, es importante conocer
teóricamente: que es una excepción, cuales son sus tipos, si ocurren (lanzan) de
forma síncrona y/o asíncrona, que jerarquía manejan, y otros fundamentos; con
el fin de no caer en la típica falla del programador de tratar cualquier error como
una excepción, lo que elevaría el consumo de recursos de procesamiento a sus
sistemas.
Por lo anterior, le invito a revisar detenidamente dichos

fundamentos y ejemplos en su texto básico: Capítulo 11,
Secciones 11.1 a la 11.4, y luego a reflexionar al respecto
de los siguientes casos que le planteo a continuación:

Primer caso:
Dados los ejemplos de las Fig. 11.2 y 11.3, de su texto básico, ¿Ud. cree que
realmente, el manejo de excepciones permite a un programa recuperarse de un
error acontecido en tiempo de ejecución, si, no, y por que?
Solución
Por supuesto que si, y eso es precisamente lo que hace que los
sistemas sean más estables y tolerantes a fallos; como vemos en el
DivisionEntreCeroSinManejoDeExcepciones.java, el programa termina su
ejecución repentinamente sin avisar al usuario con exactitud que es lo que paso
cuando se lanza un error (ya que no se gestionan las excepciones), pero en el
DivisionEntreCeroConManejoDeExcepciones.java, el programa si se logra
recuperar tanto por el manejo de excepciones (bloque try-catch) como por el
bloque repetitivo do-while.
Para verificar lo anterior, le sugiero descargar los .java

(desde el sitio web del texto básico, indicado en el apartado
de Bibliografía de esta guía), compile y ejecute en consola
(o con el IDE de su preferencia) y compare los resultados
obtenidos.
Segundo caso:
Algo nuevo en el Java SE 7 y Java 8, es el multi-catch (mencionado en la sección

11.3), revise de que se trata y luego, modifique el .java de la Fig. 11.3 de su texto
básico, atrapando todas las excepciones posibles en un solo bloque catch, y
comente cuales son las ventajas acerca del Modelo de terminación del manejo de
excepciones. ¿Hay ventajas, desventajas, cuales son?

Solución
Claro que resulta ventajoso agrupar excepciones de tipo similar, ya que reduce
el código y el tratamiento de errores atrapados; sin embargo, podría resultar
también contraproducente sino se categorizan o agrupan de forma correcta,
llevándonos a gestionarlos de la misma manera cuando se lo debería hacer de
forma individual, y así facilitar al programador y usuario información y soluciones
más personalizadas. En el siguiente fragmento de código, revisemos como queda
la solución con multi-catch. (Ver la Figura 2.1 Solución con multi-catch.).
32
33 } // fin de bloque try
34 catch(InputMismatchException | ArithmeticException inputMismatch_arithmetic_Exception)
35 {
36 System.err.printf( "\nExcepcion: %s\n", inputMismatch_arithmetic_Exception );
37 explorador.nextLine( ); // descarta entrada para que el usuario intente otra vez
38 System.out.printIn("Debe introducir enteros diferentes de cero.Intente de nuevo.\n);
39 } // fin de bloque catch
40 } while (continuarCiclo ); // fin de do...while
41
Figura 2.1 Solución con multi-catch.
Siempre que este revisando, compilando y/o ejecutando

cualquier .java de su texto básico y no comprenda algún
fragmento de código, no olvide que todas y cada una de
las líneas están perfectamente explicadas evidenciando
sus resultados en consola gracias al “Método de Código
Activo”, el cual expone, documenta y dilucida cada línea.
Y si, a pesar de toda la explicación que tiene en su texto
básico, sigue sin comprender partes o la totalidad del
ejercicio, planteé su inquietud en el EVA, que con gusto su
docente y/o compañeros ayudaremos a resolver sus dudas.

2.2. Las excepciones en el API de Java.
Java al ser un lenguaje multiplataforma orientado a objetos, tiene toda su API

(Application Programming Interface) organizada en paquetes, interfaces y clases,
es por ello que las excepciones que heredan de la clase Throwable, estan
empaquetadas (organizadas, guardadas) en el paquete java.lang (y otros) y
dentro de él, perfectamente documentadas, (la información a detalle la puede
revisar en el API de java, ver la Figura 2.2 Application Programming Interface (API
de Java). y la Figura 2.3 Application Programming Interface (API de Java). Clase
Exception.).
Figura 2.2 Application Programming Interface (API de Java).

Tomada de: Enlace web, https://docs.oracle.com/javase/8/docs/api/

Figura 2.3 Application Programming Interface (API de Java). Clase Exception.

Dentro de esta API, podemos conocer:
• Como están estructuradas las clases.

• A que paquetes pertenecen.
• Cuantos constructores tienen las clases.
• Que métodos existen para un objeto dado.
• Que propiedades tiene el objeto dado.
• La jerarquía de una o varias clases determinadas.
• La cantidad y tipo de parámetro que recibe/devuelve un constructor o
método.
• La descripción de lo que hace un método.
• El tipo de excepción que se debe controlar en el método.
• Nivel de acceso de los métodos (static, public, private, protected).
Y más información de relevancia para el programador.

Ahora llego la hora de estudiar de la mano de nuestro

texto básico, por ello le invito abrirlo en el Capítulo 11,
Secciones 11.5, y revisar que dice al respecto, la Jerarquía
de excepciones en Java, como esta organizada, que son
las excepciones verificadas y no verificadas, entre otros
temas de vital importancia que hay que conocer antes de
implementar el Manejo de Excepciones en Java.
Para complementar esto, le sugiero la Sección 6.8. del

Capítulo 6 de su texto básico.
¿Cómo le fue con la lectura?, estoy seguro de que, si la realizo a conciencia

y comprendiendo, podrá participar de forma activa en la auto evaluación y
cuestionarios del EVA, en donde medimos el nivel de comprensión de este
apartado importante.
Para finalizar este tema deseo recalcar que, en Java toda la gran cantidad de
clases existentes heredan de la clase Object y toda esta jerarquía se muestra
en su documentación API. Le recomiendo que utilice desde el principio esta
documentación (API), ya que caerá en cuenta de que las clases se encuentran
agrupadas en paquetes y cuando utilicemos alguna en nuestros programas lo
primero que se debe hacer es importar el paquete que la contiene. Por ejemplo,
para gestionar las excepciones de tipo InputMismatchException, el paquete
que importaremos es el java.util como lo indica muy bien su API, (ver Figura 2.4
Application Programming Interface (API de Java). Clase InputMismatchException.
de esta guía, y la Figura nro. 11.3, línea de código 3 de su texto básico). Existen
algunos paquetes que son importados por defecto en nuestros programas .java
(por ejemplo el java.lang), y no requieren importación explicita.

Figura 2.4 Application Programming Interface (API de Java). Clase

InputMismatchException.
El la Figura 2.4 Application Programming Interface (API de Java). Clase

InputMismatchException., del API de java se puede apreciar que la clase
InputMismatchException y otras, pertenece al paquete java.util.
Muy bien, si llego a este punto, a finalizado el tema de

estudio sobre la Jerarquía de Excepciones en el API de
Java, por ello le reto a diagramar la jerarquía de clases
desde la clase padre Object, Throwable, …, etc. hasta las
clases FileNotFoundException y ObjectStreamException.
¿Cómo le quedo? ¿Estas dos (FileNotFoundException,

ObjectStreamException) son Excepciones Verificadas o No
Verificadas, por que?
Si le resulta complicado elaborar el diagrama, le sugiero

se ayude con la “Porción de la jerarquía de herencia de la
clase Throwable” que se muestra en la Fig. 11.4 de su texto
básico.

2.3. Uso de try-catch-finally.
El uso de las sentencias try-catch-finally es la principal forma de controlar las

excepciones en java, tal como se indica en el texto básico:
• En el bloque try se coloca las instrucciones que potencialmente

podrían generar esta situación.
• En el catch el código que atrapa y trata la excepción.
• Y en el finally se liberan recursos (memoria, archivos, conexiones a
DB, etc.), que no se hayan liberado en el try o en el catch.
La sintaxis de estas instrucciones es la siguiente (ver Figura 2.5 Sintaxis de la

instrucción try-catch-finally. de esta guía):
1
2 //......................
3 try {
4 //......................
5 / / .Lanza la Excepción. . . . . .
6 //......................
7 } catch (Exception exception) {
8 //......................
9 / / .Atrapa la Excepción. . . . . .
10 //......................
11 } finally {
12 //......................
13 / / .Liberación la Excepción. . .
14 //......................
15 }
16 //......................
17
Figura 2.5 Sintaxis de la instrucción try-catch-finally.

Nota: 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. Un try puede tener uno o mas catch asociados.
Bien, es hora de remitirnos a nuestro texto básico, Capítulo

11, Secciones 11.6, y documentarnos mejor sobre esta
estructura try-catch-finally con la introducción descrita ahí,
y el ejercicio de la Fig. 11.5 juntamente con su explicación
línea a línea. Hacer esto por favor, antes de pasar a la
lectura de las instrucciones throw y throws siguientes.
¿Como me le fue en la lectura? De haberlo hecho a conciencia, codificando,

compilando, ejecutando, modificando, etc. el ejemplo de la Fig. nro. 11.5 de su
texto básico, seguro que podrá interpretar la siguiente imagen (ver Figura 2.6
Ilustración sobre el manejo de excepciones. que ilustra los bloques try-catch),
¿verdad?, ¿que le dice la imagen?, ¿Cómo la interpretamos? Aún que resulte algo
graciosa, yo siempre la suelo colocar de ejemplo en mis clases presenciales para
jamás olvidar la sintaxis, y flujo de ejecución de estos bloques try-catch-finally
para el manejo/gestión de excepciones.
Figura 2.6 Ilustración sobre el manejo de excepciones.

Tomada de este enlace web

2.4. La instrucción throw-throws.
Listo, si ya conocemos bien como trabaja la estructura

try-catch-finally para la gestión de excepciones, es hora
de mirar dos clausulas (instrucciones) que complementan
el tratamiento este tipo de errores, por ello le invito a
remitirse nuevamente a nuestro texto básico, Capítulo 11,
Secciones 11.3 “Uso de la clausula throws” y Secciones
11.6 “Lanzamiento de excepciones mediante la instrucción
throw” y revisar estos apartados.
¿Cómo le fue con la lectura? En los apartados anteriores, ya había revisado estos
temas, sin embargo, se ha deseado retomarlos solamente para dejar puntualizado
lo siguiente:
La instrucción throws 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 debe
realizar en la línea de código que llama a este método (ver en el siguiente flujo,
Figura 2.7 Uso de las sentencias throws y throw. de esta guía, línea de código
nro. 2). En cambio, la instrucción throw permite lanzar de forma explicita una
excepción del tipo que deseado (ver en el siguiente flujo, la línea de código nro.
11., Figura 2.7 Uso de las sentencias throws y throw. de esta guía).

1
2 public static void main(String[] args) throws IOException {
3 probandoThrow_Throws();
4 }
5
6 public static void probandoThrow_Throws() throws IOException{
7 //.........................
8 try {
9 //................................................
10 //Se lanza la Excepción EXPLICITAMENTE con throw..
11 throw new IOException();
12 } catch (IOException ioException) {
13 //................................................
14 //Captura y resuelve la excepción IOException.....
15 //................................................
17 //................................................
18 //Captura y resuelve la excepción Exception.......
19 //................................................
20 } finally {
21 //................................................
22 //.Liberación de recursos.........................
23 //................................................
24 }
25 //.........................
26 }
27
Figura 2.7 Uso de las sentencias throws y throw.
Y para aclarar mucho más estas dos instrucciones que se

complementan, por favor, le sugiero codifique el código
anterior en cualquier .java, y verifique sus resultados, y
luego haga cambios en dicho flujo, y de contestación al
siguiente caso:
Primera caso:
¿Que sucede si eliminamos el throws IOException de la línea de código nro.

2 del flujo anterior – Figura 2.7 Uso de las sentencias throws y throw.? ¿Existe
algún error de compilación o ejecución? ¿Si, no, por qué?
Solución
Se genera un error de compilación, ya que en la línea de código nro. 6, Figura

2.7 Uso de las sentencias throws y throw. de esta guía, se esta informando
y generando de una Excepción Verificada y si alguien (cualquier otro método)

llama al método probandoThrow_Throws(), que es quien genera este tipo de

excepción especial (Verificada); el método que lo invoque debería atrapar la
excepción IOException, a pesar de que el método probandoThrow_Throws si
este gestionando (atrapando) la excepción en sus respectivos bloques try-catch
(líneas de código 12 y 16). La solución de este primer caso podrían ser cualquiera
de las dos siguientes (según convenga):
1
4 }
5
6 public static void probandoThrow_Throws() {
7 //.........................
8 try {
9 //................................................
13 //................................................
15 //................................................
16
Figura 2.8 Primera solución antes el uso de las sentencias throws y throw.
En esta primera solución: (más sencilla o corta – Figura 2.8 Primera solución
antes el uso de las sentencias throws y throw. de esta guía), podemos observar
que las clausulas throws IOException, se han eliminado de las cabeceras
tanto del método main(), como del método probandoThrow_Throws(), dejando
así la gestión interna de la excepción IOException únicamente al método
probandoThrow_Throws(). – línea de código nro. 12. - Figura 2.8 Primera
solución antes el uso de las sentencias throws y throw. de esta guía.
Nota: Cuando se lanza una excepción verificada de forma implícita o explicita,

el compilador siempre solicita se la gestione en los respectivos bloques try-catch.
Esto no ocurre con las excepciones no verificadas.

1
3 try {
5 } catch (Exception e) {
6 //................................................
8 //................................................
9 }
10 }
11
12 public static void probandoThrow_Throws() throws IOException{
13 //.........................
14 try {
15 //................................................
19 //................................................
21 //................................................
23 //................................................
25 //................................................
26 } finally {
27 //................................................
28 //.Liberación de recursos.........................
29 //................................................
30 }
31 //.........................
32 }
33
Figura 2.9 Segunda solución antes el uso de las sentencias throws y throw.
En esta segunda y última solución: (Figura 2.9 Segunda solución antes el uso
de las sentencias throws y throw. de esta guía), observamos que se hace una
doble gestión de la excepción IOException, en los bloques de código try-catch,
tanto del método main() (bloque 3-9 ), como del método probandoThrow_
Throws() (bloque 14-21).
Nota: Si atrapamos la excepción Exception – línea de código nro. 5 – al ser clase

padre de todos los demás tipos de excepciones (subclases), se atrapan por
defecto todas las demás, ello incluye a la excepción IOException, que se esta
lanzando explícitamente por las clausulas throws IOException de la línea de
código nro. 12.
2.5. Generar excepciones propias.
La creación de excepciones propias es una ventaja en Java por su naturaleza

Orientado a Objetos (POO) y por que las clases que permiten el tratamiento de las
excepciones son de definición pública como se muestra a continuación y se pude
verificar desde su API:

• public class Throwable {…}

• public class Exception {…}
Esto se hizo a propósito, ya que los desarrolladores de aplicaciones, librerías,

Api’s, etc. de libre acceso, podrían requerir generar sus propias excepciones para
casos puntuales, y necesitar de la flexibilidad del lenguaje para hacerlo. Java lo
permite y es muy sencillo.
¿Desea conocer por que, cuando y como generar sus

propias excepciones?, seguro que si; por tanto, le invito a
remitirse a su texto básico, Capítulo 11, Sección 11.9,
fundamentarse teóricamente, y luego revise el ejemplo de
las Fig. 21.03 y siguientes, según se indica en: “Ejemplos
de una clase de excepción personalizada”. (La Fig. 21.03 la
localiza en los ejercicios en ingles del capítulo 21 adjuntos
en el sitio oficial del texto básico – url indicada en la
bibliografía de esta guía).
¿Cómo le fue con la lectura? ¿Logró revisar (compilar y ejecutar) los ejercicios de
las Fig. 21.03 y siguientes (carpeta fig21_03_05)?. Si no lo pudo localizar online,
los ejercicios de cada capítulo de su texto básico están publicados en su EVA o
en la URL indicada en bibliografía de esta guía, desde ahí los puede descargar.
Si lo hicimos bien, o no tanto, creo pertinente resumamos este último tema de la
segunda unidad, antes de pasar a nuestra autoevaluación.
Resumen de creación de excepciones propias:
Como ya se dijo inicialmente, una excepción propia es una clase que el

desarrollador crea, pero a partir de la clase Exception (o subClases) que es la
clase padre de todas las excepciones derivadas, y que gestionan los errores de
forma particular y según un objetivo específico.
Por ejemplo, en la siguiente Figura 2.10 Jerarquía de Clase para la creación

de una Excepción Propia., que cita un fragmento de la jerarquía de
excepciones contenidas en Java, he decidido crear mis dos excepciones

propias: MiExcepcionPropia_A (marcada de color degradado azul y blanco),

y MiExcepcionPropia_B (marcada de color degradado amarillo y blanco).
Estas dos excepciones son clases hijas de la clase Exception, y así lo deben
ser, ya que son EXCEPCIONES que yo como desarrollador he dedicido
crear. MiExcepcionPropia_A que hereda/se deriva directamente de la clases
Exception, y MiExcepcionPropia_A que hereda/se deriva directamente de la
clase ArithmeticException a indirectamente de RuntimeException y a su vez
de Exception. Ello no me parece muy dificil de comprender de forma gráfica,
como se muestra en la Figura 2.10 Jerarquía de Clase para la creación de una
Excepción Propia., a continuación:
Figura 2.10 Jerarquía de Clase para la creación de una Excepción Propia.
¿Se comprende la Figura 2.10 Jerarquía de Clase para la creación de una

Excepción Propia.?, seguro que si, caso contrario le invito a reflexionar
nuevamente sobre el paradigma de Programación Orientada a Objetos. Luego
de comprender esta jerarquía de herencia, revisemos como esto (Figura 2.10
Jerarquía de Clase para la creación de una Excepción Propia.) se traduce al
lenguaje de programación en los .java respectivos:

Ejemplo
Una excepción propia por definición debe ser una clase, es por ello que,
MiExcepcionPropia_A (marcada de color degradado azul y blanco en la figura
anterior) se codifica como un public class, pero al ser una nueva excepción que
nosotros deseamos definir, debemos heredarla/derivarla de la clase Exception
o cualquiera de sus SubClases (clases hijas) según se tenga la necesidad.
Esta herencia o derivación en código java, se lo hace usando la palabra clave
extends seguido del nombre de la clase Padre, de quien se hereda/deriva nuestra
excepción propia. En la Figura 2.11 Codificación de MiExcepcionPropia_A. línea
de código 2, podemos revisar como se hace:
1
2 public class MiExcepcionPropia_A extends Exception {
3 // Constructor sobre cargado 1
4 public MiExcepcionPropia_A( )
5 {
6 this("Error de División para cero"); // Llama al otro constructor sobre cargado
7 }
8
9 // Constructor sobre cargado 2
10 public MiExcepcionPropia_A(String msjError)
11 {
12 super(msjError + "aqui"); // Llama al otro constructor de la super clase Exception
13 }
14 }
15
Figura 2.11 Codificación de MiExcepcionPropia_A.
La excepción propia MiExcepcionPropia_A, define dos constructores,

uno que no recibe parámetros, y el segundo que si lo hace; esto permite
personalizar el mensaje de error a mostrar, cuando la Excepción Propia
MiExcepcionPropia_A es invocada. En la clase ProbandoExcepcionPropia.
java de la Figura 2.12 Probando la Excepción Propia MiExcepcionPropia_A. A
continuación, podemos mirar como se lanza de forma explicita la excepción propia
MiExcepcionPropia_A, haciendo uso de la palabra clave throw lo que permite

que se invoque al constructor que no recibe parámetros (fragmento de código 4-7

de la Figura 2.11 Codificación de MiExcepcionPropia_A.), y por tanto mostrar el
mensaje de error definido en ese constructor. Caso contrario, si lo que se desea
es lanzar explícitamente MiExcepcionPropia_A (con throw) pero invocando
al constructor con parámetros (fragmento de código 10-13 de la Figura 2.11
Codificación de MiExcepcionPropia_A.), la sentencia debería ser así:
throw new MiExcepcionPropia_A(“Aquí va mi mensaje personalizado de error”);
1
2 import java.util.Scanner;
3
4 public class ProbandoExcepcionPropia {
5
7 Scanner teclado = new Scanner(System.in);
8 int numero1 = teclado.nextInt ( );
9 int numero2 = teclado.nextInt ( );
10 int division;
11 try {
12 if (numero2! = 0)
13 division = numero 1 / numero 2;
14 else
15 throw new MiExcepcionPropia_A( );
16 } catch (Exception excepcion) {
17 excepcion.printStackTrace( );
18 }
19
20 }
21 }
22
Figura 2.12 Probando la Excepción Propia MiExcepcionPropia_A.

Finalmente, para afianzar los conocimientos adquiridos en

esta unidad, le sugiero desarrollar los siguientes ejercicios:
▪▪ Del Capítulo 11, ejercicios: 11.16, 11.18, 11.20, 11.21
Estos le van a ayudar aplicar cada apartado revisado en

esta unidad. Si desea verificar sus .java, no dude solicitar
las soluciones al docente tutor de la asignatura.

Autoevaluación 2

análisis, síntesis y evaluación, sobre la “Gestión de Excepciones en java”, con
la presente Autoevaluación que busca lograr en usted el siguiente Resultado de
Aprendizaje (R.A):
“Identificar y aplicar las estrategias de control de excepciones en flujos de

código propensos a fallos.”
Instrucciones:


1. La gestión de excepciones se realiza dentro de los bloques try - catch, en

donde, en el bloque try se coloca el código que podría ____________ la
excepción; y en el bloque catch el código que ____________ la excepción.
A. generar – maneja
B. manejar – genera
C. capturar – genera
D. manejar – limpia
2. En Java una excepción se define como:
A. Un segmento de código que garantiza la ejecución sin ninguna

interrupción.
B. Prevención de ocurrencia de excepciones a través de la cláusula throw.
C. Una alerta encendida (problema) en la ejecución de un segmento de
código.
D. La posibilidad mayor al 90% de ocurrencia de errores en el código
Java.
3. Cuando ocurre una excepción que es capturada en el respectivo bloque try,

el control del programa se transfiere al ______________ que maneja el tipo
de excepción lanzada; luego, el control del programa ____________ al punto
de lanzamiento de la excepción (bloque try), y continua su flujo secuencial
definido.
A. try subsecuente – no regresa

B. bloque catch – no regresa
C. bloque catch – regresa
D. bloque try – no regresa
4. Todo bloque _____ debe tener al menos _____ bloque(s) _____ para el
manejo correcto de una excepción.
A. catch – dos – try

B. try – dos – catch
C. catch – cero – try
D. try – un – catch

5. Considerando el siguiente flujo de control de errores:
CONTROL DE ERRORES
Realizar una tarea
Si la tarea anterior no se ejecutó correctamente

Realizar el procesamiento de los errores
Realizar la siguiente tarea
Si la tarea anterior no se ejecutó correctamente

Realizar el procesamiento de los errores
…
La estructura de control JAVA que se debe implementar es:
A. while
B. for
C. try – catch
D. if – else
6. Considerando el siguiente flujo, ¿cuáles y en qué orden, se deben capturar

las excepciones que se podrían lanzar?
1 Scanner teclado = new Scanner(System.in);

2 int numA = 32, numB = 2, resp = 0
3 int array [ ] = {2, 8, 4, 0}
4 try {
5 resp = array[ 2 ] / array[ 2 ]
6 numB = teclado.nextInt( );
7 } catch (ClaseExcepcionN1 claseExcepcionN1) {
8 System.out.printIn("Error: Clase de excepcion N1");


15 }
CLASE DE EXCEPCIÓN
Nl NullPointerException
Ru RuntimeException
Ex Exception
Cc ClassCastException
At ArithmeticException
Ip InputMismatchException
Io IOException
Ar ArrayIndexOutOfBoundsException
A. N1=Ex; N2=At; N3=Ar; N4=Ip

B. N1=Ex; N2=Ar; N3=Ip; N4=At
C. N1=Ar; N2=At; N3=Ip; N4=Ex
D. N1=Ex; N2=Ru; N3=Ru; N4=Ru
7. Se propone un flujo de control de excepciones y sus respectivos bloques 1-4

(subflujos):
1 /* Bloque 1 */
2 try {
3 /* Bloque 2 */
5 /* Bloque 3 */
6 }
7 /* Bloque 4 */

¿Considerando los siguientes escenarios, cuales son los bloques/subflujos,

que se ejecutarían?
ESCENARIO BLOQUES EJECUTADOS

x.) Sin excepciones: _________________________
y.) Con una excepción en el bloque 2: _________________________
z.) Con una excepción en el bloque 1: _________________________
Nota: un número con asterisco, indica un bloque/subflujo interrumpido por el

lanzamiento de una excepción: 1*, 2*, 3* o 4*
A. x.) 1 → 2 → 3 → 4; | y.) 1 → 2* → 3 → 4; | z.) 1*

B. x.) 1 → 2 → 4; | y.) 1 → 2 → 3; | z.) 1* → 4
C. x.) 1 → 2 → 4; | y.) 1 → 2* → 3 → 4; | z.) 1*
D. x.) 1 → 3 → 4; | y.) 1 → 2* → 3 → 4; | z.) 1*
8. Dado el siguiente flujo, ¿en qué línea de código se podría lanzar la

excepción FileNotFoundException?
1 public static void notas ( ) throws FileNotFoundException

2 {
3 Formatter salida = new Formatter("salida.txt");
8 Scanner entrada = new Scanner(System.in);
5 int limite = entrada.nextInt( );
6 // .......
7 }
A. 3
B. 4
C. 5
D. Ninguna

9. Dado el siguiente flujo, ¿en qué línea de código se podría lanzar la

excepción ArrayIndexOutOfBoundsException?
1 public static void notas ( ) throws FileNotFoundException

2 {
3 Formatter salida = new Formatter("salida.txt");
8 Scanner entrada = new Scanner(System.in);
5 int limite = entrada.nextInt( );
6 int nota [ ] = imite = new int [limite], sumatoria = 0;
7 double promedio;
8 for (int i = 0; i <= limite; i++)
9 {
10 nota [ i ] = entrada.nextInt( );
11 sumatoria + = nota [ i ]
12 salida.format("%s = %d \r\n", "Nota", nota [ i ]);
13 }
14 promedio = sumatoria / limite
15 salida.format("%s = %f \r\n", "Promedio", promedio);
16 salida.close( );
17 }
A. 1, 3, 4
B. 5, 6, 7
C. 10, 11, 12
D. 14, 15, 16

10. Dada la siguiente jerarquía de excepciones (diagrama UML), escriba el

nombre de la excepción propia que está definida (heredada) de forma
incorrecta.
A. MiException1
B. MiException2
C. MiException3
D. MiException4

Guía Didáctica: Programación de Algoritmos SEGUNDO BIMESTRE
SEGUNDO BIMESTRE
UNIDAD 3. ARCHIVOS, FLUJOS Y SERIALIZACIÓN DE OBJETOS
“Cuida tus pensamientos...porque se volverán

actos.
Cuida tus actos...porque se harán costumbre.
Cuida tus costumbres...porque formarán tu
carácter.
Cuida tu carácter...porque formará tu destino.
y tu destino será tu vida”.
- Gandhi.
Que gusto estimado estudiante el aún tenerlo hasta acá, esa es una prueba de
valor y constancia para usted. Pero cuénteme, ¿cómo le fue en el primer bimestre
con la POO y las Excepciones?, esos son temas importantes y necesarios no
solo para esta asignatura, si no para otras de ciclos superiores, “Arquitectura de
Aplicaciones” por ejemplo.
Pero bien, si aún no tiene claro algún tema de POO y/o Excepciones, podemos
volverlos a revisar juntos, quedando a las órdenes vía EVA ante cualquier duda
al respecto. Pero en este segundo bimestre, corresponde iniciar revisando los
mecanismos de almacenamiento de datos, temas útiles cuando se requiere de
la persistencia de información, por que sabemos es volátil o temporal mientras
se procesa en un programa en ejecución. Para tener disponibles los datos de
forma permanente es necesario guardarlos en los dispositivos de almacenamiento
secundarios (por ejemplo: disco duro o pindriver, etc.). En esta unidad
revisaremos los mecanismos que dispone el lenguaje Java para almacenar y
recuperar información en estos dispositivos persistentes.

3.1. Conceptos preliminares sobre los datos.
Antes de remitirnos a nuestro texto básico, debo comentarle que la decima

edición que estamos usando contiene únicamente los Capítulos 1 – 11 y
Apéndices A – E, al final de los cuales usted hallara el siguiente aviso:
LOS CAPÍTULOS 12 A 19 SE ENCUENTRAN DISPONIBLES, EN ESPAÑOL, EN

EL SITIO WEB DE ESTE TEXTO BÁSICO
Y como los “Archivos, flujos y serialización de objetos” están en el Capítulos

15 del texto básico, por favor diríjase a este enlace web y descargue todos estos
capítulos restantes, que los va ha necesitar no solo para esta tercera unidad, si no
también para las dos últimas unidades 4 y 5.
¿Los pudo descargar? Si no, los he publicado dentro

de nuestro EVA, para que le sea mucho más sencilla su
descarga.
Una vez con los .pdf descargados, por favor abrir el archivo
llamado: M15_DEITEL_COMO-PROGRAMAR-EN-JAVA_
SE_10ED_C15_644-683_XXXX-X.pdf que corresponde al
Capítulo 15, diríjase a las Secciones 15.1, 15.2 y 15.3, que
son totalmente introductorias pero interesante.
Finalizada la lectura de las Secciones 15.1 a la 15.3 de nuestro texto básico, me

parece pertinente puntualizar lo siguiente:
• Los archivos retienen a largo plazo grandes cantidades de datos

persistentes, después de que los programas terminan de ejecutarse.
• Las computadoras almacenan los archivos en dispositivos de
almacenamiento secundario.
• Las clases Path y Files, son algunas de las muchas usadas para la
gestión de los archivos en Java.

3.2. Flujos en Java.
Usted también reviso dentro de su texto básico la Sección 15.2 y la Sección

15.3, pues al respecto es importante puntualizar las siguientes afirmaciones: Java
ve a cada archivo como un flujo secuencial de caracteres y bytes, en donde:
• Cada sistema operativo cuenta con un mecanismo para determinar el

fin de un archivo, como un marcador de fin de archivo o la cuenta de
los bytes totales en el archivo.
• Los flujos basados en bytes: representan datos en formato binario. Sus
archivos son binarios; leible con App especializadas.
• Los flujos basados en caracteres: representan datos como secuencias
de caracteres. Sus archivos son de texto, tratables con las clases
Scanner y Formatter.
De igual forma, en la clase Files tenemos métodos static para realizar la

manipulación común de archivos/directorios, como:
• Copiar archivos
• Crear/eliminar archivos/directorios
• Obtener información sobre archivos/directorios
• Leer el contenido de archivos
• Obtener objetos para manipular el contenido de archivos/directorios.
Entre otros.
Finalmente, otras clases e interfaces NIO1 importantes son:
• DirectoryStream que permite iterar a través del contenido de un

directorio.
• Formatter que permite mostrar datos con formato en pantalla o
enviarlos a un archivo, similar a System.out.printf.
¹ NIO hace referencia al paquete de java: java.nio.*;

• Para crear archivos de texto usamos las clases: java.util.Formatter o

java.io.FileWriter. Este es un flujo de salida desde el programa hacia
los dispositivos de almacenamiento secundario.
• Para leer archivos de texto usamos las clases: java.util. Scanner o
java.io.FileReader. Este es un flujo de entrada desde los dispositivos
de almacenamiento secundario hacia el programa.
Las clases anteriores trabajan con rutas absolutas (que contiene todos los
directorios, empezando con el directorio raíz.) o ruta relativa (que empiezan
desde el directorio en el que se empezó a ejecutar la aplicación)
3.3. Escritura y lectura de datos en ficheros secuenciales.
Perfecto, ahora con estos dos apartados teóricos anteriores, es hora de aplicar lo
aprendido, por lo que le solicito a continuación:
Del M15_DEITEL_COMO-PROGRAMAR-EN-JAVA_
SE_10ED_C15_644-683_XXXX-X.pdf, diríjase a la Sección
15.4, lea, compile y ejecute los ejemplos que aquí se
describen, y al finalizar el estudio de esta sección responda
a los siguientes casos, ya acostumbradas:
Primer caso:
En la Fig. 15.3: CrearArchivoTexto.java de su texto básico se crea un archivo

con flujo basado en caracteres usando las clases Formatter principalmente.
A continuación, le expongo una solución alternativa (ver Figura 3.1 Creación
de un archivo usando las clases Formatter y FileWriter.), por favor revise las
dos soluciones (la de su texto básico y de esta guía) y conteste a las siguientes
interrogantes:
▪▪ ¿Cuáles son las diferencias entre estas dos soluciones?, ¿A su criterio,

existe alguna ventaja o desventaja?, subrayar de ser posible los fragmentos
de código en donde encuentre algo importante que resaltar.

1 package FILES;
2
3 import java.io.File;
4 import java.io.FileNotFoundException;
5 import java.io.FileWriter;
6 import java.io.IOException;
7 import java.nio.file.Files;
8 import java.nio.file.Path;
9 import java.nio.file.Paths;
10 import java.util.Formatter;
11
12 public class Formatter_VS_FileWrite_Opcion1 {
14 //Rutas del archivo
15 String strNombArchivo - "miArchivoPrueba1.txt";
16 File file = new File(strNomArchivo);
17 Path path = Paths.get(strNomArchivo);
18 try {
19 //Apertura el flujo de salida al archivo.
20 //Si el archivo existe, se trunca y se escribe desde el inicio
21 Formatter flujoOUT_Formatter = new Formatter(file);
22 //IF TERNARIO valida si existe o no el archivo,
23 //para iniciar/continuar(false/true) su escritura al inicio/final (false/true).
24 FileWriter flujoOUT_FileWriter = Files.exists(path)?
25 new FileWriter(file,true) : new FileWriter(file);
26
27 flujoOUT_Formatter.format("Nombre: %s \ t Sueldo: %.2f%m", "Daniel", 900.500);
28 flujoOUT_FileWriter.write("Nombre: Juan \t Sueldo: 1000.560 \n");
29
30 flujoOUT_Formatter.close( );
31 flujoOUT_FileWriter.close( );
32
33 } catch (SecurityException securityException) {
34 System.err.printIn("Permisos de escritura negados. Terminar el programa");
35 System.exit (1); //Termina el programa.
36 } catch (FileNotFoundException fileNotFoundException) {
37 System.err.printIn("Error para abrir el archivo. Terminar el programa");
38 System.exit (1); //Termina el programa.
39 } catch (IOException e) {
40 System.err.printIn("Error para abrir el archivo");
41 }
42 }
43 }
Figura 3.1 Creación de un archivo usando las clases Formatter y FileWriter.

Enlace web: Ver código en GitLab

Solución
Las dos clases: Fig. 15.3: CrearArchivoTexto.java (de su texto básico) y Figura
3.1 Creación de un archivo usando las clases Formatter y FileWriter., son
similares al crear archivos con flujos basados en caracteres y distintas por que el
CrearArchivoTexto.java y Formatter_VS_FileWrite_Opcion1.java, hacen una
comparativa al respecto del uso de las dos clases (Formatter y FileWriter) para la
escritura de datos en un archivo, y esta diferencia básicamente es que: mientras
Formatter trunca/elimina los datos dentro de un archivo si este existe, la clase
FileWriter permite establecer parámetros para continuar con la escritura de datos
dentro de un archivo manteniendo o no los datos existentes.
Las líneas que marcan la diferencia son las agrupadas en el bloque 19-28 de la
Figura 3.1 Creación de un archivo usando las clases Formatter y FileWriter.
Segundo caso:
En la Fig. 15.3: CrearArchivoTexto.java de su texto básico, se crea un archivo

con flujo basado en caracteres usando las clases Formatter principalmente.
A continuación, le expongo otra solución alternativa a la de su texto básico
(ver Figura 3.2 Creación de un archivo usando la clase Formatter he ingresos
cíclicos.), por favor revise las dos soluciones y conteste a las siguientes
interrogantes:
¿Cuáles son las diferencias entre estas dos soluciones? Marcar de ser posible los
fragmentos de código en donde encuentre algo importante que resaltar.
1 package FILES:
2
4 import java.io.FileNotFoundException;
8 import java.util.FormatterClosedException;
9 import java.util.NoSuchElementException;

11
14 Scanner teclado - new Scanner(System.in)
15 //Rutas del archivo
16 String strNombArchivo = "miArchivoPrueba1.txt";
17 File file = new File(strNombArchivo);
18 Path path = Paths.get(strNombArchivo);
19 try {
20 Formatter flujoOUT_Formatter = new Formatter(file);
21 System.out.printf("%s%n%s%n?", "Ingrese su nombre", "Ingrese su sueldo.");
22 //Bucle hasta encontrar la combinacion de teclas de fin de archivo
23 while (teclado.hasNext( ) ) {
24 try {
25 flujoOUT_Formatter.format("Nombre: %s \t Sueldo: %.2f%n",
26 teclado.next( ), teclado.nextDouble( ) );
27 } catch (FormatterClosedException formatterClosedException) {
28 System.err.printIn("Error al escribir en el archivo");
29 break;
30 } catch (NoSuchElementException elementException) {
31 System.err.printIn("Entrada invalida. Intente de nuevo");
32 teclado.nextLine( );//Descarta la entrada, puede intentar otra vez.
33 }
34 System.out.print("?");
35 }
36 flujoOUT_Formatter.close( );
37 } catch (SecurityException securityException) {
38 System.err.printIn("Permisos de escritura negados. Terminar el programa");
39 System.exit( 1 ); //Termina el programa.
40 } catch (FileNotFoundException fileNotFoundException) {
41 System.err.printIn("Error al escribir en el archivo. Terminar el programa");
42 System.exit( 1 ); //Termina el programa.
43 }
44 }
45 }
Figura 3.2 Creación de un archivo de forma cíclica usando la clase Formatter.


Solución
Entre la Fig. 15.3: CrearArchivoTexto.java de su texto básico y la Figura 3.2

Creación de un archivo de forma cíclica usando la clase Formatter., la diferencia
no es mayor, por que ambas crean un flujo basado en caracteres de forma cíclica;
la de nuestro texto básico, si lo hace con la definición de más métodos, pero la
Figura 3.2 Creación de un archivo usando la clase Formatter he ingresos cíclicos.
es algo más resumida.
Tercer caso:
En la Fig. 15.6: LeerArchivoTexto.java de su texto básico se lee un archivo

con flujo basado en caracteres usando las clases Scanner. A continuación, le
expongo otra solución alternativa (ver Figura 3.3 Lectura de un archivo con las
clases Scanner y FileReader.) a la de su texto básico, por favor revise las
dos soluciones (la de su texto básico y de esta guía) y conteste a las siguientes
interrogantes:
▪▪ ¿Cuáles son las diferencias entre estas dos soluciones?, ¿A su criterio,

existe alguna ventaja o desventaja?, subrayar de ser posible los fragmentos
de código en donde encuentre algo importante que resaltar.
1 package FILES:
2
3 import java.io.BufferedReader;
5 import java.io.FileReader;
6 import java.io.IOException;
10
13 String strNombArchivo = "miArchivoPrueba1.txt";
14 File file = new File(strNombArchivo);
15 Path path = Paths.get(strNombArchivo);

16 try {
17 //Apertura el flujo de entrada del archivo con Scanner.
18 Scanner flujoEntrada_Scanner = new FileReader(file);
19 //Apertura el flujo de entrada del archivo con FileReader.
20 FileReader flujoEntrada_FileReader = new FileReader(file);
21
22 //CON EL FLUJO DE ENTRADA Scanner
23 //Lectura dato a dato => //System.out.printIn(flujoEntrada_Scanner.next( ));
24 //Lectura linea a linea => //System.out.printIn(flujoEntrada_Scanner.nextline( ));
25 //Lectura ciclica. Puede ser dato a dato o linea a linea.
26 while(flujoEntrada_Scanner.hasnext( ));
27 System.out.printIn(flujoEntrada_Scanner.nextLine( ));
28 }
29
30 // CON EL FLUJO DE ENTRADA FILEREADER
31 BufferedReader leerFilesBuffer = new BufferedReader(flujoEntrada_FileReader);
32 String strLinea;
33 //Lectura caracter a caracter => //int caracter = leerFilesBuffer.read( )
34 while ( (strLinea = leerFilesBuffer.readLine( ) ) ! = null) {
35 System.out.printIn(strLinea);
36 }
37
38 flujoEntrada_Scanner.close( );
39 flujoEntrada_FileReader.close( );
40
41 } catch (IOException e) {
42 System.err.printIn("Error al abrir el archivo");
43 }
44 }
45 }
Figura 3.3 Lectura de un archivo con las clases Scanner y FileReader.

Solución
Entre las clases LeerArchivoTexto.java del texto básico y la Figura 3.3 Lectura
de un archivo con las clases Scanner y FileReader., si existe similitudes y
diferencias: son similares por que ambas realizan la lectura de flujos basados
en caracteres, la diferencia es que, en esta guía hace una comparativa entre

las clases Scanner y FileReader para ilustrar el uso de estas dos clases para un
mismo fin, y en el texto básico usa únicamente la clase Scanner. Los fragmentos
de código que resaltan lo anteriormente indicado son: líneas de código 17-36.
Y para cerrar este apartado, le dejo la Figura 3.4 Creación de archivos CSV con
flujos basados en caracteres., en donde se realiza la salida y entrada (output,
input) con flujos basados en caracteres, pero de un tipo de archivo peculiar
con extensión .CSV, el cual siendo un archivo de texto, puede ser importado y
exportado usando Excel con una visualización más atractiva y tabulada en celdas,
pero si se usa un editor de texto común, se observa punto y coma (;) como
separador de valores.
Le sugiero revise esta clase FilesNotasJava_CSV.java, ya que la misma le

será de mucha ayuda y base, para el desarrollo y entrega de sus actividades
obligatorias en el EVA con fines académicos y de evaluación.
1 package FILES:
2
6 import java.util.Locale;
7
8 public class FilesNotasJava_CSV {
10 try {
11 //FLUJO DE SALIDA al archivo,
12 //con Charset US-ASCII, para escribir . en lugar de ,
13 Locale ingles = new Locale ("en", "EN");
14 Formatter outArchivo = new Scanner (new File ("notas.csv") );
15 outArchivo.format("%.2f;%d';%d;%n", 4.5, 20, 8);
16 outArchivo.format("%d';%d;%.2f;%n", 15, 19, 16.4);
17 outArchivo.close( );
18
19 //FLUJO DE SALIDA al archivo,
20 Scanner inArchivo = new Scanner(new File("notas.csv") );
21 String contenido;
22 int nroEst = 1
23 while (inArchivo.hasNext( )) {

24 System.out.printIn("NOTAS DEL ESTUDIANTE: " + NROeST);

25 contenido = inArchivo.nextLine( )
26 String[ } tokens = contenido.split("; ");
27 //System.out.printIn(tokens [0] + ", " + tokens [1] + ", "+ tokens [2]);
28 System.out.printf("%-5s%-5s%-5s%n", tokens[0], tokens [1], tokens [2]);
29 int i = 1;
30 for (String nota : tokens) {
31 System.out.printIn ("Nota [" + i + "] : " + nota);
32 //Transforma la nota de string a double.
33 //double notaAux = Double.valueOf(nota);
34 //System.out.printIn("Nota [" + i + "]; " + notaAux);
35 i++;
36 }
37 nroEst++;
38 }
39 inArchivo.close( );
40 } catch (NumberFormatException numberFormatException) {
41 System.err.printIn("Formato de numero invalido");
43 System.err.printIn("Excepcion generada: " + e);
44 System.exit(1); //Termina el programa.
45 }
46 }
47 }
Figura 3.4 Creación de archivos CSV con flujos basados en caracteres.

3.4. Serialización de objetos.
Querido estudiante, en este punto finalizamos el estudio de la tercera unidad de

la asignatura (primera del segundo bimestre), por ello vamos a remitirnos a la
siguiente Sección del Capitulo 15 de su texto básico:
En el archivo M15_DEITEL_COMO-PROGRAMAR-EN-
JAVA_SE_10ED_C15_644-683_XXXX-X.pdf, diríjase a la
Sección 15.5, lea, compile y ejecute los ejemplos que aquí
se describir y expliquemos como se aplica cada un de las
siguientes afirmaciones en los códigos de las clases allí
expuestas.

Aplicando y puntualizando lo leído:
• La serialización permite escribir o leer objetos completos mediante un

flujo.
• Un objeto serializado es una secuencia de bytes e incluye los datos del

objeto (tipo de objeto, tipos de datos que almacena, etc.)
• Se puede leer del archivo un objeto serializado y deserializarse para

recrearlo en la memoria.
• ObjectInputStream y ObjectOutputStream permiten leer y escribir

objetos desde y hacia un flujo (posiblemente un archivo).
• Sólo las clases que implementan a la interfaz Serializable pueden

serializarse y deserializarse.
• writeObject de ObjectOutput, recibe un Object y escribe su

información en un OutputStream.
• Una clase que implementa a ObjectOutput como

ObjectOutputStream, debe asegurarse que el objeto Object sea
serializable.
• readObject de ObjectInput, lee y devuelve una referencia a un objeto

Object a partir de un InputStream.
• Una vez que se lee un objeto, su referencia puede convertirse al tipo

real del objeto.




Autoevaluación 3

análisis, síntesis y evaluación, sobre la “Gestión de archivos en Java”, con la
presente Autoevaluación que busca lograr en usted el siguiente Resultado de
Aprendizaje (R.A):
“Evaluar técnicas de gestión de archivos de acceso secuencial adoptando la

más eficiente para la entrada/salida de datos persistentes.”
Instrucciones:



1. En base a las definiciones sobre los “Archivos, flujos y serialización de

objetos”, indicar el valor de verdad de las siguientes afirmaciones:
AFIRMACIÓN
1. Para leer varias veces desde el inicio un archivo con Scanner, debe cerrarse y
volver a abrirse.
2. Los archivos binarios pueden ser leídos por los seres humanos en un editor de
texto normal o común.
3. La ruta relativa contiene todos los directorios que conducen hacia un archivo o
directorio específico.
4. La clase Formatter contiene el método printf, para enviar datos con formato a
pantalla o a un archivo.
A. Verdadero – Falso – Falso – Falso

B. Verdadero – Falso – Falso – Verdadero
C. Verdadero – Falso – Verdadero – Verdadero
D. Verdadero – Verdadero – Verdadero – Verdadero
2. Escriba una instrucción que abra el archivo “fileTest.txt” en modo entrada,

con un flujo basado en caracteres.
A. Formatter inputFile = new Formatter(Paths.get(“fileTest.txt”));

B. Scanner inputFile = new Formatter(Paths.get(“fileTest.txt”));
C. Scanner inputFile = new Scanner(Paths.get(“fileTest.txt”));
D. FileWriter inputFile = new FileWriter(Paths.get(“fileTest.txt”));

3. Escriba una instrucción que abra con un flujo basado en bytes, el archivo
personas.ser en modo entrada; use la variable ipPers para envolver un
objeto InputStream.
A. ObjectInputStream ipPers = new ObjectInputStream(Files.

newInputStream(Paths.get(“personas.ser”)));
B. ObjectOutputStream ipPers = new ObjectOutputStream(Files.
newOutputStream(Paths.get(“personas.ser”)));
C. ObjectInputStream ipPers = new ObjectOutputStream(Files.
D. ObjectOutputStream ipPers = new ObjectInputStream(Files.
4. Escriba una instrucción que abra con un flujo basado en bytes, el archivo
personas.ser en modo salida; use la variable opPers para envolver un objeto
OutputStream.
A. ObjectInputStream opPers = new ObjectInputStream(Files.

B. ObjectOutputStream opPers = new ObjectOutputStream(Files.
C. ObjectInputStream opPers = new ObjectOutputStream(Files.
D. ObjectOutputStream opPers = new ObjectInputStream(Files.
5. Escriba una instrucción que abra el archivo “fileTest.txt” en modo salida, con
un flujo basado en caracteres.
A. Formatter outputFile = new Formatter(Paths.get(“fileTest.txt”));

B. Scanner outputFile = new Formatter(Paths.get(“fileTest.txt”));
C. Scanner outputFile = new Scanner(Paths.get(“fileTest.txt”));
D. FileReader outputFile = new FileReader(Paths.get(“fileTest.txt”));

6. Defina los tipos de datos recomendados para automatizar el siguiente

requerimiento. Defina la mínima cantidad de datos posible.
Se desea almacenar los datos de clientes que ingresan a una sala de cine
(ejemplo de la numeración de asientos: A1, A2, …, A16; B1, B2, etc.), para
ello los datos indispensables y sus tipos, son:
A. nombClient, apelClient, tituloPelicula: String; horaFuncion: int;

numAsiento: double;
B. nombClient, tituloPelicula: String; horaFuncion: date; numAsiento: int;
C. nombClient, tituloPelicula, numAsiente: String; horaFuncion: time;
D. nombClient, tituloPelicula: String; horaFuncion: double;
7. El archivo notas.csv tiene el siguiente tenido. Si el número de notas para

cada estudiante es variable, ¿mínimo cuantos ciclos repetitivos cree que se
requieren para la lectura de este archivo, sumar sus notas por estudiante y
presentar las notas/resultados individualmente?
Nota: considere la ventaja de usar el método split(String separador) para la

lectura.
ESTUDIANTES NOTA 1. NOTA 2. NOTA_N.

Estudiante1 -1 4 Nota_N
Estudiante2 18 -1 Nota_N
Estudiante3 -1 -1 Nota_N
… … … …
EstudianteN Nota_N Nota_N Nota_N
A. 1
B. 2
C. 4
D. n

8. Un ejemplo de dato persistente es:
1 final double numb_pi;

2 num_pi = 3.1415;
A. 3 System.out.printIn(num_pi);
1 double num [ ] = {3.1415, 2.7182};

2 System.out.printIn(num[0]);
B. 3 System.out.printIn(num[1]);
1 Scanner entrada = new Scanner (System.in);

2 double pi;
C. 3 pi = entrada.nextDouble( );
1 Formatter salida = new Formatter ("numeros.txt");

2 salida.format("%f", 3.1415);
D. 3 salida.close( );
9. Según la siguiente sentencia ejecutada desde consola CMD-Windows.
javac –classpath .;c:\ejemplos\cap17 CrearArchivoTexto.java

INSTRUCCIÓN ACCIÓN
1. javac x. Para localizar las clases empaquetadas/importadas.
2. –classpath y. Nombre de la clase de será compilada.
3. CrearArchivoTexto z. Comando para compilar desde CMD una clase.
A. 1–x; 2–y; 3–z

B. 1–y; 2–x; 3–z
C. 1–z; 2–x; 3–y
D. 1–x; 2–z; 3–y

10. Un archivo (file) puede contener otros archivos, o también uno o varios
registros; el registro a su vez está formado por campos y los campos por
caracteres (dato o valor) y éstos últimos por bits.
1 public class Utpl {

2 public String nom;
3 public int ruc;
4 }
5
6 class Docentes extends Utpl {
7 public String nom, rol;
8 }
9
10 class Administrativo extends Utpl {
11 public String nom, cargo;
12 }
13
14 class test {
16 Docentes docente[ ] = new Docentes[2];
17 docente[0] = new Docentes( );
18 docente[0] .nom = "Juan Lopez";
19 docente[0] .rol = "Auxiliar";
20 }
21 }

Con esta aclaración y jerarquía de clases .java, indicar ¿cuál es el concepto

representado por cada línea de código:
INSTRUCCIÓN REPRESENTA UN / UNA

1. Línea de código 18 x. campo
2. línea de código 17 y. registro
3. La clase Utpl z. DB
A. 1–x; 2–y; 3–z

B. 1–y; 2–x; 3–z
C. 1–z; 2–x; 3–y
D. 1–x; 2–z; 3–y

UNIDAD 4. ALGORITMOS RECURSIVOS
“Solo aquellos que se atreven a tener grandes

fracasos terminan consiguiendo grandes éxitos”.
- Robert F. Kennedy.
Vamos avanzando ya al fin del estudio de esta asignatura y en esta ocasión

corresponde revisar una técnica muy especial de programación, la recursividad,
en primera instancia puede ser algo complicado comprender su funcionamiento,
pero lo importante en este aspecto es empezar el estudio con ejemplos pequeños,
por lo que vale la pena comentar que si bien es cierto existen algunos programas
que se pueden resolver tanto de forma recursiva como de forma iterativa
(mediante ciclos for, while, do-while), existen otros problemas que son netamente
recursivos, por ejemplo en la Sección 18.1 del texto básico se mencionan
algunos ejemplos de los cuales se resalta el tratamiento de arboles binarios,
Torres de Hanoi, Fractales, etc. son de naturaleza recursiva y en algunos casos es
muy complicado resolverlos de forma iterativa como se menciono anteriormente.
Sin más iniciemos por favor con los siguientes apartados.
4.1. Introducción y conceptos básicos de recursividad.
Para repasar los conceptos introductorios recursivos, por favor, remitámonos a los
siguientes apartados de nuestro texto básico:
En los *.pdf descargados en la unidad anterior, abra el

archivo llamado M18_DEITEL_COMO-PROGRAMAR-
EN-JAVA_SE_10ED_C18_776-809_XXXX-X.pdf, que
corresponde al Capitulo 18, y diríjase a las Secciones 18.1
y 18.2 para hacer un repaso teórico e importante sobre los
fundamentos de Recursividad, al terminar su estudio, revise
las puntualizaciones que le hago a continuación:

Fundamentos de recursividad:
• Un método recursivo se llama a sí mismo en forma directa o indirecta

(a través de otro método).
• Un método recursivo es capaz de resolver sólo los casos más simples
o caso base.
• Un método recursivo con un problema muy complejo (sin caso base),
divide el problema en dos:
▪▪ (1er ) el método sabe cómo resolver (caso base) y

▪▪ (2do) que no lo sabe.
Paso recursivo
• Divide un problema muy complejo (o no complejo), en versiones mas

pequeñas/sencillas. Así la recursividad es, factible.
• La recursividad termina al llegar al caso base (el problema complejo se
hace cada vez más sencillo).
• Cuando el método reconoce el caso base, devuelve un resultado a la
copia anterior del método.
Recursividad indirecta
• Se da cuando el metodoA() recursivo, llama al metodoB() recursivo y

el metodoB() vuelve a llamar al metodoA().
Recursividad infinita
• Se da cuando las llamadas recursivas no convergen en un caso base,

como consecuencia se agota la memoria; es similar a ciclos iterativos
infinitos.

Sugerencia
• Prefiera un método recursivo y no iterativo, cuando el problema

produzca un programa más fácil de comprender y de depurar.
Vuelta recursiva
• Si las llamadas recursivas no producen una solución, el programa

retrocede al punto de decisión anterior y toma una decisión distinta, con
más llamadas recursivas.
4.2. Aplicación de la recursividad.
Es hora de aplicar cada concepto estudiado anteriormente, por ello por favor,
debemos remitirnos nuevamente a nuestro texto básico:
JAVA_SE_10ED_C18_776-809_XXXX-X.pdf, diríjase a
las Secciones 18.3 a la 18.6, compile, ejecute y estudie
cada ejemplo de la mano de su texto básico, al final
compleméntelos con las siguientes ilustraciones, resumen y
explicaciones que le hago a continuación:
Estimado estudiante, no olvide revisar bien las siguientes figuras

(complementarias a su texto básico) e indique si existen diferencias o similitudes
al respecto:
Es una muy buena práctica, que al realizar la comparativa

de lo solicitado anteriormente, compile y ejecute el
FactorialRecursivo.java en modo depuración con puntos
de interrupción en las líneas de código número 21 y 25, con
el fin de evidenciar con sus propios ojos, lo que se ilustra
con las Figura 4.2 Ilustración de las llamadas recursivas. y la
Figura 4.3 Ilustración de los retornos recursivos.

1 package RECURSIVIDAD
2
3 /**
4 * La clase permite obtener el factorial de un número
5 *recursivamente a traves del metodo recursivo (num)
6 *@author Pedro Daniel Irene Robalino
7 *@email [email protected]
8 */
9 public class FactorialRecursivo {
11 int num = 3, resultado = 0
12 resultado = factorialRecursivo(num);
13 Sistem.out.printIn(num + "! = " + resultado);
14 }
15 /**
16 * Metodo recursivo para obtener el factorial de un numero
17 *@param num por medio del cual se obtendra el factorial
18 *@return retorna el factorial de num - 1
19 */
20 public static int factorialRecursivo(int num) {
21 if(num ==0) //Evalua el caso base
22 return 1; //Caso base
23 else { //Paso recursivo / llamada recursiva
24 int devolver = (num*factorialRecursivo(num-1));
25 return devolver; //Vuelta recursiva
26 }
27 }
28 }
Figura 4.1 Clase para hallar el factorial de un número recursivamente.
Enlace Web: Ver código en GitLab

Figura 4.2 Ilustración de las llamadas recursivas.
Figura 4.3 Ilustración de los retornos recursivos.

El método recursivo factorialRecursivo(int num), Figura 4.1 Clase para hallar

el factorial de un número recursivamente., fragmento de código 20-27, tiene los
siguientes componentes:
• Llamada recursiva inicial (main() - línea de código 10 y 12):

es aquella en donde, desde un método externo se invoca a
factorialRecursivo(int num) en un primer tiempo.
• Llamada recursiva continuas (línea de código número 24): y también

llamado paso recursivo, que es aquel en donde el método recursivo se
invoca a si mismo (cíclicamente, por usar otro término), esto se hace en
el segundo y siguientes tiempos.
• Evaluación del caso base (línea de código número 21): Es una

evaluación, condición o validación con la instrucción if(pregunta) para
identificar si se debe finalizar las llamadas recursivas o caso contrario,
se debe continuar con estas.
• Caso base (línea de código número 22): Si en la evaluación del

caso base, la validación con la instrucción if (pregunta) es positiva,
las llamadas recursivas finalizan e inician las cadenas de retornos
recursivos a las llamadas recursivas inmediatamente superiores.
En la Figura 4.2 Ilustración de las llamadas recursivas., se puede apreciar

únicamente las llamadas recursivas (paso recursivo), es decir, cuando aún no se
converge al caso base.
En la Figura 4.3 Ilustración de los retornos recursivos., se puede apreciar la

ilustración de los retornos recursivos, es decir, cuando se ha llegado al caso
base (num == 0), y se inician las cadenas de retornos a las llamadas recursivas
inmediatamente superiores.
En el ejemplo de la Serie de Fibonacci de su texto básico, los componentes y

aplicaciones de conceptos sobre Recursividad, son prácticamente iguales.

4.3. Comparación entre recursividad e iteración.
La recursividad e iteración tienen tanto similitudes y diferencias que las vamos a

repasar, pero solo una vez revisado el siguiente apartado:
JAVA_SE_10ED_C18_776-809_XXXX-X.pdf, diríjase a las
Secciones 18.7, al finalizar este estudio, complemente con
el resumen que le ofrezco a continuación:
Similitudes, tanto la recursividad como la iteración:
• Se basan en una instrucción de control.

• Implican repeticiones.
• Implican una prueba de terminación.
• Pueden ocurrir de forma indirecta.
• Cualquier problema que pueda resolverse en forma recursiva, también
se puede en forma iterativa.
Diferencias, la recursividad y la iteración se diferencias específicamente según

los siguientes criterios:
ITERACIÓN RECURSIVIDAD
Usa instrucciones/condiciones de Usa una instrucción de selección.
repetición.
Usa explícitamente una instrucción de Se repite a través de llamadas repetidas a
repetición. un mismo método.
Termina cuando falla la condición de Termina cuando se reconoce un caso
continuación de ciclo. base.
Controlada por contador. Se acercan en forma gradual a la
terminación.
Modifica un contador hasta que hace que Sigue produciendo versiones cada vez
falle la condición. más simples del problema original hasta
llegar al caso base.

ITERACIÓN RECURSIVIDAD
Ciclo infinito si la condición nunca es falsa. Infinita si el paso recursivo no reduce un
problema más sencillo que converja en el
caso base.
Podría requerir una gran cantidad de Se implementa con pocas líneas de código
código. (frecuentemente).

Estos le van a permitir aplicar cada apartado revisado en


Autoevaluación 4
Hemos finalizado el estudio de la presente unidad y es el momento de auto medir

su nivel de: conocimiento, comprensión, aplicación, análisis, síntesis y evaluación,
sobre los “Algoritmos recursivos en Java”, con la presente Autoevaluación
que busca lograr en usted el siguiente Resultado de Aprendizaje (R.A):
“Comprender y evaluar los conceptos, características y ejercicios de los

métodos recursivos.”
Instrucciones:



1. Indique los valores de verdad de las siguientes afirmaciones dados los

fundamentos de recursividad:
AFIRMACIONES
1. Un método que se llama a sí mismo en forma indirecta no es
un ejemplo de recursividad.
2. La recursividad es eficiente, debido a la reducción en el uso
del espacio en memoria.
3. Un método recursivo es capaz de resolver sólo el caso base.
4. La recursividad es factible cuando el paso recursivo se
asemeja al problema original pero más sencillo/pequeño.
A. Falso – Falso – Verdadero – Verdadero

B. Verdadero – Falso – Verdadero – Verdadero
C. Falso – Falso – Falso – Verdadero
D. Falso – Falso – Verdadero – Falso
2. Un método recursivo se llama ______________________________ a través

de otro método.
A. 2 veces
B. infinitas veces
C. una sola vez de forma indirecta
D. a sí mismo en forma directa o indirecta
3. Para terminar la recursividad, se requiere un (a) ________.
A. paso recursivo
B. instrucción break
C. tipo de valor de retorno void
D. caso base

4. La acción de omitir el caso base, o escribir el paso recursivo de manera

incorrecta para que no converja en el caso base, puede ocasionar ________,
con lo cual se agota la memoria en cierto punto. Este error es análogo al
problema de un ________ en una solución iterativa (no recursiva).
A. una recursividad infinita – ciclo finito

B. una recursividad infinita – ciclo infinito
C. una recursividad finita – ciclo infinito
D. finalización de la ejecución – ciclo finito
5. Los siguientes términos son aplicados a los siguientes conceptos.
Términos Aplicabilidad
1 paso recursivo / caso base w Iteraciones recursivas
2 for / while x Iteraciones cíclicas
3 lanzar / pila de llamadas y Manejo de excepciones
4 burbuja / inserción z Métodos de ordenamiento
A. 1-x, 2-w, 3-y, 4-z

B. 1-w, 2-y, 3-x, 4-z
C. 1-w, 2-x, 3-y, 4-z
D. 1-w, 2-x, 3-z, 4-y
6. La recursividad directa es:
A. La forma por la cual, el Método A, llama de manera especial al Método

B.
B. Si Método A recursivo llama al B, y este vuelve a llamar al A, hasta un
caso base.
C. Llamar al Método B en el Método A n veces, hasta llegar a un caso
base.
D. Llamar al Método A dentro del Método A n veces, hasta llegar a un
caso base.

7. En el siguiente flujo se ha codificado e invocado el método recursivo

recursivoA(valor). Analícelo e indique en que línea de código se encuentra
codificado el caso base.

2 System.out.printIn(recursivoA(3) );
3 }
4
5 public static int recursivoA(int valor) {
6 if(valor == 1)
7 return valor + 2;
8 return recursivoA(valor - 1);
9 }
A. 2
B. 5
C. 6
D. 8
8. Dado el siguiente flujo, indicar cual es el valor que se muestra por pantalla
gracias a la llamada del método recursivoA(3).

2 System.out.printIn(recursivoA(3) );
3 }
4
5 public static int recursivoA(int valor) {
6 if(valor == 1)
7 return 2;
8 return recursivoA(valor - 1);
9 }
A. -1,
B. 1,
C. 2,
D. 3,

9. Dado el siguiente método recursivo, ¿cuál es el valor de retorno si desde el

main() se lo invoca de la siguiente manera?
System.out.println(metodoA(5));
1 public static int metodoA(int valor) {

2 if(valor == 1)
3 return 1;
4 return valor * metodoA(valor - 1);
5 }
A. 1
B. 4
C. 5
D. 120
10. Los siguientes flujos (metodo1 y metodo2) permiten obtener el factorial de

un número, pero solo metodo2 lo hace de forma recursiva. En el metodo1,
¿cual es la línea de código que equivaldría al caso base del recursivo
metodo2?
1 public static int metodo1(int num) {

2 respt = num;
3 do {
4 respt *= (num - 1); num--;
5 } while (num > 1);
6 return respt;
7 }
8
9 public static int metodo2(int fact) {
10 if(fact <= 1)
11 return 1;
12 respt = fact * metodo2(fact - 1);
13 return respt;
14 }

A. Cuando en la línea 5 la condición se evalúa como falsa.

B. Cuando en la línea 5 la condición se evalúa como verdadera.
C. Cuando la línea 6 retorna el resultado del factorial.
D. Cuando en la línea 2 se descarga en respt el valor de num.

UNIDAD 5. ALGORITMOS SOBRE ARREGLOS
“La disciplina, tarde o temprano vencerá la

inteligencia”.
- Yokoi Kenji.
Hemos llegado al final de nuestro estudio, en verdad a sido un placer poderle

acompañar y colaborarle en su crecimiento profesional en cuanto a la
Programación de Algoritmos, y efectivamente es con ello que vamos a cerrar el
estudio de esta asignatura, ¡los algoritmos sobre arreglos!
Los arreglos son un tipo de datos que pertenecen al grupo de estructuras

compuestas las cuales usted ya reviso en asignaturas anteriores; 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 más importantes que se realizan sobre estas estructuras son: búsqueda
de elementos y ordenamiento. El propósito principal de este tema es que aprenda
a dominar, analizar y administrar la información existente en un arreglo cuya
aplicación es variada, por ejemplo: el análisis de datos temporales en el campo de
la educación, proyecciones, almacenes de datos de cosechas para calcular costos
de producción, etc. Perfecto, luego de esta introducción iniciemos entonces con el
estudio:
5.1. Estructura de un arreglo.
Antes de empezar con el estudio de los algoritmos para manipular los datos
almacenados en un arreglo, recordemos algunas características y aplicaciones
importantes de este tipo de datos de la mano de nuestro texto básico:

En nuestro texto básico, diríjase al Capítulo 7, y revise las

Secciones 7.1 a la 7.16.
Así es, este apartado de la última unidad es algo extenso

pero necesario, ya que es la base de todos los algoritmos
sobre arreglos (métodos de ordenamiento y búsqueda), es
por lo que, es indispensable revisemos y recordemos todo el
Capítulo 7 que, de hecho, en asignaturas anteriores a esta,
usted ya estudio, pero no esta de más recordar.
Si realizo a conciencia el estudio de este Capitulo 7 de su texto básico, entonces

puede revisar las siguientes puntualizaciones que le hago al respecto:
Fundamentos sobre arreglos:
• Los arreglos son estructura de datos relacionados homogéneos, de

tamaño fijo.
• Los arreglos son objetos considerados como tipos por referencia.
• Se accede a los elementos del arreglo con su nombre y una posición/
índice entre corchetes.
• Su primer elemento es de posición/índice cero (elemento cero).
• La posición/índice debe ser un entero no negativo; se puede usar una
expresión como índice.
• La variable de instancia length devuelve la longitud de un objeto
arreglo.
• Un arreglo se declara con el tipo y cantidad de elementos, usando la
palabra clave new. Su sintaxis es como se muestra a continuación:
tipo nombArreglo [ ] = new tipo[tamaño];
• Los elementos de un arreglo se inicializan con valores

predeterminados:
▪▪ 0 (cero) para numéricos primitivos
▪▪ false para booleanos
▪▪ null para referencias

• A continuación, algunos ejemplos de declaración e inicialización de

arreglos/matrices:
▪▪ int A1[ ]; // A1 es un arreglo de enteros

▪▪ int A2[10]; // error, el tamaño no va aquí
▪▪ int[ ] A3; // A3 es un arreglo de enteros
▪▪ int A4, B5[ ]; // A4 es un entero, B5 un arreglo
▪▪ int[ ] A6, B7; // A6 y B7 son arreglos
▪▪ String S[ ]; // S es un arreglo de strings/cadenas
▪▪ S[1]=”” // error, el arreglo no ha sido creado
▪▪ int A8[ ] = new [3, 8, 2, 91]; // Error, no es posible inicializar
así.
▪▪ int A9[ ] = new int{3, 8, 2, 91}; // Error, no es posible
inicializar así.
▪▪ int A10[ ] = new double[6]; // Error, en de definición e
inicialización del arreglo, su TIPO, debe ser homogéneo.
▪▪ int A11[ ] = {9, 3, 4, 8}; // A11 es un arreglo de enteros de
tamaño 3, donde A[0] es el primer elemento, y A[3] (ó A[A.
length-1]) el último
▪▪ int A12[ ] = new int[6]; // A12 es un arreglo de 6 elementos.
A[0] el primero, y A[5] el último.
▪▪ int M13[ ][ ] = {{2, 13, 37}, {4, 5, 7}}; // M13 es una matriz
rectangular de m x n = 2 x 3, (2 filas x 3 columnas)
▪▪ int M14[ ][ ] = {{9, -4, 16}, {74, -86, 91, 5}}; // M14 es una
matriz irregular, es decir, de 2 filas, 3 columnas en la primera
fila, y 4 columnas en la última fila.
▪▪ int Mt[ ][ ][ ] = {{{5, 2}, {4, 6}, {8, 1}}, {{2, 8}, {9, 2}, {1, 7}}}; //
Mt es una matriz de matrices de 2 x 3 X 2. (2 matrices, cada
matriz de 3 filas x 2 columnas)

For mejorado:
Figura 5.1 Fundamentos sobre el for mejorado
El for mejorado es una instrucción alternativa al for tradicional, que permite

iterar sobre los elementos de un arreglo directamente, es decir, sin hacer uso de
contadores/índices. Pero usted no lo debe usar para modificar los elementos de
un arreglo, para ello, debe usar un for tradicional. De igual forma puede usar este
for mejorado conjuntamente con la clase Arrays para recorrer los sub-arreglos de
una matriz (matrices) de la siguiente forma:
For mejorado y sin usar la clase Arrays:
1 int m [ ] [ ] = {{2, 5}, {8, 2}, {9, 1}};

2 for(int i - 0; i < m.length; i ++) {
3 for (int elemento : m[i])
4 System.out.print(elemento + " ")
5 }
For mejorado usando la clase Arrays:
1 int m [ ] [ ] = {{2, 5}, {8, 2}, {9, 1}};

2 for(int i - 0; i < m.length; i ++) {
3 System.out.print(Arrays.toString(m [i] ) )
4 }

5.2. Algoritmos de búsqueda.
Esta claro que un arreglo hace referencia a un conjunto de datos, por lo tanto,
existe una serie de operaciones que son típicas en esta estructura. Iniciemos con
el estudio de los algoritmos de búsqueda puesto que estos algoritmos son la base
para realizar operaciones de eliminación, modificación, etc.
Los algoritmos de búsqueda que revisaremos en este apartado son:
• Búsqueda secuencial o lineal.

• Búsqueda binaria.
Búsqueda secuencial o lineal
Para revisar este algoritmo secuencial/lineal de búsqueda, remitirse al siguiente

apartado de nuestro texto básico.
En las unidades anteriores le solicite descargue del sitio

oficial del texto básico, los capítulos adicionales/digitales
(12_a_19_capitulos_adicionales_espanol), si no lo hizo,
hagámoslo por favor y abramos el archivo M19_DEITEL_
COMO-PROGRAMAR-EN-JAVA_SE_10ED_C19_810-838_
XXXX-X.pdf que corresponde al Capítulo 19, y revisemos
Secciones 19.2.
LOS CAPÍTULOS 12 A 19 SE ENCUENTRAN

DISPONIBLES, EN ESPAÑOL, EN EL SITIO WEB DE ESTE
TEXTO BÁSICO
Y para complementar lo que seguro le fue muy sencillo (por que este método de
búsqueda es realmente muy fácil, implica únicamente un ciclo repetitivo y una
pregunta secuencial), puntualizo lo siguiente:
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 más

eficiente.
A continuación, he desarrollado una versión más resumida a la expuesta en su

texto básico, si usted lo desea, opcionalmente lo puede revisar como punto de
comparación:
1 public static int busquedaLineal (int arreglo [ ], int valorBuscado) {

2 int posicion = -1
3 for (int i = 0; i < arreglo,length; i++)
4 if (valorBuscado = = arreglo [i]) {
5 posicion = i ;
6 break;
7 }
8 return posicion; //Retorna -1 si no encuentra el valorBuscado
9 }
Figura 5.2 Solución alternativa – búsqueda lineal
Búsqueda binaria
Para revisar este algoritmo de búsqueda binaria, remitirse al siguiente apartado

de nuestro texto básico.
En el archivo M19_DEITEL_COMO-PROGRAMAR-
EN-JAVA_SE_10ED_C19_810-838_XXXX-X.pdf que
corresponde al Capítulo 19, de nuestro texto básico,
revisemos la Secciones 19.4.
De no contar con el archivo, le dejo el enlace a continuación

para su descarga:
LOS CAPÍTULOS 12 A 19 SE ENCUENTRAN

DISPONIBLES, EN ESPAÑOL, EN EL SITIO WEB DE ESTE
TEXTO BÁSICO

Al finalizar el estudio de este apartado, complementémoslo con el siguiente

resumen:
La búsqueda binaria 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 Fig. 19.3 | Uso de
la búsqueda binaria para localizar un elemento en un arreglo (el símbolo * en la
salida marca el elemento medio) (parte 3 de 3), de su texto básico, se puede
evidenciar gráficamente el proceso explicado anteriormente.

comparación:
1 public static int busquedaBinaria (int arreglo [ ], int valorBuscado) {

2 int centro, inf = 0,sup = arreglo,length -1
3 while (inf <= sup) {
4 centro = (sup+inf) / 2; //Para preguntar si el elemento central, es el valorBuscado
5 if (arreglo[centro] == valorBuscado) {
6 return centro; //Termina el ciclo, si encuentre el valorBuscado
7 } else if (valorBuscado < arreglo[centro]) {
8 sup = centro -1;//Toma sub-arreglo del centro hasta el inicio (derecha)
9 System.out.printIn(Arrays.toString(Arrays.copyofRange(arreglo, inf, sup+1)));
10 } else {
11 inf = centro +1;//Toma sub-arreglo del centro hasta el final (izquierda)
12 System.out.printIn(Arrays.toString(Arrays.copyofRange(arreglo, inf, sup+1)));
13 }
14 }
15 return - 1; //Retorna -1 si no encuentr el valorBuscado
16 }
Figura 5.3 Solución alternativa – búsqueda binaria


5.3. Algoritmos de ordenamiento.
Otra de las tareas fundamentales en el trabajo con arreglos es el ordenamiento de

sus elementos, en este apartado vamos a estudiar 3 técnicas:
• Ordenamiento por selección.

• Ordenamiento por inserción.
• Ordenamiento burbuja (descrita en esta guía, no en el texto básico).
Es hora de hacer nuestra pausa para remitirnos al texto básico:
Abramos el archivo M19_DEITEL_COMO-PROGRAMAR-

EN-JAVA_SE_10ED_C19_810-838_XXXX-X.pdf que
corresponde al Capítulo 19, y revisemos la Secciones 19.5
a la 19.7, que corresponde a una pequeña introducción
sobre estas técnicas de ordenamiento y a las técnicas en si.
Pausa por favor y estudie en su texto básico.
Si finalizamos el estudio de lo sugerido anteriormente, puntualicemos lo siguiente:
Cada uno de estos métodos tiene sus ventajas y desventajas, en unos casos
la sencillez de su implementación puede 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 hacer su trabajo.
Ordenamiento por selección:
Es simple, pero ineficiente. Selecciona el elemento más pequeño (<) o más

grande (>) recorriendo todo el arreglo, y lo intercambia con el primer elemento.
En la segunda iteración se selecciona el segundo elemento más pequeño e
intercambia con el segundo elemento. Continúa hasta que en la última iteración
se selecciona el segundo elemento más grande, y se intercambia con el
antepenúltimo elemento, dejando el elemento más grande en el último índice. En
la i-ésima iteración del ordenamiento por selección, los i elementos más pequeños
de todo el arreglo se ordenan en los primeros i índices.


comparación:
1 public static int [ ] seleccion(int[ ] arreglo) {

2 for(int i = 0; i < arreglo.length - 1; i++) {
3 int posmin=i;
4 for(int j = i + 1; j < arreglo.length; j++)
5 //<para orden Ascendente (de menor a mayor)
6 //>para orden Descendente (de mayora menor)
7 if (arreglo[j] < arreglo[posmin])
8 posmin = j; //posicion del mas pequeño
9 intercambiar (arreglo, i, posmin);
10 }
11 return arreglo;
12 }
13
14 public static void intercambiar(int[ ] arreglo, int i, int j) {
15 int aux = arreglo[i];
16 arreglo[i] = arreglo[j]
17 arreglo[j] = aux;
18 System.out.printf("%d <=> %d %s%n, arreglo[i], arreglo[j],
19 Arrays.toString(arreglo));
20 }
Salida por pantalla:
ARREGLO ORIGINAL
[5, 6, 2, 1, 4]
ORDENANDO EL ARREGLO
1 <=> 5 [1, 6, 2, 5, 4]
2 <=> 6 [1, 2, 6, 5, 4]
4 <=> 6 [1, 2, 4, 5, 6]
5 <=> 5 [1, 2, 4, 5, 6]
[1, 2, 4, 5, 6].
Figura 5.4 Solución alternativa – ordenamiento por selección y salida por pantalla.

Ordenamiento por inserción:
Toma el segundo elemento en el arreglo y si es menor (<) que el primer elemento,

se intercambian. En la segunda iteración se analiza el tercer elemento y se inserta
en la posición correcta con respecto a los primeros dos elementos. Después de la
i-ésima iteración, quedan ordenados los primeros i elementos del arreglo original.

comparación:
1 public static int [ ] insercion(int[ ] arreglo) {

2 for(int i = 1; i < arreglo.length - 1; i++) {
3 int insert = arreglo[i];
4 int j = i - 1;
7 while (j > = 0 && insert < arreglo[j]) {
8 arreglo [ j + 1] = arreglo[j];
9 System.out.printf("%d <=> %d ", insert, arreglo[j]);
10 j = j - 1;
11 }
12 arreglo [ j + 1] = insert;
13 System.out.printf("%n%s%n, Arrays, toString(arreglo));
14 }
15 return arreglo;
16 }


ARREGLO ORIGINAL
[5, 6, 2, 1, 4]
[5, 6, 2, 1, 4]
2 <=> 6 2 <=> 5
[2, 5, 6, 1, 4]
1 <=> 6 1 <=> 5 1 <=> 2
[1, 2, 5, 6, 4]
4 <=> 6 4 <=> 5
[1, 2, 4, 5, 6]
[1, 2, 4, 5, 6]
Figura 5.5 Solución alternativa – ordenamiento por inserción y salida por pantalla.
Ordenamiento burbuja:
Comparar los dos primeros elementos, toma el más pequeño (<) o más grande (>)
y lo burbujea (mueve) al final del arreglo comparándolos con los subsiguientes,
al final de una iteración el elemento queda ordenado en la última posición. El
burbujeo de cada i-ésimo (par de elementos), se hace hasta ubicar el menor (<) o
mayor (>) en la última i-ésima posición del arreglo.
A continuación, exponemos este método de ordenamiento burbuja, en Java

completamente:
1 /**
2 * Metodo de ordenamiento Burbuja, para arreglos
4 *@version 1.0.0
5 */
6 package ARREGLOS
7 import java.util.Arrays;
8

9 public class Ordenador MetodoBurbuja {

10 /**
11 * Ordena un arreglo con el metodo de ordenamiento Burbuja el cual burbujea
12 * el mayor/menor elemento, al final del arreglo
13 *@param arreglo Original a ser ordenado.
14 *@return el arreglo ordenado
15 */
16 public static int [ ] burbuja(int [ ] arreglo) {
17 for(int i = 1; i < arreglo.length; i++) {
18 for(int j = 0; j < arreglo.length - i; j++)
21 if (arreglo[j] > arreglo[j + 1])
22 intercambiar(arreglo, j, j + 1);
23 }
24 return arreglo;*/
25 }
26
27 /**
28 * Intercambia dos elementos del arreglo ha ser ordenado
29 *@param arreglo Arregki sub - ordenado
30 *@param i posicion del primer elemento a ordenar
31 *@param j posicion del primer elemento a ordenar
32 */
33 public static void intercambiar(int [ ] arreglo, int i, int j) {
34 int aux = arreglo [i];
35 arreglo[i] = arreglo[j]; return 1; //Caso base
36 arreglo[j] = aux;
37 System.out.printf("%d <=> %d %s%n, arreglo[i], arreglo[j],
38 Arrays.toString(arreglo));
39 }
40
41 public static void main (String[ ] args) throws InterruptedException {
42 int arreglo [ ] = {5, 6, 2, 1, 4}; //Arreglo de valores Original
43 System.out.printf("ARREGLO ORIGINAL");
44 //Se presenta el arreglo original
45 System.out.printf(Arrays.toString(arreglo));
46 //Se presenta todo el proceso de ordenamiento.
47 System.out.printf("\nORDENADO EL ARREGLO");
48 System.out.printf(Arrays.toString(burbuja(arreglo));
49 }
50 }


ARREGLO ORIGINAL
[5, 6, 2, 1, 4]
2 <=> 6 [5, 2, 6, 1, 4]
1 <=> 6 [5, 2, 1, 6, 4]
4 <=> 6 [5, 2, 1, 4, 6]
2 <=> 5 [2, 5, 1, 4, 6]
1 <=> 5 [2, 1, 5, 4, 6]
4 <=> 5 [2, 1, 4, 5, 6]
1 <=> 2 [1, 2, 4, 5, 6]
[1, 2, 4, 5, 6]
Figura 5.6 Solución – ordenamiento burbuja y salida por pantalla.

5.4. Operaciones adicionales en un arreglo.
Adicional a las anteriores, existen otras operaciones que se realizan

frecuentemente en un arreglo: 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:
1 /**
2 * Programa para buscar un valor dado, y eliminarlo del arreglo
4 *@version 1.0.0
5 */
6
7 package ARREGLOS
9
10 public class EliminarElementoArreglo {

11
12 /**
13 *Metodo de busqueda Lineal; busca secuencialmente en cada elemento
14 *del arreglo hasta encontrar el elemento buscado o hasta llegar al final.
15 *@param arreglo Arreglo sobre el cual se busca el valorBuscado
16 *@param valorBuscado valor que se compara con cada elemento del arreglo
17 *@return La posicion en el arreglo, del valorBuscado
18 */
19 public static int busquedaLineal (int arreglo [ ], int valorBuscado) {
20 int posicion = - 1;
21 for(int i = 0; i < arreglo.length; i++)
22 if (valorBuscado == arreglo[i]) {
23 posicion = i;
24 eliminarElemento(arreglo, posicion);
25 break;
26 }
27 return posicion; //Retorna -1 si no encuentra el valorBuscado
28 }
29
30 public static void eliminarElemento(int arreglo[ ], int posicion) {
31 for(int i = posicion; i < arreglo -1; i++)
32 arreglo[i] = arreglo[i + 1];
33 arreglo[arreglo.length -1] = 0;
34 }
35
36 public static void main (String[ ] args) {
37 int[ ] arreglo = {23, 25, 29, 42, 44, 46, 48, 49, 57, 59, 68, 74, 75, 85, 97};
38 System.out.printIn("ARREGLO ORIGINAL");
39 System.out.printIn(Arrays.toString(arreglo));
40 int valorBuscado = 23;
41 System.out.printIn("%nElemento a eliminar;[%d]%n" , valorBuscado);
42 int posicionElemento = busquedalineal(arreglo, valorBuscado);
43 System.out.printIn(posicionElemento >=0
44 ? "Elemento [" + (valorBuscado) + "] eliminado de la posicion; ["
45 + posicionElemento + "]" : "ELEMENTO [" + (valorBuscado) + "] NO ENCONTRADO");
46 System.out.printIn("ARREGLO FINAL:");
48 }
49 }


ARREGLO ORIGEN:
[23, 25, 29, 42, 44, 46, 48, 49, 57, 59, 68,
74, 75, 85, 97]
Elemento a eliminar: [23]

Elemento [23] eliminado de la posicion:
[0]
ARREGLO FINAL:
[25, 29, 42, 44, 46, 48, 49, 57, 59, 68, 74,
75, 85, 97, 0]
Figura 5.7 Método para eliminar un elemento especifico y salida por pantalla.
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 último 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. Usted se cree capaz de programar
esta solución ayudándose de la Figura 5.7 Método para eliminar un elemento
especifico y salida por pantalla., de ser así genial, si no, no dude solicitarle la
solución a su docente tutor vía EVA.
5.5. Operaciones con la clase Arrays.
El API de Java proporciona una amplia cantidad de recursos para facilitar el

trabajo del programador en el tratamiento de los arreglos, uno de ellos es la clase
Arrays, que, entre muchos métodos, posee algunos para ordenar, buscar, copiar,
eliminar, etc. elementos de un arreglo. A continuación, un pequeño ejemplo:
1 package ARREGLOS;
2
4
5 public class ClasesVarias_Arreglos {
6

7 public static void main (String[ ] args) {

8 int elementoBuscar = 4;
9 int arreglo[ ] = {5, 6, 2, 1, 4}; //Arreglo de valores Original
10 System.out.printIn("ARREGLO ORIGINAL");
11 //Convierta a Strina un arreglo. Útil para su presentación directa.
13 //Ordena arreglos de objetos
14 //Collections.sort(List o ArrayList de objetos);
15 System.out.printIn("ARREGLO ORDENADO");
16 //Ordena un arreglo
17 Arrays.sort(arreglo);
19 //Busca en un arreglo, un elemento específico.
20 System.out.printf("%d encontrado en la posición %d%n", elementoBuscar,
21 Arrays.binarySerch (arreglo, elementoBuscar)+ 1);
22 }
23 }
Figura 5.8 Uso de la clase Arrays



▪▪ Del Capítulo 19, ejercicios: 19.7, 19.8


Autoevaluación 5
Hemos finalizado el estudio de esta última unidad en la asignatura, y es el

análisis, síntesis y evaluación, sobre los “Algoritmos sobre arreglos (búsqueda/
ordenamiento)”, con la presente Autoevaluación que busca lograr en usted el
siguiente Resultado de Aprendizaje (R.A):
“Revisar y aplicar los conceptos y estructuras de arreglos en los diferentes

algoritmos de búsqueda y ordenamiento.”
Instrucciones:
• Lea, revise, analice y evalué cuidadosamente cada uno de los

numerales, luego compare, relacione, aplique, organice y seleccione el
literal de la alternativa que mejor defina, corrija, complete o responda a
los conceptos, códigos, diagramas, etc. que se plantean a continuación.
• De las cuatro alternativas, más de una le podrá parecer correcta, pero

no es así; existe una única solución: (A), (B), (C), o (D).
• Anote sus respuestas, para que al final sea usted quien juzgue,
califique y autoevalúe, su nivel de competencias adquiridas,
comparando con el solucionario adjunto al final de esta guía de
estudios.
1. Las listas y tablas de valores pueden guardarse en ________ y ________.
A. arreglos – colecciones
B. clases – archivos
C. variables – objetos
D. métodos – arreglos

2. Dado el arregloA, escriba la instrucción en Java para mostrar el segundo

elemento.
int arregloA [ ] = {1, 8, 10, -4};
A. System.out.println(arregloA[1]);
B. System.out.println(arregloA[2]);
C. System.out.println(arregloA.length - 2);
D. System.out.println(arregloA[arregloA.length - 2]);
3. Dada la declaración de matriz, indicar el valor de verdad de las siguientes

afirmaciones:
int[ ][ ] matriz = new int[2][3];
AFIRMACIONES
1. La matriz tiene 3 filas.
2. La matriz tiene 2 columnas.
3. La matriz puede guardar 5 elementos.
4. El último elemento de la matriz es matriz[1][2]
A. Verdadero – Verdadero – Falso – Verdadero

B. Falso – Falso – Verdadero – Verdadero
C. Falso – Falso – Falso – Verdadero
D. Falso – Falso – Falso – Falso
4. Un arreglo es:
A. Un grupo de objetos (variables) que no guardan valores, sino sus

direcciones en memoria.
B. Un conjunto de elementos cuya longitud podría variar con la instrucción
for mejorado.
C. Una estructura de datos relacionada de longitud variable.
D. aryString = new String[2]

5. ¿Cuál es el motivo por el cual el siguiente flujo de código genera un

resultado de 2.0?
1 double opera = 0
2 double arrayNum [ ] = {2.6, 3.4, 4, 1.2, 0.8};
3 for (double num : arrayNum) {
4 opera += (num <=2) ? num ; 0
5 }
6 System.out.printIn(opera);
A. El 2.0 es el resultado de restar 4 - (1.2+0.8)

B. Es el resultado de la suma y resta de todos los elementos.
C. De los 5 elementos del arreglo se suman los menores o iguales a 2.
D. De los 5 elementos del arreglo se suman los mayores o iguales a 2.
6. Al declarar e inicializar arreglos o matrices, cuál de las siguientes sentencias

NO ES correcta:,
A. int A[ ] = new int[6];

B. int M [ ][ ] = {{2, 13, 37}, {4, 5, 7}};
C. int M [ ][ ] = {{9, -4, 16}, {74, -86, 91, 5}};
D. int A[ ] = new [3, 8, 2, 91];
7. Con el método de búsqueda binario ¿cuantas particiones se requieren para

encontrar el número 75 en el siguiente arreglo ordenado?
int [ ]arreglo = {13, 23, 24, 34, 35, 36, 38, 42, 47, 51, 68, 74, 75, 85, 97}
A. 1
B. 2
C. 3
D. 4

8. Con el método de búsqueda lineal, ¿cuantas iteraciones se requieren para

encontrar el número 100 en el siguiente arreglo?:
int[ ] arreglo = {23, 25, 29, 42, 44, 46, 48, 49, 57, 59, 68, 74, 75, 85, 97};
A. arreglo.length - 1
B. arreglo.length
C. 14
D. 0
9. De los métodos de búsqueda estudiados en esta guía, ¿cuál es el mejor

método para buscar dentro del siguiente arreglo?
int [ ]arreglo = {53, -13, 4, 35, 15, 36, -8, 2, 7, 15, -3, 4, 71, 95, 3}
A. Burbuja
B. Burbuja mejorado
C. Lineal
D. Binario
10. Ordenamiento por selección: en la primera iteración, se selecciona el

elemento más pequeño de toda la lista y se intercambia con el primer
elemento; en la segunda iteración, se selecciona el segundo elemento
más pequeño (el restante más pequeño) y se intercambia con el segundo
elemento, y así sucesivamente.

¿Dado lo anterior y el siguiente arreglo, como queda ordenado el arreglo con

el método por selección en la primera iteración (intercambio)?
int[ ] arreglo = {75, 95, 55, 56, 63, 81, 76, 59, 25, 66};
A. 25, 95, 55, 56, 63, 81, 76, 59, 75*, 66

B. 25, 75*, 95, 55, 56, 63, 81, 76, 59, 66
C. 75*, 95, 55, 56, 63, 81, 76, 59, 66, 25
D. 95, 55, 56, 63, 81, 76, 59, 66, 75*, 25

Guía Didáctica: Programación de Algoritmos SOLUCIONARIO
7. Solucionario
Unidad N° 1: Clases y Objetos en Java

Autoevaluación 1
Pregunta Respuesta Retroalimentación
1 D A. Incorrecta:new permite instanciar una clase mediante
un objeto, no tiene relación directa con el nombre del
archivo .java.
B. Incorrecta:extends permite heredar los atributos y

métodos public/protected de una clase padre.
C. Incorrecta:abstract define que una clase va ha tener un

método abstracto.
D. Correcta:El nombre del archivo .java, debe ser el

mismo que el de la clase definida como public.
2 A A. Correcta:El nombre del archivo .java, debe ser el
mismo que el de la clase definida como public.
B. Incorrecta:No, por que el nombre del archivo .java, debe

ser el mismo que el de la clase definida como public.
C. Incorrecta:El compilador relaciona el nombre del

archivo, con el nombre de la clase public, por ello esto
si importa.
D. Incorrecta:Object por default es clase padre de toda

clase en Java, y no tiene que ver con el nombre de la
clase en especial.


Autoevaluación 1
3 A A. Correcta:El nombre de la clase, atributos, métodos,
retornos y niveles de acceso son correctos.
B. Incorrecta:El nombre de la clase no corresponde a la

definida en el código.
C. Incorrecta:La distribución y niveles de acceso de los

componentes (nombre de la clase y atributos) es
incorrecta.
D. Incorrecta:El nivel de acceso del atributo es incorrecto.

4 C A. Incorrecta:Un atributo no encapsula a la clase.
B. Incorrecta:Un método no encapsula a la clase.
C. Correcta:El objeto si encapsula/instancia a una clase.
D. Incorrecta:Va de la particular (clase) a lo más general

(Uml), ello no es correcto.
5 A A. Correcta:Operador que se utiliza para crear un objeto
nuevo de una clase.
B. Incorrecta:extends permite heredar los atributos y

métodos public/protected de una clase padre.
C. Incorrecta:Object es superclase de todas las clases del

lenguaje Java por lo que no puede ser usado para crear
nuevos objetos.
D. Incorrecta:Es un marcador que permite identificar y

definir el inicio de la clase.


Autoevaluación 1
6 C A. Incorrecta:Un nivel de acceso son restricciones que
se asigna a los datos y no a los parámetros de los
métodos/funciones.
B. Incorrecta:Un nivel de acceso son restricciones que

se asigna a los datos y no a los parámetros de los
métodos/funciones.
C. Correcta:Los parámetros de entrada son variables que

deben tener un tipo y nombre.
D. Incorrecta:public/private son modificadores de acceso

para los atributos de una clase, no para parámetros de
entrada.
7 D A. Incorrecta:La variable por referencia establece una
conexión hacia un objeto.
B. Incorrecta:Este es un sinónimo para referirte a los

atributos de una clase, y no a su copia (instancia).
C. Incorrecta:Este es un sinónimo para referirte a las

variables internas de los métodos, y no a los atributos
de una clase.
D. Correcta:Cada vez que se crea un objeto, se crea una

copia de todos los componentes de la clase.
8 D A. Incorrecta:Los nombres de métodos deber ser verbos
que denoten acción.
B. Incorrecta:Estos son atributos y no métodos.
C. Incorrecta:Estos son atributos y no métodos.
D. Correcta:Son las acciones que se pueden realizar

sobre el objeto Libro.


Autoevaluación 1
9 B A. Incorrecta:Son tipos de datos que existen con o sin
POO.
B. Correcta:Se refieren a las propiedades establecer/

obtener y niveles de acceso en POO.
C. Incorrecta:Son sentencias repetitivas que existen con o

sin POO.
D. Incorrecta:Palabras reservadas generales para

programación en Java, con o sin POO.
10 A A. Incorrecta:“b” es publico, por lo tanto, existe acceso
interno o externo a la clase.
B. Incorrecta:No niveles de acceso si restringen la lectura/

escritura hasta el exterior de una clase.
C. Correcta:Específicamente “a” solo brinda acceso al

interior de su misma clase.
D. Incorrecta:a = a es incorrecto, se reescribe el mismo

valor dentro de si mismo, y no en el atributo de la clase.
11 A A. Correcta:En la línea 2, se llama el segundo método
sobrecargado (línea de código 7).
B. Incorrecta:Ninguno de los dos métodos sobrecargados

puede devolver este valor.
C. Incorrecta:metodoA(a) – línea 4 es el que devuelve este

valor, pero este no es invocado en la línea de código 2.
D. Incorrecta:Ninguno de los dos métodos sobrecargados

puede devolver este valor.


Autoevaluación 1
12 D A. Incorrecta:obtener() no tiene que ver nada con los
constructores, los set(tipo atributo), si.
B. Incorrecta:Los métodos de inicialización son los set(tipo

atributo).
C. Incorrecta:Los métodos de inicialización son los set(tipo

atributo).
D. Correcta:obtener() tiene todo que ver con los métodos

de consulta por que retornan el valor del atributo.
13 B A. Incorrecta:De una clase a otra, no se puede invocar
nada directamente, sin un objeto que instancia la clase.
B. Correcta:Por medio del objeto de invoca al método

enviando el parámetro de entrada correctamente.
C. Incorrecta:El parámetro de entrada se envía

incorrectamente.
D. Incorrecta:Es posible si el método sumar() es estático.

El parámetro de entrada se envía incorrectamente.
14 D A. Incorrecta:Las características de las clases hijas, no se
heredan a las superclases.
B. Incorrecta:Forma si es la clase principal, y Rectangulo

su clase hija.
C. Incorrecta:Los atributos de rectángulo si deben ser

inicializados en su propio constructor.
D. Correcta:Estas características aprovechan al máximo

la herencia.


Autoevaluación 1
15 C A. Incorrecta:cargo no es un atributo perteneciente a la
clase docente ni mediante herencia.
B. Incorrecta:bonificaciones no es un atributo
perteneciente a la clase docente ni mediante herencia.
C. Correcta:sueldo y horas son atributos que pertenecen

a la clase docente, mediante herencia.
D. Incorrecta:cargo no es un atributo perteneciente a la

clase docente ni mediante herencia.
16 B A. Incorrecta:puertas=puertas; ruedas=ruedas no es
correcto, se debe usar this.
B. Correcta:Se puede realizar, ya que esos atributos son

heredados desde el padre hacia la subclase.
C. Incorrecta:Se debe usar el operador this, si no, la

variable local (o parámetros de entrada) es igual a si
misma.
D. Incorrecta:La clase padre no tiene constructores

sobrecargados para inicializar individualmente cada
atributo.
17 A A. Correcta:,Por que es una operación única de la clase
Circulo, por que esta puede tener dos puntos.
B. Incorrecta:Un Punto no puede tener dos coordenadas,

por ello distancia() no debe pertenecer a Punto.
C. Incorrecta:Distancia no es clase, si no, un método.
D. Incorrecta:Coordenadas no es clase, si no, atributos.


Autoevaluación 1
18 B A. Incorrecta: No existe la definición de un constructor en
la clase empleado.
B. Correcta:El método heredado desde el padre

empleado hacia los hijos, es calcularSueldoBase()
C. Incorrecta:No se pueden heredar los miembros entre

cases adyacentes/hermanas (por llamarlo de una
forma).
D. Incorrecta:No se pueden heredar los miembros entre

cases adyacentes/hermanas (por llamarlo de una
forma).
19 D A. Incorrecta:El objeto pez de tipo Animal si es polimórfico,
por que instancia a la clase Pez.
B. Incorrecta:El objeto rana de tipo Animal si es

polimórfico, por que instancia a la clase Rana.
C. Incorrecta:El objeto ave de tipo Animal si es polimórfico,

por que instancia a la clase Ave.
D. Correcta:pez de tipo Animal no es polimórfico por que

instancia a su misma clase, una clase abstracta no es
instanciable.
20 C A. Incorrecta:Así es, pero no solo este método, si no
también el método Frenar()
B. Incorrecta:Así es, pero no solo este método, si no

también el método Avanzar()
C. Correcta:Éstos son abstractos en Transporte, por que

sus clases hijas son quienes deben implementarlos.
D. Incorrecta:Éstos no son métodos, si no, clases.

Unidad 2. Gestión de Excepciones en java

Autoevaluación 2
1 A A. Correcta: En el bloque try aún no existen errores –
excepciones; en el catch ya se habla de un(os) error(es)
generado(s) y que se debe(n) manejar.
B. Incorrecta: El bloque try no maneja la excepción, el

catch SI; el try encierra código que se debe vigilar.
C. Incorrecta: try podría capturar una excepción, pero

no se habla de try, sino del CÓDIGO incluido en try. Y
catch maneja la excepción, no la genera.
D. Incorrecta: Quien maneja la excepción es catch, no

try. El termino limpieza de la pila tiene que ver con
excepciones
2 C A. Incorrecta: En un segmento de código cuando se
genera una excepción la ejecución se interrumpe para
pasar al controlador de excepciones catch.
B. Incorrecta: La cláusula throw no previene excepciones,

las lanza. La cláusula try es quien captura las
excepciones, en Java una excepción no se previene, se
captura.
C. Correcta: Cuando se genera una alerta (problema/

error) en la ejecución de un bloque de código, se le
denomina EXCEPCIÓN.
D. Incorrecta: Una excepción es la posibilidad de

ocurrencia de errores, pero no necesariamente tiene un
porcentaje de probabilidad asignado.


Autoevaluación 2
3 B A. Incorrecta: El bloque subsecuente try no maneja una
excepción, la captura, pero el control del programa
no se pasa al siguiente try, sino al primer catch que
controle ese tipo de excepción generada.
B. Correcta: El primer bloque catch encontrado después

de generarse una excepción es el que maneja dicho
error, luego el control del programa no retorna a la línea
de código en la cual se generó la excepción, sino que
sigue su flujo fuera del catch.
C. Incorrecta: EL bloque catch maneja la excepción

lanzada, pero al finalizar este bloque catch el control
del programa no retorna al punto donde se generó la
excepción, la ejecución sigue su secuencia normal.
D. Incorrecta: Los bloques try no manejan excepciones,

solamente las captura, quien maneja las excepciones
son los bloques catch correspondientes.
4 D A. Incorrecta: El número de bloques try no se cuentan
por el número de bloques catch definidos en el código,
aunque para todo try debe existir al menos un catch.
B. Incorrecta: No son DOS el número mínimo de bloques

catch que debe haber para cada try, si, UNO.
C. Incorrecta: No puede existir un bloque try sin un catch y

viceversa.
D. Correcta: Los errores generados en el bloque de código

try deben ser manejados al menos en un bloque catch.


Autoevaluación 2
5 D A. Incorrecta: El algoritmo no define un control de errores
repetitivo, sino, secuencial y finito.
B. Incorrecta: El algoritmo no define un control de errores

repetitivo, sino, secuencial y finito.
C. Incorrecta: El algoritmo no representa el óptimo manejo

de excepciones, si, uno deficiente if-else
D. Correcta: Esta secuencia de verificaciones SI

(condición) entonces, es la que se interpreta como if-
else en Java
6 C A. Incorrecta: Si se captura inicialmente la excepción
PADRE Exception, en vano (y generando errores de
compilación), se captura las 3 restantes clases de
excepciones N2, N3 y N4.
B. Incorrecta: Si se captura inicialmente la excepción

PADRE Exception, en vano (y generando errores de
compilación), se captura las 3 restantes clases de
excepciones N2, N3 y N4.
C. Correcta: Perfecto, las clases de excepciones que

se deben capturar son: Ar, At, Ip y por si no se lanza
ninguna de las anteriores, capturamos Ex. (Excepciones
general), con el fin de prevenir cualquier error.
D. Incorrecta: Si se captura inicialmente la excepción

PADRE Exception, en vano (y generando errores
de compilación), se captura la restante clases de
excepciones RuntimeException, además, no se puede/
ni debe captura una misma clase de excepción dentro
de otro catch


Autoevaluación 2
7 C A. Incorrecta: Cuando todo va perfecto (no se lanzan
excepciones), el bloque 3 nunca se ejecuta.
B. Incorrecta: Cuando la excepción se lanza en un bloque/

sentencia sin manejo de excepciones (dentro de try-
catch), el programa finaliza su ejecución, por lo tanto,
al lanzar una excepción en el bloque 1, el 4 nunca se
avanza a ejecutar.
C. Correcta: Perfecto, sin excepciones el bloque 3 nunca

se ejecuta, no así cuando se generan excepciones en
los bloques 2 y 1
D. Incorrecta: Cuando todo va perfecto (no se lanzan

excepciones), el bloque 3 nunca se ejecuta.
8 A A. Correcta: No olvide que throws de la linea 1, es muy
diferente a throw.
B. Incorrecta: No hay riesgo de excepción, ya que solo se

esta declarando un objeto.
C. Incorrecta: InputMismatchException es la que se podría

lanzar.
D. Incorrecta: Si, si hay dos riesgos de excepciones.


Autoevaluación 2
9 C A. Incorrecta: Las lineas 1, 3 y 4 sin simples declaraciones/
definiciones.
B. Incorrecta: InputMismatchException es la que se podría

lanzar en la linea 5, en las demás, no hay peligro de
excepción.
C. Correcta: Al acceder a los elementos de un arreglo

con los indices, hay pelibro de lanzar la excepción
ArrayIndexOutOfBoundsException
D. Incorrecta: No hay acceso a ningún elemento de un

arreglo.
10 A A. Correcta: Todas las excepciones propias deben
heredar de la super clase Exception.
B. Incorrecta: Si hereda directamente de la super clase

Exception, esta bien definida.
C. Incorrecta: Si hereda directamente de la super clase

D. Incorrecta: Si hereda indirectamente de la super clase


Unidad 3. Archivos, flujos y serialización de objetos

Autoevaluación 3
1 A A. Correcta: Solo la primera afirmación es correcta, la
demás no lo son.
B. Incorrecta: Formatter contiene el método format para

imprimir datos con formato.
C. Incorrecta: La ruta absoluta contiene todos los

directorios que conducen hacia un archivo/directorio.
D. Incorrecta: Los archivos binarios no son legibles con

simples editores de texto.
2 C A. Incorrecta: El flujo es uno de salida hacia un archivo y

no de entrada desde el archivo.
B. Incorrecta: Este comportamiento polimórfico no es

correcto entre estas dos clases.
C. Correcta: Scanner es la que permite un flujo de entrada

basado en caracteres.
D. Incorrecta: El flujo es uno de salida hacia un archivo y

no de entrada desde el archivo.
3 A A. Correcta: ObjectInputStream es la que permite un flujo
de entrada basado en bytes.
B. Incorrecta: ObjectOutputStream es la que permite un

flujo de salida basado en bytes.
C. Incorrecta: Este comportamiento polimórfico no es

D. Incorrecta: Este comportamiento polimórfico no es



Autoevaluación 3
4 B A. Incorrecta: ObjectInputStream es la que permite un flujo
de entrada basado en bytes.
B. Correcta: ObjectOutputStream es la que permite un

flujo de salida basado en bytes.
C. Incorrecta: Este comportamiento polimórfico no es

D. Incorrecta: Este comportamiento polimórfico no es

5 A A. Correcta: Formatter es la que permite un flujo de salida
basado en caracteres.
B. Incorrecta: Este comportamiento polimórfico no es

C. Incorrecta: Scanner permite un flujo de entrada (no de

salida) basado en caracteres.
D. Incorrecta: El flujo es uno de entrada desde un archivo

y no de salida hacia el archivo.
6 C A. Incorrecta: El apellido del cliente no es indispensable,
pero lo más incorrecto es, definir un numero de asiento
como real.
B. Incorrecta: Un número de asiento para una sala de cine

son como los que se ejemplifican, no puede ser de tipo
int
C. Correcta: Excelente, los datos indispensables son:

nombre, película, hora y asiento, conjuntamente con
sus tipos.
D. Incorrecta: Hace falta el número de asiento, si no, el

cliente, no conocerá a que haciendo ha sido asignad.


Autoevaluación 3
7 B A. Incorrecta: Solo para la lectura de línea a línea basta un
ciclo, para split y el recorrido de este, uno más.
B. Correcta: El primer ciclo para recorrer el archivo, y el

segundo (interno) para recorrer el arreglo de split()
C. Incorrecta: No son necesarios tantos ciclos, solo uno

para recorrer todo el archivo, y otro más para recorrer el
split()
D. Incorrecta: No puede ser N ciclo indefinidos, eso en

programación no existe, o es un error de programación.
8 D A. Incorrecta: Es un ejemplo de una variable constante
(que no cambia de valor) no de dato persistente (en
disco).
B. Incorrecta: Es un ejemplo de arreglos, no de dato

persistente (en disco).
C. Incorrecta: Una lectura desde teclado no es un ejemplo

de dato persistente en disco.
D. Correcta: Así es, el dato 3.1415 es un valor que se

almacena en disco, en el archivo numeros.txt.
9 C A. Incorrecta: javac es un comando para compilar un
archivo .java, y no para localizar clases/paquetes.
B. Incorrecta: javac es un comando para compilar un

archivo .java, no un nombre de clase.
C. Correcta: javac es un comando para compilar un

archivo .java.
D. Incorrecta: -classpath permite localicar paquetes/clases,

no sirve para compilar un archivo .java.


Autoevaluación 3
10 A A. Correcta: Excelente, por que la DB UTPL contiene al
registro Docente y éste al campo docente[0].nom
B. Incorrecta: docente[0].nom no representa un registro, si

no un campo.
C. Incorrecta: docente[0].nom no representa una base de

datos, si no un campo.
D. Incorrecta: docente[0] = Docentes() no representa Base

de datos, si no un registro.

Unidad 4. Algoritmos recursivos

Autoevaluación 4
1 A A. Correcta: Perfecto, los fundamentos recursivos
afirmativos/reales son: 3, 4.
B. Incorrecta: En la afirmación 1. Si existe la recursividad

indirecta.
C. Incorrecta: Un método recursivo si es capaz solo de

resolver un caso base.
D. Incorrecta: La recursividad si es factible cuando en cada

llamada, el problema da haciéndose más pequeño.
2 D A. Incorrecta: Un método recursivo no se llama

necesariamente solo 2 veces.
B. Incorrecta: Si un método recursivo se llamara infinitas

veces, ocasionaría un error de StackOverflowError
C. Incorrecta: Quien lo invoca al método recursivo si es

otro, pero no necesariamente una sola vez y de forma
indirecta.
D. Correcta: Correcto, un método recursivo se llama a si

mismo, pero a través de una invocación inicial (directa o
indirecta) de otro método.
3 D A. Incorrecta: Este permite que las llamadas recursivas
continúen.
B. Incorrecta: Se aplica únicamente a ciclo, en recursividad

no podría aplicase por que no haría posible los retornos
recursivos.
C. Incorrecta: De ser así, no haría posible los retornos

recursivos con valores.
D. Correcta: El caso base se da cuando el if(pregunta) es

verdadera e inician los retornos recursivos.


Autoevaluación 4
4 B A. Incorrecta: La recursividad infinita es comparable
(analógicamente) con los ciclos infinitos.
B. Correcta: Correcto: la recursividad infinita es

comparable (analógicamente) con los ciclos infinitos.
C. Incorrecta: Solo si la recursividad SI CONVERGE en un

caso base, la misma llega a su finalización (recursividad
finita).
D. Incorrecta: Si la recursividad no converge en un caso

base, si se finaliza le ejecución de la misma, pero por
un error de StackOverflowError, el cual se da por que la
recursividad se tornó infinita.
5 C A. Incorrecta: Un paso recursivo y caso base se refiere a
iteraciones recursivas y no cíclicas.
B. Incorrecta: for/while se refiere a iteraciones cíclicas y no

a manejo de excepciones.
C. Correcta: Perfecto, cada término es estudiado en todas

las unidades de esta asignatura
D. Incorrecta: Burbuja e inserción son métodos de

ordenamiento, y no sirven para el manejo de
excepciones.
6 D A. Incorrecta: No es un ejemplo de recursividad directa ni
indirecta.
B. Incorrecta: Es un ejemplo de recursividad indirecta.
C. Incorrecta: No es un ejemplo de recursividad directa ni

indirecta, si cíclica iterativa.
D. Correcta: Esta es la mejor y corta definición de

recursividad directa.


Autoevaluación 4
7 C A. Incorrecta: Aquí recién inician las llamadas recursivas.
B. Incorrecta: No representa en caso base, si no la

cabecera del método recursivo.
C. Correcta: Se podría decir que es en la línea 6 o 7.
D. Incorrecta: Esta representa el paso recursivo, y no el

caso base.
8 C A. Incorrecta: Podría ser si se retorna solo valor y se
modifica el caso base de valor == -1.
B. Incorrecta: Podría ser si se retorna solo valor.
C. Correcta: En toda la pila de retornos recursivos siempre

se esta retornando el valor constante de 2.
D. Incorrecta: Nunca va a retornar este valor, por que en

cada llamada recursiva hay una operación (valor -1)
9 D A. Incorrecta: La operación de la línea 4, hace que jamás
se vaya a retornar el mismo valor de caso base.
B. Incorrecta: Por la operación de la línea 4, nunca se

retorna solo el valor – 1.
C. Incorrecta: Es ilógico que un método recursivo con

operaciones implicadas retorne el mismo valor que
recibe.
D. Correcta: Perfecto, el método recursivo calcula el

factorial del parámetro de entrada.


Autoevaluación 4
10 A A. Correcta: Aquí se rompe el ciclo, y se retorna el
resultado del factorial.
B. Incorrecta: Representa a las llamadas recursivas, y no

al caso base.
C. Incorrecta: Podría ser, pero de forma indirecta, ya que

aquí no se hace la validación y retorno inmediato.
D. Incorrecta: Se trata de una simple operación de

asignación, y no de ninguna característica de
recursividad.

Unidad 5. Algoritmos sobre arreglos

Autoevaluación 5
1 A A. Correcta: Los arreglos uni, bi o multi dimensionales
permiten almacenar estructuras de datos homogéneas,
y las colecciones heterogéneas.
B. Incorrecta: Los archivos de pronto si permiten

almacenar persistentemente datos, pero las clases no
sirven solo para ello.
C. Incorrecta: Un objeto si, pero una variable es un

concepto muy simple para describir esto.
D. Incorrecta: En los métodos se programa la gestión de

estos datos, pero no se almacenan directamente en
ellos.
2 A A. Correcta: Perfecto, ya que los índices para las
posiciones de un arreglo inician en cero (0).
B. Incorrecta: Al elemento mostrado aquí es el 10, es decir

el tercer elemento.
C. Incorrecta: Lo que se visualiza aquí es el tamaño del

arreglo – 2, es decir: 4 – 2 = 2.
D. Incorrecta: Al elemento mostrado aquí es el 10, es decir

el tercer elemento.
3 C A. Incorrecta: La matriz tiene 2 filas y 3 columnas.
B. Incorrecta: Al ser una matriz de 2x3, puede almacenar 3

elementos.
C. Correcta: Así es, es una matriz de 2x3, con 6

elementos, y el último esta en 2-1 filas, y 2-1 columnas.
D. Incorrecta: El último si esta en 2-1 filas, y 2-1 columnas.


Autoevaluación 5
4 A A. Correcta: Correcto, es por ello que un arreglo o
matriz se le conoce también como un tipo de dato por
referencia.
B. Incorrecta: Una vez definida la longitud del arreglo/

matriz, su longitud no es dinámica, sino, estática, es
decir, éste no puede variar.
C. Incorrecta: Si es una estructura de datos, pero no de

longitud variable, y fija.
D. Incorrecta: Esta no es la definición completa correcta

(ni teórica ni práctica/codificación). Esta sí: String
aryString[]; aryString = new String[2];
5 C A. Incorrecta: No, el 4 no es considerado dentro de la
operación/
B. Incorrecta: La suma de TODOS los elementos es 17
C. Correcta: Perfecto, la suma de los elementos

arrayNum3 y arrayNum3 es 2.0
D. Incorrecta: El if ternario (?) hace que se evalué una

condición y se ejecute una u otra sentencia.
6 D A. Incorrecta: Si es un arreglo de 6 elementos.
B. Incorrecta: Es una matriz correctamente declarada e

inicializada.
C. Incorrecta: Es una matriz correctamente declarada e

inicializada.
D. Correcta: No sigue la sintaxis de declaración de un

arreglo.


Autoevaluación 5
7 D A. Incorrecta: Si el 75 estuviera en la posición central, si,
fuera en la primera iteración del ciclo.
B. Incorrecta: Si el 75 estuviera en la posición central de

una de las mitades del arreglo, si, fuera correcto.
C. Incorrecta: El 75 se va ha localizar en la última iteración

del arreglo, no en la antepenúltima.
D. Correcta: El 75 se va ha localizar en la última iteración

del arreglo.
8 B A. Incorrecta: No validaría el último elemento de ser así.
B. Correcta: Debe recorrer todo el arreglo en búsqueda

del 100,
C. Incorrecta: No validaría el último elemento de ser así.
D. Incorrecta: No haría ninguna comparación de ser así.

9 C A. Incorrecta: Este no es un método de búsqueda, si de
ordenamiento.
B. Incorrecta: Este no es un método de búsqueda, si de

ordenamiento.
C. Correcta: Así es, el lineal/secuencial no requiere un

arreglo ordenado para el fin.
D. Incorrecta: El arreglo no esta ordenado, es por ello que,

este algoritmo no aplica.


Autoevaluación 5
10 A A. Correcta: Así es, el 25 que es el primer elemento
menor queda al inicio, y en lugar del 25, se ubica el 75.
B. Incorrecta: Esto proceso se podría parecerse más al

método por inserción o burbuja, menos al de selección.
C. Incorrecta: Podría ser, pero por definición del método,

se ordena desde el inicio hasta el final.
D. Incorrecta: Esto proceso se podría parecerse más al

método burbuja, menos al de selección.

Guía Didáctica: Programación de Algoritmos REFERENCIAS BIBLIOGRÁFICAS
8. Referencias bibliográficas
Deitel, Paul. Deitel, H. (2016). Cómo programar en Java. (Sergio Fonseca Garza,
Alan David Palau, y otros.) (10th ed.). México: Pearson Educación.
Irene, P. (2020): Guía didáctica de Programación de Algoritmos, Ecuador, Editorial

UTPL.
Cadenhead, R. (2014). Java 8. (Grupo Comercial Anaya, Ed.) (1st ed.). Madrid:
Ediciones Anaya.
Montero, M. R. (2014). Java 8. (Grupo Comercial Anaya, Ed.) (1st ed.). Madrid:
Multimedia Anaya.
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 Enlace
web: http://ocw.upm.es/course/programacion-en-java-i [Consultado 26-07-
2019].
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.
Enlace Web https://ocw.ehu.eus/pluginfile.php/5429/mod_resource/content/1/
intro_java/Course_listing.html [Consultado 26-07-2019].
10e. Deitel. [En línea]. Enlace Web http://www.pearsonenespanol.com/
mexico/educacion-superior/deitel_index/como-programar-en-java-10e
Deitel & Associates (2017): Sitio Web del texto básico: Java How to Program, 10/e
(Early Objects) [En línea]. Enlace Web http://www.deitel.com/books/jhtp10/

Guía Didáctica: Programación de Algoritmos REFERENCIAS BIBLIOGRÁFICAS
9/e. [En línea]. Enlace Web http://recursosmcc.pearsonenespanol.com/
Deitel/material_adicional.html [Consultado 28-08-2019].
Jaor Software (2019): Un vistazo al Nuevo Apache NetBeans Versión 11. [En
línea]. Enlace web https://www.youtube.com/watch?v=bAsdyFAcOGU
Deitel & Associates (2019): Red social Deitel y de alguna de sus obras. [En línea].
Enlace Web http://www.deitel.com/deitelfan [Consultado 28-08-2019].

Guia

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia

Cargado por

Copyright:

Formatos disponibles

Informática

Modalidad Abierta y a Distancia

La Universidad Católica de Loja

Departamento de Ciencias de la Computación y Electrónica

La Universidad Católica de Loja

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA

Diagramación y diseño digital:

4.3. Direcciones de Internet: 9

5. Orientaciones generales para el estudio 11

6. Proceso de enseñanza-aprendizaje para el logro de competencias 14

UNIDAD 1. CLASES Y OBJETOS EN JAVA 14

1.1. Qué es programación orientada a objetos. 15

1.2. Atributos (primitivos/por referencia), niveles de acceso. 19

1.3. Métodos, propiedades (set, get), constructores y sobrecarga. 22

1.4. Encapsulamiento, ocultación y paquetes. 27

UNIDAD 2. GESTIÓN DE EXCEPCIONES EN JAVA 55

2.1. Fundamentos sobre el manejo de excepciones. 55

2.2. Las excepciones en el API de Java. 58

2.3. Uso de try-catch-finally. 62

2.4. La instrucción throw-throws. 64

2.5. Generar excepciones propias. 67

UNIDAD 3. ARCHIVOS, FLUJOS Y SERIALIZACIÓN DE OBJETOS 80

3.1. Conceptos preliminares sobre los datos. 81

3.2. Flujos en Java. 82

3.3. Escritura y lectura de datos en ficheros secuenciales. 83

3.4. Serialización de objetos. 90

UNIDAD 4. ALGORITMOS RECURSIVOS 100

4.1. Introducción y conceptos básicos de recursividad. 100

4.2. Aplicación de la recursividad. 102

4.3. Comparación entre recursividad e iteración. 106

UNIDAD 5. ALGORITMOS SOBRE ARREGLOS 114

5.1. Estructura de un arreglo. 114

5.2. Algoritmos de búsqueda. 118

5.3. Algoritmos de ordenamiento. 121

5.4. Operaciones adicionales en un arreglo. 126

5.5. Operaciones con la clase Arrays. 128

8. Referencias bibliográficas 159

Con esta asignatura se pretende que usted resuelva problemas computacionales

Los contenidos que abarca la asignatura están estructurados en cinco unidades; 2

La primera unidad, el estudio se enfoca en las Clases y Objetos en Java (POO

Luego en la segunda unidad (última del primer bimestre) estudiaremos la

En el segundo bimestre tercera unidad (primera del segundo bimestre), el tema

Para la cuarta unidad miraremos algunos Algoritmos Recursivos, de forma

6 MODALIDAD ABIERTA Y A DISTANCIA

Y finalmente en la quinta unidad revisaremos algunos Algoritmos sobre

Debo puntualizar que esta asignatura no es para aprender la lógica ni los

Poniéndome a su entera disposición, le dejo un pensamiento de Carlos

7 MODALIDAD ABIERTA Y A DISTANCIA

Texto: Deitel, P. y Deitel, H. (2016). Cómo programar en Java. México: Pearson

Se ha seleccionado este texto básico por las ventajas pedagógicas y

Guía: Irene, P. (2020). Guía didáctica de Programación de Algoritmos. Loja,

La guía didáctica contiene las indicaciones que debe tener en cuenta

8 MODALIDAD ABIERTA Y A DISTANCIA

Cadenhead, R. (2014). Java 8. Madrid: Ediciones Anaya.

La obra cuenta con un sencillo enfoque paso a paso que le ayudará a

Montero, M. R. (2014). Java 8. Madrid: Multimedia Anaya.

Java 8 es una obra puntual que presenta los conceptos de Programación

4.3. Direcciones de Internet:

Beltrán, A. y Santamaría, J. (2009): Programación en Java I OpenCourseWare de

Recurso OCW de la asignatura Programación en Java I que se dicta en

Sarriguren, A. Serrano, J y Alonso, L. (2009): Introducción a la programación

Presentación de los elementos básicos de programación y de la

9 MODALIDAD ABIERTA Y A DISTANCIA

Corresponde al sitio web del texto básico “Cómo programar en Java” de