Programación III Java ISP

Instituto
ISP Superior
Pascal
TDS - Tecnicatura en Desarrollo de Software

Programación III - tercer cuatrimestre
índice
presentación 3
objetivos 5

programa 5

bibliografía 7
clases
clase 1 | 8
clase 2 | 24
clase 3 | 42
clase 4 | 94
clase 5 | 124
clase 6 | 154
clase 7 | 178
clase 8 | 194
clase 9 | 215
clase 10 | 236
clase 11 | 254
clase 12 | 264

evaluación integradora 278
impresión total del documento ! 278 páginas
ISP | Programación III | Tercer Cuatrimestre 2

presentación Le damos la bienvenida a la materia PROGRAMACIÓN III, en la cual continuará
transitando los caminos de la codificación.
Cabe destacar que esta asignatura es la continuación de PROGRAMACIÓN II y

de INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS, por lo
cual usted podrá hacer uso de todo lo aprendido en la misma para resolver pro-
blemas computacionales, pasando por todas las fases: algoritmia, diagramación,
pseudo codificación y codificación.
La materia se compone de cinco módulos: en el primero (que abarca las clases 1

y 2) abordaremos el lenguaje de la programación Java; en el segundo (clases 3, 4
y 5) trabajaremos con estructuras de datos dinámicas; en el tercer módulo (clases
6, 7 y 8) y cuarto módulo (clases 9, 10 y 11) nos focalizaremos en la Introducción
a Programación con Objetos en Java. Finalmente, en el quinto módulo abordare-
mos la programación en Entorno Web.
El programa está pensado en función de la siguiente idea:
La programación es una profesión en continuo crecimiento y su constante com-

plejización garantiza un futuro laboral, un trabajo dinámico, que permite utilizar
la creatividad e innovar de manera constante, trayendo aparejado la actualiza-
ción permanente.
Por lo tanto, las prácticas están focalizadas en la programación orientada a obje-

tos en Java, que le permitan desarrollar habilidades para brindar una respuesta
acorde a la necesidad que se le plantee. Es decir, en esta asignatura codifi-
cará en lenguaje Java posibilitándole estar a tono con las necesidades actuales
para sistemas operativos diversos y plataformas diferentes. En resumen, para un
entorno en constante evolución.
En cada clase se le presentarán conceptos, explicaciones, lecturas y ejercicios

para que resuelva. Recuerde que es muy importante detenerse en cada actividad
y realizar los ejercicios propuestos ya que consolidarán lo estudiado en cada
tema y lo preparará para las evaluaciones.
Nosotros estaremos allí para despejarle todas las dudas que puedan surgirle de
forma tal que se sienta seguro para dar un paso más adentrándose al conoci-
miento.

A continuación, les compartiremos un video, que podrá visualizar
desde plataforma, que resume lo antedicho, tomando como eje la
programación Java:
Disponible tambien en https://www.youtube.com/

watch?v=h43aGUwIJ50
Importante:
• Deben entregar, enviar, compartir o subir a plataforma las actividades del

tema 3 - clase 5 y la clase 12 como parte práctica del final de PIII.
• Recordar que las clase 7 y 8 tienen prácticas que serán base para el teó-
rico del parcial 2.
• Por otro lado, la clase 9 es base de algunas preguntas del teórico del final.
¡Adelante!

objetivos ∙ Aprender las herramientas Java para el desarrollo orientado a objetos
que permitan que su aplicación sea una solución a problemas computa-
cionales.
∙ Aprender la metodología de resolución de problemas con la finalidad de

brindar soluciones concretas y oportunas usando la programación orien-
tada a objetos en Java.
∙ Identificar la magnitud de un problema, para poder usar herramientas

ligadas a la construcción y ejecución de programas escritos en Java
orientado a objetos.
∙ Descomponer un problema en tantas partes como sea necesario de

manera tal que permita la obtención de soluciones simples para cada
fracción, y no complejas para un todo.
∙ Desarrollar módulos Java de fácil comprensión que expresen claramente

la solución al problema o requerimiento, para que puedan encararse
desde la perspectiva del colaborativo.
∙ Desarrollar habilidades para generar código Java eficientes que utilicen

los recursos disponibles de manera apropiada y que puedan reutilizarse
para soluciones a problemas similares.
programa
Módulo 1: Lenguaje de Programación Java. Revisión PII
• Desarrollado en las Clases 1 y 2
Objetivos específicos
● Revisar los aspectos más importantes de la programación en Java para afian-
zar las bases del lenguaje.
● Revisar los distintos modelos de diseño para lograr una representación fiel de
la situación a desarrollar
● Aplicar los modelos según el caso para acortar la brecha entre el modelo real
y el modelo virtual.
Contenidos
Estructuras de Estáticas de Datos. Variable única. Arreglos Unidimensionales.
Arreglos multidimensionales. Código Java para cada caso.
Estructuras de Programación: Secuencial. Condicional. Repetitivas. Código Java
para cada caso.

Módulo 2: ESTRUCTURAS DE DATOS DINÁMICAS
• Desarrollado en las Clases 3, 4 y 5
• Conocer las estructuras más importantes a la luz del desarrollo de siste-
mas, para dominar el ejercicio de la programación lógica.
• Determinar la necesidad de la aplicación de estas estructuras, para otor-
gar cierto grado de análisis al código que se desarrolle.
Contenidos
Estructuras de datos dinámicas. Lineales: pilas, colas y listas. No lineales: árbo-
les y grafos. Ordenamientos: Tipo de ordenamientos. Ordenamientos en Java
Módulo 3: Introducción a Programación con Objetos en Java - Parte 1

• Reconocer los aspectos más importantes de la programación orientada
a objetos en Java, para lograr abstracciones que representen a la realidad del
cliente.
• Reconocer los distintos modelos de diseño y su sintaxis, para afianzar técni-
cas de desarrollo de software.
Contenidos
POO y resolución de problemas. Objetos y mensajes. Diagramas de secuencia.
Comportamiento y su implementación. Encapsulamiento y Polimorfismo (nocio-
nes).
Módulo 4: Introducción a Programación con Objetos en Java - Parte 2

• Aprender la relación entre los objetos y sus formas de comunicación,
para obtener modelos fieles al entorno del cliente.
• Reconocer los diferentes estados y transiciones por las cuales pasa un
objeto y su relación con los eventos, para lograr un desarrollo eficiente.
Contenidos
JDBC. SWING. SERVLET. Concepto. Aplicaciones. Tipos.

Módulo 5: Programación Entorno Web
• Desarrollado en la Clase 12
• Aplicar los contenidos vistos en las clases anteriores, para abordar el
desarrollo como solución problemas reales.
• Reconocer las ventajas y desventajas de este tipo de programación, para
poder realizar recomendaciones adecuadas a los clientes.
Contenidos
Introducción a la tecnología WEB con J2EE. Modelo cliente-servidor. Acceso a
Datos. Conceptos y ejemplos. Práctica final.
bibliografía
Material básico:
• Material de estudio desarrollado en cada Clase.
• DEITEL, Harvey M y DEITEL, Paul J., Cómo programar en Java, 9na.
edición, Prentice-Hall, ISBN: 978-970-26-1190-5, México, 2012.
Material complementario:
• BARNES D.J. y KÖLLING M. Programación orientada a objetos con Java.

Una introducción práctica usando BlueJ. Pearson Educación, 2007.
• BELL, Douglas y PARR, Mike. Java para estudiantes. 6ta. edición,

Pearson Educación, México, 2011.
• TEO, F.J.M. Manual imprescindible de Java 7. Anaya Multimedia-Anaya

Interactiva, México, 2011.
• WEISS, Mark Allen. Estructuras de datos en java. Pearson Educación,

2013.

clases
clase 1
ESTRUCTURAS ESTÁTICAS DE DATOS
introducción
Lo que buscamos en esta primera clase es que usted, recuerde algunos temas
vistos en varias materias ya cursadas. Vamos a comenzar por las variables y
arreglos, y cómo se programan en Java.
Retomando e integrando conceptos y prácticas podremos resolver problemas
computacionales propios y de terceros.
Es hora de comenzar a revisar. ¿Me acompaña?
clase 1
tema 1 TEMA 1: VARIABLE ÚNICA. ARREGLOS UNIDIMENSIONALES. ARREGLOS
MULTIDIMENSIONALES.
Cuando realizamos desarrollos, dependemos de variables. Ellas son necesarias

pues asumen distintos valores según las necesidades del usuario.
Dentro del grupo de variables encontraremos aquellas que pueden tomar un valor
y aquellas que toman varios valores.
Como vemos en la figura

Las variables que toman un solo valor, funcionan como caja de almacenaje
momentáneo. Veamos la siguiente figura
Las variables son procesadas para producir salidas. Veamos un ejemplo senci-
llo. Usted quiere hacer un bizcochuelo. A la hora de agregar los huevos puede
hacerlo de dos maneras, de a uno (variable única) o todos juntos (arreglo de
huevos)
Para hacerlo gráfico

Habiendo ejemplificado cada caso, definiremos
En programación, las variables son espacios reservados en la

memoria que pueden cambiar de contenido a lo largo de la eje-
cución de un programa.
En programación, hablamos de arreglos, cuando tenemos una
colección de datos del mismo tipo. Es colección es finita y orde-
Atención nada. Se almacenan bajo el mismo nombre y sus elementos
pueden ser accedidos por su orden específico. Se ubican de
manera consecutiva en la RAM.
Los arreglos se pueden clasificar en

● Unidimensionales
● Bidimensionales

● Multidimensionales.
Con los arreglos podemos hacer operaciones como:

● Lectura → implica el acceso a través de sus índices
● Escritura → consiste en asignar un valor a un elemento específico.
● Actualización → Dentro de esta operación se encuentran las operaciones
de eliminar, insertar y modificar datos.
● Ordenamiento → existen diferentes tipos
○ Selección directa
○ Burbuja
○ Por mezcla
● Búsquedas
○ Secuencial
○ Binaria
○ Hash
Ordenamientos en Arreglos
Dado que los arreglos tienen mucha utilidad en el ámbito de la programación y

que no ellos podemos hacer agrupaciones que serán utilizadas en diversos pro-
cesos, en algunos casos es muy útil contar con sus elementos ordenados.
Por esa causa existen diversos algoritmos que permiten ordenar los arreglos.
Algunos más eficientes que otros, pero todos eficaces.
Mira la animación animación1

Algoritmos de Búsqueda
Así como existen algoritmos para ordenar, están los propios para buscar dentro
de un arreglo.
Contamos con, la secuencial, binaria y la hash. Veamos cada una de ellas.

Les dejo un video, disponible desde la plataforma, para profundi-
zar lo visto. El audiovisual les muestra de una manera muy gráfica
los métodos de ordenamiento vistos, como así también los algorit-
mos de búsqueda.
Lo que acabamos de ver es solo una parte de todo este gran tema, que profun-
dizaremos en la clase 5, cuando ya tengamos en claro otra serie de estructuras
de programación.
LECTURA COMPLEMENTARIA Si quieren profundizar les reco-

miendo lean del material complementario Weiss, Mark Allen.
Estructuras De Datos En Java. Pearson Educación, 2013.
Leer

clase 1 TEMA 2: VARIABLE ÚNICA EN JAVA
tema 2
Ahora a revisar todo el Tema 1 en Java. Comenzaremos con las variables. Dire-
mos que una variable en Java es un identificador que representa un lugar de
memoria que contiene información. El tipo de información que guarda una varia-
ble sólo puede ser del tipo con que se declaró esa variable.
Veamos el siguiente cuadro:
Recordemos que Java posee dos grandes categorías de tipos para las variables:
● Tipo Primitivo: Las variables de tipos primitivos almacenan directamente
un valor que siempre pertenece al rango de ese tipo. Por ejemplo una
variable int almacena un valor entero como 1, 2, 0, -1, etc.
● Tipo Referencia: Las variables de tipo referencia a objetos almacenan

direcciones y no valores directamente. Una referencia a un objeto es la
dirección de un área en memoria destinada a representar ese objeto. Las
variables referencia son referencias o nombres de una información más
compleja: arrays u objetos de una determinada clase.

Nombre de las Variables
Los nombres de variables en Java se pueden crear con mucha libertad. Pueden
ser cualquier conjunto de caracteres numéricos y alfanuméricos, sin algunos
caracteres especiales como operadores o separadores ( ,.+-*/ etc.).
Existe una serie de palabras reservadas las cuales se usan de una manera par-
ticular en Java y por lo tanto no se pueden utilizar como nombres de variables.
Dichas palabras son:
(*) son palabras reservadas, pero no se utilizan en la actual implementación del

lenguaje Java.
Veamos un ejemplo de declaraciones:

Cabe destacar que con todo este tipo de variables, podemos realizar procesos
destinados a resolver situaciones específicas como respuesta a la solicitud de los
clientes.
Si quieren revisar las operaciones que se pueden hacer con las

variables los invito a revisar el Módulo 2 – Programación II, allí
encontrarán todo lo necesario para poder hacer la actividad que
Atención les propongo a continuación.
Actividad 1: Refrescando Java

A.
Actividad

Actividad 2: Seguimos repasando temas
Actividad
ARREGLOS UNIDIMENSIONALES EN JAVA
Como ya sabemos, un arreglo es una estructura de almacenamiento que per-

mite guardar un conjunto de objetos del mismo tipo.
Se accede a cada elemento a través de su índice. Siendo 0 es el índice del
primer elemento y n-1 es el índice del último elemento, siendo n, la dimensión
del arreglo.
Para crear un arreglo se hace así:
int[] numeros;
Con esa línea se crea la variable tipo Array (arreglo). Con numeros = new
int[5]; creamos el objeto Array y le indicamos cuántos elementos tendrá el
arreglo.
Ejemplo

Así se le asignan valores a los elementos:
Actividad 3: Continuamos trabajando con JAVA
Actividad
ARREGLOS MULTIDIMENSIONALES EN JAVA
Recordemos que un arreglo multidimensional es aquel que posee más de una

dimensión. Si bien existen de muchas dimensiones, a los efectos prácticos vere-
mos los que poseen dos dimensiones.
El acceso a los mismos se hace a través de sus subíndices, uno para hacer refe-
rencia a la fila y otro a la columna.
En la imagen que sigue podemos ver los tipos de datos vistos:

Veamos un ejemplo:
Actividad 4: ¡A desarrollar!
Actividad
Como se dice en la jerga informática, “se aprende a desarrollar desarrollando”,

yo creo en eso, pero también debemos basarnos en documentación y en material
bibliográfico, por eso les aconsejo las lecturas siguientes:
LECTURA COMPLEMENTARIA - Si quieren profundizar les reco-

Estructuras De Datos En Java. Pearson Educación, 2013
Leer
LECTURA OBLIGATORIA Si desea profundizar este tema puede
hacerlo a través de la bibliografía obligatoria DEITEL, Harvey M y
DEITEL, Paul J., Cómo programar en Java, 9na. Edición, Prentice-
Hall, ISBN: 978-970-26-1190-5, México, 2012

clase 1
claves de corrección Actividad 1: Refrescando Java
A-
Solución:

Actividad 2: Seguimos repasando temas
Solución

Actividad 3: Continuamos trabajando con JAVA
Solución
Actividad 4: ¡A desarrollar!
Solución
package actividad4;
import java.util.*;
public class Bidimensional2 {
public static void main(String[] args) {

final int FILAS = 5, COLUMNAS = 4;
Scanner sc = new Scanner(System.in);
int i, j, mayor, menor;
int filaMayor, filaMenor, colMayor, colMenor;
int[][] A = new int[FILAS][COLUMNAS];
System.out.println(“Lectura de elementos de la matriz: “);
for (i = 0; i < FILAS; i++) {
for (j = 0; j < COLUMNAS; j++) {
System.out.print(“A[“ + i + “][“ + j + “]= “);
A[i][j] = sc.nextInt();

}
}
System.out.println(“valores introducidos:”);
for (i = 0; i < A.length; i++) {
for (j = 0; j < A[i].length; j++) {
System.out.print(A[i][j] + “ “);
}
System.out.println();
}
mayor = menor = A[0][0];//se toma el primero como mayor y menor
filaMayor = filaMenor = colMayor = colMenor = 0;
for (i = 0; i < A.length; i++) { //

for (j = 0; j < A[i].length; j++) {
if (A[i][j] > mayor) {
mayor = A[i][j];
filaMayor = i;
colMayor = j;
} else if (A[i][j] < menor) {
menor = A[i][j];
filaMenor = i;
colMenor = j;
}
}
}
System.out.print(“Elemento mayor: “ + mayor);
System.out.println(“ Fila: “+ filaMayor + “ Columna: “ + colMayor);
System.out.print(“Elemento menor: “ + menor);
System.out.println(“ Fila: “+ filaMenor + “ Columna: “ + colMenor);
}
}
clase 1 Estructuras Estáticas de Datos

conclusiones
Llegamos al final de la clase y hemos revisado dos temas que son la base de la
programación, la estructura básica de los datos que usan en un desarrollo.
En la clase siguiente nos embarcaremos en las estructuras de programación.

clase 2 ESTRUCTURAS DE PROGRAMACIÓN
introducción
Como ya hemos visto en Programación I y en Introducción a la Programación
Orientada a Objetos, existen diferentes estructuras de programación.
Las mismas nos permiten expresar preguntas, o situaciones que se repiten o

controles. Durante esta clase repasaremos los conceptos de cada una de las
estructuras básicas, seguidas por ejemplos acordes a cada situación.
Espero me acompañen.
clase 2 Estructuras de Programación

tema 1
Tema 1: Secuencial. Condicional. Repetitivas.
Vamos a comenzar repasando con imágenes:

¿Te diste cuenta? Espero que sí. Las imágenes nos muestran cuestiones comunes
que los desarrolladores deben traducir a código para poder brindar soluciones
computacionales a los clientes.
Cada una de las imágenes anteriores, representa una estructura de programa-

ción.
La característica fundamental de las estructuras secuenciales, es los pasos reso-

lutivos, se dan uno tras otro.
Sería el caso de ingresar dos edades, sumarlas y mostrar el resultado. Si el caso
lo tuviéramos que definir como una secuencia, diríamos:
1. Ingrese las edades

2. Sumar las edades
3. Mostrar resultado.
No hay lugar a duda que un paso depende del anterior y que deben hacerse en
ese orden.
La estructura secuencial es aquella en la que una instrucción

sigue a otra en secuencia. Las tareas se siguen de tal modo
que la salida de una es la entrada de la siguiente y así hasta el
Atención fin del proceso.

En el caso de las estructuras condicionales, vienen a aportar cierta lógica a las
soluciones. En este caso una acción depende de un análisis previo. Según sea el
resultado se ejecutará o no determinado proceso.
Las estructuras condicionales comparan variables para que, de

acuerdo al resultado de esta comparación, se siga un curso de
acción dentro del programa. Existen simples, dobles y múlti-
ples.
Una estructura es simple, si posee solo una respuesta.
Atención
Una estructura es doble, si posee dos respuestas.

Una estructura es múltiple, si posee varias respuestas.
Por último nos encontramos con
También los conocemos como ciclos, ellos nos permiten representar acciones
que se dan de manera reiterada.
Son aquellos en cuya solución es necesario utilizar un mismo

conjunto de acciones que se puedan ejecutar una cantidad
específica de veces. La cantidad de repeticiones puede ser fija
Atención o variable.

Existen

Estructuras De Datos En Java. Pearson Educación, 2013.
Leer
LECTURA OBLIGATORIA Para profundizar este tema lea la

bibliografía obligatoria DEITEL, Harvey M y DEITEL, Paul J.,
Cómo programar en Java, 9na edición, Prentice-Hall, ISBN: 978-
970-26-1190-5, México, 2012.
clase 2 Estructuras de Programación

tema 2 Tema 2: Java de las estructuras.
De una manera muy concisa vamos a revisar este tema. Para poder abordar el
mismo, vamos a ver un ejemplo de cada caso. Al finalizar tendrá una serie de
ejercicios para resolver.
Estructura Secuencial
Leamos el siguiente enunciado.
Como verá, podemos dividirlo en pasos:

1. Declarar una variable N
2. Asignarle un valor
3. Sumarle 77
4. Mostrar
5. Restarle 3
6. Mostrar
7. Duplicarla
8. Mostrar
De los pasos 3 en adelante podemos agruparlos en procesar. Entonces quedaría

así:

Veamos en código:
Recordemos el flujo:

Estructura Condicional Simple
Leamos el siguiente enunciado:
Podemos ver que se pide el análisis de una variable SÓLO determinar si es par y
luego del análisis avisar de esa situación.
Su código es:
Su flujo se ve así:

Estructura Condicional Doble
En este caso para si un número es par si el resto de dividir el número entre 2 es

igual a cero. En caso contrario el número es impar
El operador Java que calcula el resto de la división entre dos números enteros o
no es el operador %
Su código es:

Estructura Condicional Múltiple
Podemos ver que, se debe hacer una selección entre diferentes valores que
puede asumir el ingreso.
Su código es:

Estructura Repetitiva Para
Podemos ver que se pide el ingreso de 100 números mediante la estructura

para. Su código es:
Estructura Repetitiva Do .. While


Podemos ver que se pide el ingreso de 100 números mediante la estructura do
while. Su código es:

Estructura Repetitiva While
Podemos ver que se pide el ingreso de 100 números mediante la estructura

while. Su código es:

Leer
970-26-1190-5, México, 2012.
Si quieren revisar las operaciones que se pueden hacer con las variables les
invito a revisar el Módulo 3 - PII, allí encontrarán todo lo necesario para poder
hacer la actividad que les propongo a continuación.
Actividad 1: Llegó el momento de ejercitar
A continuación se les presenta una serie de ejercicios de cada

Actividad estructura vista
Desarrolle en Java los siguientes programas:

Actividad 1: Llegó el momento de ejercitar
clase 2
claves de corrección
Soluciones
1

2

4
clase 2
Como hemos visto a lo largo de la clase, podemos representar la mayoría de
conclusiones las situaciones de la vida cotidiana, usando estructuras de programación bási-
cas. Pero debemos seguir avanzando, dado que hay situaciones complejas,
que requieren otro tipo de estructuras de almacenamiento y programación. Nos
vemos la clase que viene.

clase 3 ESTRUCTURAS DE DATOS DINÁMICAS LINEALES
introducción
En las clases anteriores hemos trabajado con estructuras de datos estáticas.
Podemos decir de ellas que el tamaño que ocupan en la memoria se define antes
de que el programa se ejecute, sin posibilidad de actualización de esta situación
en el momento de ejecución.
Esto es ciertamente una situación problemática para el uso racional de la memo-

ria y por tal motivo surgen las estructuras de datos dinámicas.
Durante esta clase haremos un recorrido conceptual y práctico. Espero me acom-

pañen.
clase 3 Pilas
tema 1
Para comenzar con este tema mira con atención la siguiente figura:
¡Si!, yo dije lo mismo, ¡qué delicia!, cómo no desayunar o merendar una PILA
de churros. En este caso si nosotros queremos comer un churro, lo sacamos de
arriba para que no se desmorone y si queremos agregar uno lo apilamos, por la
misma razón.
En informática una PILA es algo similar. Es una estructura de datos dinámica

lineal, donde los datos se van acomodando por “arriba”

Una pila es un contenedor de datos basado en LIFO (Last
Input Firt Output). En este tipo de estructura los datos pueden
insertarse y suprimirse elementos solo por un extremo, llamado
frente; es decir, en una pila el último dato en entrar es el primero
en salir.
Atención
Es una estructura de datos homogénea, secuencial y de tamaño
variable.
Operaciones Aplicables a una Pila
Existen dos tipos de operaciones que podemos realizar con pilas:
Entonces conceptualmente una pila de llena por encima y se vacía de la misma

manera. Ahora veamos cómo hacer esto en Java.
Supongamos el siguiente caso. Queremos apilar libros. Para ello vamos a crear
una pila. Vamos hacer que sea de libros y vamos a sacar libro y poner libros.

Usando la clase STACK, como pueden ver se crea la pila, luego las cosas que
van en la pila y se comienza a trabajar.
Vale decir que podemos implementar pilas de dos formas una por arreglo y la
otra por lista enlazada.
Ahora bien, lo ideal es no implementar una pila por medio de un arreglo, pues
este modo de implementación trae aparejado muchos problemas en el uso de la
memoria, incluso si se tiene pensado ir modificando el tamaño de dicho arreglo
dinámicamente.
Lo óptimo es implementarla por medio de una lista de nodos enlazados por pun-
teros. Veamos la gráfica:
La idea es poder generar los nodos de manera dinámica a medida que se vayan
necesitando maximizando el uso de la memoria.

Esto implica trabajar con punteros, de tal manera que cada uno apunta al siguiente
nodo y obteniendo una lista enlazada.
Viendo la imagen podemos de arriba se aprecia que los datos no están colocados
contiguamente, esto es porque al generarse la memoria de manera dinámica,
por la utilización de los punteros, para guardar la dirección de memoria del nodo
siguiente.
Cabe mencionar como dato importante, que las pilas son un tipo especial de lista,
al igual que la cola.
Veamos un ejemplo de pila, codificado en Java usando la librería Stack.
Existen otras maneras de codificar pilas en Java, cuando no se

usa la librería stack. Les facilito un enlace, donde pueden ver
cómo se realiza, todo depende de cómo la quieran implementar
http://codigolibre.weebly.com/blog/pilas-en-java

Leer
LECTURA OBLIGATORIA Para profundizar este tema lea
la bibliografía obligatoria DEITEL, Harvey M y DEITEL, Paul
J., Cómo programar en Java, 9na edición, Prentice-Hall, ISBN:
978-970-26-1190-5, México, 2012.
Luego de haber repasado, llegó el momento de ejercitar.

Actividad 1: ¡A desarrollar! Caso 1
Actividad
Actividad
Actividad
Actividad

Colas
clase 3
tema 2 Comenzaremos con la estructura cola. Miremos para ello la siguiente fotografía:
Cuántas veces en la escuela habremos formado fila y la maestra nos insistía en

tomar distancia. Cuando pasábamos al aula pasaba desde el primero hasta el
último y el que llegaba tarde quedaba al final.
En informática, las colas emulan esa situación.
Estructura de datos, que se caracteriza por ser una secuencia

de elementos cuya inserción push se realiza por un extremo y
la extracción pop por el otro. Es decir FIFO (del inglés First In
Atención First Out).
Cómo podemos ver en la imagen:

Veamos otro ejemplo:
Como vimos en el tema anterior, existen librerías Java que nos permiten trabajar
con estructuras dinámicas lineales. En el caso de las colas contamos con la libre-
ría llamada QUEUE.
Con esta librería o interfaz podemos crear colas y gozar de métodos para el uso
de las mismas.
Como vemos, hay dos métodos para cada operación y pueden retornar dos valo-
res, null o una excepción.
Por ejemplo, en los métodos para Extraer “remove()” y “poll()” si se intenta

extraer un dato de una Cola que ya está vacía el método remove() lanzará una
excepción como resultado, en cambio el método poll() simplemente retornará o
tomará el valor null.

A continuación se muestra un ejemplo:
El método de offer() es preferible al método add () dado que internamente solo

llama al método offer () sin aportar otra funcionalidad.
Además, el método add () arroja la excepción “java.lang.IllegalStateException:

Queue full” cuando la cola está llena, mientras que el método offer () devuelve
un valor booleano FALSE para el mismo en caso.
Si profundizamos en la Interfaz Queue de JAVA podemos decir que es un subtipo

de la interfaz de java.util.Collection.
Veamos otro ejemplo:

Existen otras maneras de codificar pilas en Java, cuando no se
usa la librería queue. Les facilito un video, que podrán visuali-
zar desde plataforma, donde pueden ver cómo se realiza, todo
depende de cómo la quieran implementar:
https://www.youtube.com/watch?v=E3NUfYCz868

Estructuras De Datos En Java. Pearson Educación, 2013.
Leer
LECTURA OBLIGATORIA Para profundizar este tema lea
la bibliografía obligatoria DEITEL, Harvey M y DEITEL, Paul J.,
970-26-1190-5, México, 2012.
Luego de haber repasado, llegó el momento de ejercitar.
Actividad 5: Continuamos desarrollando
Desarrolle los programas solicitados, usando interfaces de utilida-

Actividad des o en forma “manual”
tema 2 - clase 3 - im08

clase 3 Listas
tema 3
Veamos la siguiente imagen
¿Qué podemos ver? ¿Qué hacen los niños? Creo que todos han respondido
niños tomados de la mano.
Si nosotros pasamos al terreno de la informática encontramos estructuras que
simulan esta situación, dichas estructuras son conocidas como listas.
Existen de distinto tipo:
● Lista Enlazada
○ Lista de Enlace Simple
○ Lista de Enlace Doble
○ Lista de Enlace Circular
Ahora vamos a hablar de cada una de ellas.
Lista de Enlace Simple

Cada nodo tiene un único campo de enlace. Una variable de
referencia contiene una referencia al primer nodo, cada nodo
(excepto el último) enlaza con el nodo siguiente, y el enlace del
Atención último nodo contiene null para indicar el final de la lista.
Características:
• El último nodo de la lista no apunta a ningún nodo (null).

• Se accede a la lista mediante el inicio de la lista.
• Se debe recorrer toda la lista para acceder a un nodo en particular.

Operaciones básicas:
● agregar (valor): agrega el valor al final de la lista.

● insertar (referencia, valor): inserta el valor después del valor de refe-
rencia en la lista.
● remover(referencia): elimina el nodo con el valor que coincida con la
referencia.
● editar (referencia): actualiza el valor de nodo con el valor que coincida
con la referencia.
● esVacia(): retorna true si la lista está vacía, false en caso contrario.
● buscar (valor): retorna la true si el elemento existe en la lista, false
caso contrario.
● eliminar(): elimina la lista
● listar(): imprime en pantalla los elementos de la lista.
A continuación se muestra el código, donde podemos ver una implementación

Java sobre el uso de listas enlazadas:
/**
* Clase que define los elementos que debe tener un Nodo de la lista.
*/
public class Nodo {
// Variable en la cual se va a guardar el valor.
private int valor;
// Variable para enlazar los nodos.
private Nodo siguiente;
/**
* Constructor que inicializamos el valor de las variables.
*/
public void Nodo(){
this.valor = 0;
this.siguiente = null;
}
// Métodos get y set para los atributos.
public int getValor() {

return valor;
}
public void setValor(int valor) {

this.valor = valor;
}
public Nodo getSiguiente() {

return siguiente;
}
public void setSiguiente(Nodo siguiente) {

this.siguiente = siguiente;

}
}
/**
* Clase que define las operaciones básicas que debe tener una lista simple.
*/
public class Lista {
// Puntero que indica el inicio de la lista o conocida tambien
// como cabeza de la lista.
private Nodo inicio;
// Variable para registrar el tamaño de la lista.
private int tamanio;
/**
* Constructor por defecto.
*/
public void Lista(){
inicio = null;
tamanio = 0;
}
/**
* Consulta si la lista esta vacia.
* @return true si el primer nodo (inicio), no apunta a otro nodo.
*/
public boolean esVacia(){
return inicio == null;
}
/**
* Consulta cuantos elementos (nodos) tiene la lista.
* @return numero entero entre [0,n] donde n es el numero de elementos
* que contenga la lista.
*/
public int getTamanio(){
return tamanio;
}
/**
* Agrega un nuevo nodo al final de la lista.
* @param valor a agregar.
*/
public void agregarAlFinal(int valor){
// Define un nuevo nodo.
Nodo nuevo = new Nodo();
// Agrega al valor al nodo.
nuevo.setValor(valor);
// Consulta si la lista esta vacia.
if (esVacia()) {
// Inicializa la lista agregando como inicio al nuevo nodo.
inicio = nuevo;
// Caso contrario recorre la lista hasta llegar al ultimo nodo
//y agrega el nuevo.
} else{

// Crea ua copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al ultimo nodo.
while(aux.getSiguiente() != null){
aux = aux.getSiguiente();
}
// Agrega el nuevo nodo al final de la lista.
aux.setSiguiente(nuevo);
}
// Incrementa el contador de tamaño de la lista
tamanio++;
}
/**
* Agrega un nuevo nodo al inicio de la lista.
* @param valor a agregar.
*/
public void agregarAlInicio(int valor){
// Consulta si la lista esta vacia.
if (esVacia()) {
// Inicializa la lista agregando como inicio al nuevo nodo.
inicio = nuevo;
// Caso contrario va agregando los nodos al inicio de la lista.
} else{
// Une el nuevo nodo con la lista existente.
nuevo.setSiguiente(inicio);
// Renombra al nuevo nodo como el inicio de la lista.
inicio = nuevo;
}
// Incrementa el contador de tamaño de la lista.
tamanio++;
}
/**
* Inserta un nuevo nodo despues de otro, ubicado por el valor que contiene.
* @param referencia valor del nodo anterios al nuevo nodo a insertar.
* @param valor del nodo a insertar.
*/
public void insertarPorReferencia(int referencia, int valor){
// Verifica si la lista contiene elementos
if (!esVacia()) {
// Consulta si el valor existe en la lista.
if (buscar(referencia)) {
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo de referencia.
while (aux.getValor() != referencia) {
}

// Crea un respaldo de la continuación de la lista.
Nodo siguiente = aux.getSiguiente();
// Enlaza el nuevo nodo despues del nodo de referencia.
// Une la continuacion de la lista al nuevo nodo.
nuevo.setSiguiente(siguiente);

tamanio++;
}
}
}
/**
* Inserta un nuevo nodo despues en una posición determinada.
* @param posicion en la cual se va a insertar el nuevo nodo.
* @param valor valor del nuevo nodo de la lista.
*/
public void insrtarPorPosicion(int posicion, int valor){
// Verifica si la posición ingresada se encuentre en el rango
// >= 0 y <= que el numero de elementos del la lista.
if(posicion>=0 && posicion<=tamanio){
// Consulta si el nuevo nodo a ingresar va al inicio de la lista.
if(posicion == 0){
// Inserta el nuevo nodo al inicio de la lista.
nuevo.setSiguiente(inicio);
inicio = nuevo;
}
else{
// Si el nodo a inserta va al final de la lista.
if(posicion == tamanio){
Nodo aux = inicio;
// Recorre la lista hasta llegar al ultimo nodo.
}
// Inserta el nuevo nodo despues de del ultimo.
}
else{
// Si el nodo a insertar va en el medio de la lista.
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo anterior
// a la posicion en la cual se insertara el nuevo nodo.
for (int i = 0; i < (posicion-1); i++) {
}
// Guarda el nodo siguiente al nodo en la posición
// en la cual va a insertar el nevo nodo.
// Inserta el nuevo nodo en la posición indicada.
// Une el nuevo nodo con el resto de la lista.
nuevo.setSiguiente(siguiente);

}
}
tamanio++;
}
}
/**
* Obtiene el valor de un nodo en una determinada posición.
* @param posicion del nodo que se desea obtener su valor.
* @return un numero entero entre [0,n-1] n = numero de nodos de la lista.
* @throws Exception
*/
public int getValor(int posicion) throws Exception{
// >= 0 y < que el numero de elementos del la lista.
if(posicion>=0 && posicion<tamanio){
// Consulta si la posicion es el inicio de la lista.
if (posicion == 0) {
// Retorna el valor del inicio de la lista.
return inicio.getValor();
}else{
// Crea una copia de la lista.
Nodo aux = inicio;
// Recorre la lista hasta la posición ingresada.
for (int i = 0; i < posicion; i++) {
}
// Retorna el valor del nodo.
return aux.getValor();
}
// Crea una excepción de Posicion inexistente en la lista.
} else {
throw new Exception(“Posicion inexistente en la lista.”);
}
}
/**
* Busca si existe un valor en la lista.
* @param referencia valor a buscar.
* @return true si existe el valor en la lista.
*/
public boolean buscar(int referencia){
Nodo aux = inicio;
// Bandera para indicar si el valor existe.
boolean encontrado = false;
// Recorre la lista hasta encontrar el elemento o hasta
// llegar al final de la lista.
while(aux != null && encontrado != true){
// Consulta si el valor del nodo es igual al de referencia.
if (referencia == aux.getValor()){
// Canbia el valor de la bandera.
encontrado = true;
}
else{
// Avansa al siguiente. nodo.

}
}
// Retorna el resultado de la bandera.
return encontrado;
}
/**
* Consulta la posición de un elemento en la lista
* @param referencia valor del nodo el cual se desea saber la posición.
* @return un valor entero entre [0,n] que indica la posición del nodo.
* @throws Exception
*/
public int getPosicion(int referencia) throws Exception{
Nodo aux = inicio;
// COntado para almacenar la posición del nodo.
int cont = 0;
// Recoore la lista hasta llegar al nodo de referencia.
while(referencia != aux.getValor()){
// Incrementa el contador.
cont ++;
// Avansa al siguiente. nodo.
}
// Retorna el valor del contador.
return cont;
// Crea una excepción de Valor inexistente en la lista.
} else {
throw new Exception(“Valor inexistente en la lista.”);
}
}
/**
* Actualiza el valor de un nodo que se encuentre en la lista ubicado
* por un valor de referencia.
* @param referencia valor del nodo el cual se desea actualizar.
* @param valor nuevo valor para el nodo.
*/
public void editarPorReferencia(int referencia, int valor){
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo de referencia.
while(aux.getValor() != referencia){
}
// Actualizamos el valor del nodo
aux.setValor(valor);
}
}
/**
* Actualiza el valor de un nodo que se encuentre en la lista ubicado
* por su posición.
* @param posicion en la cual se encuentra el nodo a actualizar.
* @param valor nuevo valor para el nodo.

*/
public void editarPorPosicion(int posicion , int valor){
// Consulta si el nodo a eliminar es el primero.
if(posicion == 0){
// Alctualiza el valor delprimer nodo.
inicio.setValor(valor);
}
else{
// En caso que el nodo a eliminar este por el medio
// o sea el ultimo
Nodo aux = inicio;
// Recorre la lista hasta lleger al nodo anterior al eliminar.
for (int i = 0; i < posicion; i++) {
}
// Alctualiza el valor del nodo.
aux.setValor(valor);
}
}
}
/**
* Elimina un nodo que se encuentre en la lista ubicado
* por un valor de referencia.
* @param referencia valor del nodo que se desea eliminar.
*/
public void removerPorReferencia(int referencia){
// Consulta si el valor de referencia existe en la lista.
// Consulta si el nodo a eliminar es el pirmero
if (inicio.getValor() == referencia) {
// El primer nodo apunta al siguiente.
inicio = inicio.getSiguiente();
} else{
Nodo aux = inicio;
// Recorre la lista hasta llegar al nodo anterior
// al de referencia.
while(aux.getSiguiente().getValor() != referencia){
}
// Guarda el nodo siguiente del nodo a eliminar.
Nodo siguiente = aux.getSiguiente().getSiguiente();
// Enlaza el nodo anterior al de eliminar con el
// sguiente despues de el.
aux.setSiguiente(siguiente);
}
// Disminuye el contador de tamaño de la lista.
tamanio--;
}
}
/**
* Elimina un nodo que se encuentre en la lista ubicado
* por su posición.

* @param posicion en la cual se encuentra el nodo a eliminar.
*/
public void removerPorPosicion(int posicion){
// Consulta si el nodo a eliminar es el primero
if(posicion == 0){
// Elimina el primer nodo apuntando al siguinte.
inicio = inicio.getSiguiente();
}
// En caso que el nodo a eliminar este por el medio
// o sea el ultimo
else{
Nodo aux = inicio;
// Recorre la lista hasta lleger al nodo anterior al eliminar.
for (int i = 0; i < posicion-1; i++) {
}
// Guarda el nodo siguiente al nodo a eliminar.
// Elimina la referencia del nodo apuntando al nodo siguiente.
aux.setSiguiente(siguiente.getSiguiente());
}
// Disminuye el contador de tamaño de la lista.
tamanio--;
}
}
/**
* Elimina la lista
*/
public void eliminar(){
// Elimina el valor y la referencia a los demas nodos.
inicio = null;
// Reinicia el contador de tamaño de la lista a 0.
tamanio = 0;
}
/**
* Mustra en pantalla los elementos de la lista.
*/
public void listar(){
// Verifica si la lista contiene elementoa.
if (!esVacia()) {
Nodo aux = inicio;
// Posicion de los elementos de la lista.
int i = 0;
// Recorre la lista hasta el final.
while(aux != null){
// Imprime en pantalla el valor del nodo.
System.out.print(i + “.[ “ + aux.getValor() + “ ]” + “ -> “);
// Avanza al siguiente nodo.
// Incrementa el contador de la posión.
i++;

}
}
}
}
public class Main {

/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Lista lista = new Lista();
System.out.println(“<<-- Ejemplo de lista simple -->>\n”);
// Agregar al final de la lista

lista.agregarAlFinal(12);
// Agregar in inicio de la lista
lista.agregarAlInicio(41);
lista.agregarAlInicio(6);
System.out.println(“<<-- Lista -->>”);

lista.listar();
System.out.println(“\n\n<<-- Tamaño -->”);

System.out.println(lista.getTamanio());
System.out.println(“\n<<-- Obtener el valor del nodo en la posicion 3

-->>”);
System.out.println(lista.getValor(3));
System.out.println(“\nInsrta un nodo con valor 16 despues del 15”);

lista.insertarPorReferencia(15, 16);
lista.listar();
System.out.print(“ | Tamaño: “);
System.out.println(“\n\nInsrta un nodo con valor 44 en la posición 3”);

lista.insrtarPorPosicion(3, 44);
lista.listar();
System.out.println(“\nActualiza el valor 12 del tercer nodo por 13”);

lista.editarPorReferencia(12, 13);
lista.listar();

System.out.println(“\nActualiza el valor nodo en la posición 0 por
17”);
lista.editarPorPosicion(0, 17);
lista.listar();
System.out.println(“\nElimina el nodo con el valor 41”);

lista.removerPorReferencia(41);
lista.listar();
System.out.println(“\nElimina el nodo en la posición 4”);

lista.removerPorPosicion(4);
lista.listar();
System.out.println(“\nConsulta si existe el valor 30”);

System.out.println(lista.buscar(30));
System.out.println(“\nConsulta la posicion del valor 9”);

System.out.println(lista.getPosicion(9));
System.out.println(“\nElimina la lista”);
lista.eliminar();
System.out.println(“\nConsulta si la lista está vacia”);

System.out.println(lista.esVacia());
System.out.println(“\n\n<<-- Fin de ejemplo lista simple -->>”);

}
}
Bueno me imagino, que ya estamos listos para un paso más, lo importante es

tener en cuenta que las listas son como cadenas con eslabones que vamos, en
donde las operaciones son las mismas que haríamos con una cadena, nada más
que con código y en este caso en particular en Java.
Listas Doblemente Enlazadas
En este tipo de lista enlazada cada nodo tiene dos enlaces: uno apunta al nodo
anterior, o apunta al valor NULL o a la lista vacía si es el primer nodo; y otro que
apunta al siguiente nodo siguiente, o apunta al valor NULL o a la lista vacía si es
el último nodo.

En Java lo podríamos programar así:
CLASE NODO
Para poder realizar acciones sobre la lista doblemente enlazada utilizaremos la

clase Lista en la cual estarán todas las funciones sobre la lista doblemente enla-
zada como. insertar, eliminar, mostrar, etc.

A partir de estas clases podremos realizar cualquier programa, por ejemplo uno
que permite insertar ordenadamente N números por teclado en una lista doble-
mente enlazada y posteriormente visualiza en forma invertida
Falta poco, ya llegamos a las listas circulares.
Listas Circulares
Una lista circular es una lista lineal en la que el último nodo apunta al primero (no
existe null).
Para poder implementarla, se utiliza la misma lógica ya vista, creamos la clase

NODO, luego la clase LISTA con todas las funciones necesarias para poder traba-
jar con la lista y a posteriori podemos desarrollar cualquier programa que requiera
una lista circular como estructura.

Bueno, hemos terminado con esta estructura, llegó el momento de ejercitar. En
el tema 4, va a encontrar una serie de ejercicios interesantes que te enseñarán a
codificar las estructuras vistas a lo largo de la clase 3.

Para reforzar los invito a ver desde la plataforma estos videos:
● PILAS →
https://www.youtube.com/watch?v=1IxIZ9qXEgw
● LISTAS →
https://www.youtube.com/watch?v=MlzW9Jp9hkk&list=PLPO
v7bTzpLUuiyROxEKLiOYqmCjo_VHQv&index=12
● COLAS →
https://www.youtube.com/watch?v=pefbUlZC2BA&index=13&
list=PLPOv7bTzpLUuiyROxEKLiOYqmCjo_VHQv

Leer 970-26-1190-5, México, 2012.
clase 3
tema 4
EJERCITAMOS
Veamos la siguiente imagen
¿Qué podemos ver? Esta persona ejercita, si lo sigue haciendo va a mejorar su

estado físico y su salud en general. Como queremos hacer lo mismo con nuestro
conocimiento en Java, les dejo una serie de ejercicios sobre, pilas, listas y colas.
Actividad 6: Actividad con Listas

1) Un cine de un pueblo pequeño nos propone hacer una apli-
cación para controlar las personas de una cola de un cine en los
Actividad grandes estrenos de películas.
Un conjunto de personas esperaran la cola para sacar una entrada,
tendremos que calcular la entrada según la edad de la persona
(mínimo 5 años).
La edad de las personas se genera aleatoriamente entre 5 y 60
años. Les recomiendo realizar un método en el main para generar
Personas en la cola.
Al final, deberemos mostrar la cantidad total recaudada. El número
de personas de la cola se elige al azar entre 0 y 50.
Recuerda que al final la lista debe quedar vacía, una vez que una
persona paga su entrada ya no está en la cola.
Los precios son:

● Entre 5 y 10 años → $100
● Entre 11 y 17 años → $150
● Mayor de 18 → $200

2) Realiza el ejercicio anterior pero el lugar de usar una lista enlazada, usar la
clase ArrayList. Usa un iterador para recorrer el ArrayList. Usa la misma clase
Persona del ejercicio anterior.
3) Un supermercado nos pide que hagamos una pequeña aplicación que alma-
cene los productos pasados por el escaner.
La aplicación debe almacenar Productos (clase), cada producto al crearse con-
tiene una cantidad, un precio (estos dos generados aleatoriamente). El nombre
del producto será básico (producto1, producto2, producto3, etc.).
El precio ya viene con los impuestos incluidos.
Calcular el precio total de una lista de entre 1 y 8 productos (aleatorio). Mostrar un
ticket con todo lo vendido y el precio final como se hacen en los supermercados.
Más o menos con este formato, lo importante son los datos, no el estilo:
Cantidad Precio Total
Producto1 5 3.5 17.5
Precio final 35
Actividad 7: Actividad con Mezclas
1. Realiza una pila utilizando una lista enlazada como estruc-

Actividad tura de datos. La pila debe permitir:
a. - Insertar un objeto en la pila (push).
b. - Recuperar un objeto de la pila (pop).
c. - Obtener el objeto de la cima (top) de la pila, sin
extraerlo.
d. -Averiguar si hay algún objeto almacenado en la
pila.
e. - Devolver el número de objetos almacenados en
la pila.
2. Realiza una cola utilizando una lista enlazada como
estructura de datos. La cola debe permitir:
a. - Insertar un objeto en la cola (enqueue).
b. - Recuperar un objeto de la cola (dequeue).
c. - Obtener el primer objeto (first) de la cola, sin
extraerlo.
d. - Averiguar si hay algún objeto almacenado en la
cola (isEmpty).
e. - Devolver el número de objetos almacenados en
la cola (size).

clase 3 Actividad 1: ¡A desarrollar! Caso 1
Solución
Solución:

Solución:

Solución:
Actividad 5: Continuamos desarrollando

Desarrolle los programas solicitados, usando interfaces de utilidades o en forma
“manual”

Solución
Solución

Actividad 6: Actividad con Listas
1) Un cine de un pueblo pequeño nos propone hacer una aplicación para contro-
lar las personas de una cola de un cine en los grandes estrenos de películas.
Un conjunto de personas esperaran la cola para sacar una entrada, tendremos
que calcular la entrada según la edad de la persona (minimo 5 años).
La edad de las personas se generan aleatoriamente entre 5 y 60 años. Les
recomiendo realizar un método en el main para generar Personas en la cola.
Al final, deberemos mostrar la cantidad total recaudada. El número de personas
de la cola se elige al azar entre 0 y 50.
Recuerda que al final la lista debe quedar vacía, una vez que una persona paga
su entrada ya no está en la cola.
Los precios son:
● Entre 5 y 10 años → $100
● Entre 11 y 17 años → $150
● Mayor de 18 → $200
Solución
package ejercicio_listaenlazada_1;
public class Persona {
private int edad;
/**
* Constructor por defecto
* @param edad
*/
public Persona(int edad){
this.edad=edad;
}
/**
* Devuelve la edad
* @return Edad acutal
*/
public int getEdad() {
return edad;
}
/**
* Modifica la edad
* @param edad Valor edad

*/
public void setEdad(int edad) {
this.edad = edad;
}
/**
*
* @param <T>
*/
public class Nodo<T> {
private T dato;
private Nodo<T> siguiente;
/**
*/
public Nodo(){
siguiente=null;
}
/**
* Le pasamos un dato al nodo
* @param p
*/
public Nodo(T p){
siguiente=null;
dato = p;
}
/**
* Le pasamos un dato y su siguiente nodo al nodo
* @param t Dato a insertar
* @param siguiente Su sisguiente nodo
*/
public Nodo(T t, Nodo<T> siguiente){
this.siguiente=siguiente;
dato = t;
}
public T getDato() {
return dato;
}
public void setDato(T dato) {

this.dato = dato;
}
public Nodo<T> getSiguiente() {

return siguiente;
}

public void setSiguiente(Nodo<T> siguiente) {
}
public class CineApp {
//Creamos la cola, al crearla ya creamos el numero de personas

ListaEnlazada<Persona> cola = new ListaEnlazada<>();
//Generamos la cola
generarCola(cola);
//Creamos variables que nos seran útiles

double recaudacion;
double recaudacionTotal=0;
Persona espectadorActual;
int edadActual;
//Recorremos la cola
while(!cola.estaVacia()){
//”Atendemos” al espectador para que pague

espectadorActual=cola.devolverPrimero();
edadActual=espectadorActual.getEdad();
//Comprobamosla edad
if(edadActual>=5 && edadActual<=10){
recaudacion=1;
}else if(edadActual>=11 && edadActual<=17){
recaudacion=2.5;
}else{
recaudacion=3.5;
}
recaudacionTotal+=recaudacion;
System.out.println(“Una persona de “+edadActual+” años se le ha

cobrado “ +recaudacion+ “ euros”);
//Quitamos al espectador de la cola

//Tambien hemos podido usar al principio el meotodo devolverYBo-
rrarPrimero();
cola.quitarPrimero();
//Mostramos el resultado
System.out.println(“La recaudación es de “+recaudacionTotal+”
euros”);

}
/**
* Genera una cola de personas
* @param cola
*/
public static void generarCola(ListaEnlazada<Persona> cola){
int numeroPersonas=generaNumeroAleatorio(1,50);
for(int i=0;i<numeroPersonas;i++){
cola.insertarUltimo(new Persona(generaNumeroAleatorio(5, 60)));
}
/**
* Genera un numero aleatorio entre dos numeros.
* Entre el minimo y el maximo incluidos
* @param minimo Número mínimo
* @param maximo Número máximo
* @return Número entre minimo y maximo
*/
public static int generaNumeroAleatorio(int minimo, int maximo){
int num=(int)Math.floor(Math.random()*(minimo-
(maximo+1))+(maximo+1));
return num;
}

ListaEnlazada<Persona> cola = new ListaEnlazada<>();
//Generamos la cola
generarCola(cola);

double recaudacion;
int edadActual;
while(!cola.estaVacia()){

espectadorActual=cola.devolverPrimero();

recaudacion=1;
recaudacion=2.5;
}else{
recaudacion=3.5;
}

//Quitamos al espectador de la cola

//Tambien hemos podido usar al principio el meotodo devolverYBo-
rrarPrimero();
cola.quitarPrimero();
euros”);
/**
* Genera una cola de personas
* @param cola
*/
public static void generarCola(ListaEnlazada<Persona> cola){
cola.insertarUltimo(new Persona(generaNumeroAleatorio(5, 60)));
}
/**
*/
return num;
}

}
2) Realiza el ejercicio anterior pero el lugar de usar una lista enlazada, usar la
clase ArrayList. Usa un iterador para recorrer el ArrayList. Usa la misma clase
Persona del ejercicio anterior.
Solución
public class Persona {
private int edad;
/**
* @param edad
*/
public Persona(int edad){
this.edad=edad;
}
/**
* Devuelve la edad
* @return Edad acutal
*/
public int getEdad() {
return edad;
}
/**
* Modifica la edad
* @param edad Valor edad
*/
public void setEdad(int edad) {
this.edad = edad;
}
import java.util.ArrayList;
import java.util.Iterator;

ArrayList<Persona> cola = new ArrayList<>();
generarCola(cola);

double recaudacion;

int edadActual;
//Creamos el iterator
Iterator<Persona> it=cola.iterator();
while(it.hasNext()){
espectadorActual=it.next();

recaudacion=1;
recaudacion=2.5;
}else{
recaudacion=3.5;
}

euros”);
public static void generarCola(ArrayList<Persona> cola){
cola.add(new Persona(generaNumeroAleatorio(5, 60)));
}
}
/**
*/

return num;
}
3) Un supermercado nos pide que hagamos una pequeña aplicación que alma-
cene los productos pasados por el escaner.
La aplicación debe almacenar Productos (clase), cada producto al crearse con-
tiene una cantidad, un precio (estos dos generados aleatoriamente). El nombre
del producto será básico (producto1, producto2, producto3, etc.).
El precio ya viene con los impuestos incluidos.
Calcular el precio total de una lista de entre 1 y 8 productos (aleatorio). Mostrar
un ticket con todo lo vendido y el precio final como se hacen en los supermerca-
dos. Más o menos con este formato, lo importante son los datos, no el estilo:
Cantidad Precio Total
Precio final 35
Solución
/**
* @param <T>
*/
private T dato;
/**
*/
public Nodo(){
siguiente=null;
}
/**
* @param p
*/
public Nodo(T p){
siguiente=null;
dato = p;
}
/**
*/

dato = t;
}
return dato;
}

this.dato = dato;
}

return siguiente;
}

}
}
/**
* @param <T>
*/
private T dato;
/**
*/
public Nodo(){
siguiente=null;
}
/**
* @param p
*/
public Nodo(T p){
siguiente=null;
dato = p;
}
/**
*/
dato = t;
}

return dato;
}

this.dato = dato;
}

return siguiente;
}

}
}
/**
* @param <T>
* Lista enlazada simple
*/
public class ListaEnlazada<T>{
//Atributos
private Nodo<T> primero;
/**
*/
public ListaEnlazada(){
listaVacia();
}
/**
* Vacia la lista
*/
private void listaVacia(){
primero = null;
}
/**
* Indica si la lista esta vacia o no
* @return True = esta vacia
*/
public boolean estaVacia(){
return primero == null;
}
/**
* Inserta un objeto al principio de la lista
* @param t Dato insertado
*/
public void insertarPrimero(T t){
Nodo<T> nuevo = new Nodo<>(t);

if (!estaVacia()){
//Sino esta vacia, el primero actual pasa a ser
// el siguiente de nuestro nuevo nodo
nuevo.setSiguiente(primero);
}
//el primero apunta al nodo nuevo

primero=nuevo;
/**
* Inserta al final de la lista un objeto
* @param t Dato insertado
*/
public void insertarUltimo(T t){
Nodo<T> aux = new Nodo<>(t);

Nodo<T> rec_aux;
if (estaVacia()) {
insertarPrimero(t);
}else {
rec_aux = primero;
//Buscamos el ultimo nodo

while(rec_aux.getSiguiente() != null){
rec_aux=rec_aux.getSiguiente();
}
//Actualizamos el siguiente del ultimo

rec_aux.setSiguiente(aux);
}
}
/**
* Quita el primer elemento de la lista
*/
public void quitarPrimero(){
Nodo<T> aux;
if (!estaVacia()){
aux=primero;
primero = primero.getSiguiente();
aux=null; //Lo marcamos para el recolector de basura
}
}
/**
* Quita el ultimo elemento de la lista
*/
public void quitarUltimo(){
Nodo<T> aux=primero;
if(aux.getSiguiente()==null)
//Aqi entra, si la lista tiene un elemento
listaVacia();

if(!estaVacia()) {
aux=primero;
//Buscamos el penultimo, por eso hay dos getSiguiente()

while(aux.getSiguiente().getSiguiente() != null){
aux=aux.getSiguiente();
}
//Marcamos el siguiente del antepenultimo como nulo, eliminando el

ultimo
aux.setSiguiente(null);
}
/**
* Devuelve el último elemento de la lista
* @return Último elemento
*/
public T devolverUltimo(){
T elemen = null;
Nodo<T> aux;
if (!estaVacia()){
aux = primero;
//Recorremos
}
elemen = aux.getDato();
}
return elemen;
}
/**
* Devuelve el primer elemento de la lista
* @return Primer elemento, null si esta vacia
*/
public T devolverPrimero(){
T elemen = null;
if (!estaVacia()){
elemen = primero.getDato();
}
return elemen;
}
/**
* Devuelve el número de elementos de la lista
* @return Número de elementos
*/
public int cuantosElementos(){
Nodo<T> aux;
int numElementos=0;
aux = primero;
//Recorremos

while(aux != null){
numElementos++;
}
return numElementos;
/**
* Devuelve el dato del nodo en la posicion pos
* @param pos
* @return dato del nodo en la posicion indicada
*/
public T devolverDato(int pos){
int cont=0;
T dato=null;
if(pos<0 || pos>=cuantosElementos()){
System.out.println(“La posicion insertada no es correcta”);
}else{
//recorremos
while(aux!=null){
if (pos == cont){
//Cogemos el dato
dato=aux.getDato();
}
cont++;
}
}
return dato;
/**
* Devuelve el nodo de la posicion indicada
* @param pos
* @return Nodo de la posicion indicada
*/
public Nodo<T> devolverNodo(int pos){
int cont=0;
}else{
//recorremos
while(aux!=null){
if (pos == cont){
//Devuelvo aux, con esto salimos de la función
return aux;
}

//Actualizo el siguiente
cont++;
}
}
return aux;
/**
* Inserta un nuevo nodo en la posicion indicada con el su dato
* @param pos
* @param dato
*/
public void introducirDato(int pos, T dato){
Nodo<T> auxDato=null; //Debemos crear un nodo para insetar el dato
Nodo<T> anterior=primero; //Debemos crear un nodo para insetar el
dato
int contador=0;
if(pos<0 || pos>cuantosElementos()){
}else{
if(pos==0){
insertarPrimero(dato);
}else if(pos==cuantosElementos()){
insertarUltimo(dato);
}else{
//Recorremos
while(aux!=null){
if (pos == contador){
//Creo el nodo
auxDato=new Nodo<>(dato, aux);
//El siguiente del anterior a aux es auxDato
anterior.setSiguiente(auxDato);
}
//Actualizo anterior
anterior=aux;
contador++;
aux=aux.getSiguiente(); //Actualizo siguiente
}
}
}
/**

* Modifica el dato indicado en el nodo de la posicion indicada
* @param pos
* @param dato
*/
public void modificarDato(int pos, T dato){
int cont=0;
}else{
//Recorremos
while(aux!=null){
if (pos == cont){
//Modificamos el dato directamente
aux.setDato(dato);
}
cont++;
aux=aux.getSiguiente(); //Actualizamos
}
}
/**
* Borra un elemento de la lista
* @param pos Posición de la lista que queremos borrar
*/
public void borraPosicion(int pos){
Nodo<T> anterior=null;
int contador=0;
}else{
while(aux!=null){
if (pos == contador){
if (anterior==null){
primero = primero.getSiguiente();
}else {
//Actualizamos el anterior
anterior.setSiguiente(aux.getSiguiente());
}
aux=null;
}else{
anterior=aux;
contador++;
}
}
}
}
/**

* Devuelve el primer el elemento y lo borra de la lista
* @return Primer elemento
*/
public T devolverYBorrarPrimero(){
T dato=devolverPrimero();
quitarPrimero();
return dato;
}
/**
* Indica la posición del primer dato que se encuentre
* @param t dato buscado
* @return Posición del dato buscado, -1 si no se encuentra o esta vacia
*/
public int indexOf (T t){
if (estaVacia()){
return -1;
}else{
int contador=0;
boolean encontrado=false;
//recorremos, cuando encontrado=true, sale del bucle

while(aux!=null && !encontrado){
if(t.equals(aux.getDato())){
//Cambiamos a true
encontrado=true;
}else{
contador++;
//actualizamos
}
}
if(encontrado){
return contador;
}else{
//no se ha encontrado
return -1;
}
}
}
/**
* Indica la posición del primer dato desde la posicion indicada
* @param t dato buscado
* @param pos
* @return Posición del dato buscado, -1 si no se encuentra o esta vacia
*/
public int indexOf (T t, int pos){
Nodo<T> aux;
if (estaVacia()){
return -1;
}else{

int contador=pos;
boolean encontrado=false;
//Empezamos desde el nodo correspondiente

aux=devolverNodo(pos);
//recorremos, cuando encontrado=true, sale del bucle

while(aux!=null && !encontrado){
if(t.equals(aux.getDato())){
//Cambiamos a true
encontrado=true;
}else{
contador++;
//Actualizamos
}
}
if(encontrado){
return contador;
}else{
return -1;
}
}
}
/**
* Indica si un dato existe en la lista
* @param t Dato a comprobar
* @return Si el dato existe, devuelve true
*/
public boolean datoExistente(T t){
boolean existe=false;
while(aux!=null && !existe){
if(aux.getDato().equals(t)){
existe=true;
}
//Actualizamos
}
return existe;
}
/**
* Muestra el contenido de la lista
*/
public void mostrar(){
System.out.println(“Contenido de la lista”);
System.out.println(“---------------------”);

while(aux!=null){
System.out.println(aux.getDato());//mostramos el dato
}
/**
* Devuelve el contenido de la lista en un String
* @return contenido de la lista
*/
@Override
public String toString(){
String contenido=””;
while(aux!=null){
contenido=aux.getDato()+”\n”; //guardamos el dato
}
return contenido;
}
}
/**
public class SupermercadoApp {
//Creamos la lista de productos

ListaEnlazada<Producto> productos=new ListaEnlazada<>();
//Generamos los productos

generarProductos(productos);
//Declaramos variables que necesitaremos

String ticket=”************Cantidad***Precio***Total\n”;
double precioTotal=0;
Producto productoActual;
//Recorremos la lista
for(int i=0;!productos.estaVacia();i++){
productoActual=productos.devolverYBorrarPrimero();
precioTotal+=productoActual.precioFinal();
ticket+=”Producto”+(i+1)+”\t”+productoActual.getCantidad()+
“\t”+productoActual.getPrecio()+
“\t”+productoActual.precioFinal()+”\n”;

ticket+=”Precio final\t\t\t”+precioTotal;
System.out.println(ticket);
/**
* Genera productos que se almacenan en la lista
* @param lista
*/
public static void generarProductos(ListaEnlazada<Producto> lista){
int cantidad;
double precio;
cantidad=generaNumeroAleatorio(1,10);;
precio=generaNumeroRealAleatorio(0.05, 50);
lista.insertarUltimo(new Producto(cantidad, precio));
}
/**
*/
return num;
}
/**
* Genera un numero aleatorio entre dos numeros reales.
* Devuelve un numero con dos decimales.
*/
public static double generaNumeroRealAleatorio(double minimo, double
maximo){
double num=Math.rint(Math.floor(Math.random()*(minimo-((maximo*10
0)+1))+((maximo*100)+1)))/100;
return num;

}
Actividad 7: Actividad con Mezclas
1. Realiza una pila utilizando una lista enlazada como estructura de datos.
La pila debe permitir:
a. - Insertar un objeto en la pila (push).
b. - Recuperar un objeto de la pila (pop).
c. - Obtener el objeto de la cima (top) de la pila, sin extraerlo.
d. -Averiguar si hay algún objeto almacenado en la pila.
e. - Devolver el número de objetos almacenados en la pila.
Soluciòn
/*
* LinkedStack.java
*
*/
public class LinkedStack {
class Node {
Object elem;
Node Next;
public Node(Object o) {
elem = o;
Next = null;
}
}
Node end;
int size;
public LinkedStack() {
end = null;
size = 0;
}
public void push(Object o) {

Node new_node = new Node(o);
if (end == null)
end = new_node;
else {
new_node.Next = end;
end = new_node;
}
size++;
}; // inserts an object onto the stack
public Object pop() {

if (end == null)
return null;
;
Object o = end.elem;
end = end.Next;

size--;
return o;
}// Gets the object from the stack
public boolean isEmpty() {
return (size == 0);

}
public int size() {
return size;
}
public Object end() {
if (end == null)
return null;
else
return end.elem;
}
} // class LinkedStack
2. Realiza una cola utilizando una lista enlazada como estructura de datos.
La cola debe permitir:
a. - Insertar un objeto en la cola (enqueue).
b. - Recuperar un objeto de la cola (dequeue).
c. - Obtener el primer objeto (first) de la cola, sin extraerlo.
d. - Averiguar si hay algún objeto almacenado en la cola (isEmpty).
e. - Devolver el número de objetos almacenados en la cola (size).
Soluciòn
/*
* LinkedQueue.java
*
*/
public class LinkedQueue {
class Node {
Object elem;
Node Next;
public Node(Object o) {
elem = o;
Next = null;
}
}
Node first;
Node end;
int size;
public LinkedQueue() {

end = null;
size = 0;
}
public void enqueue(Object o) {

Node new_node = new Node(o);
if (first == null) {
first = new_node;
end = new_node;
} else {
end.Next = new_node;
end = new_node;
}
size++;
}; // inserts an object onto the queue
public Object dequeue() {

if (first == null)
return null;
;
Object o = first.elem;
first = first.Next;
size--;
return o;
} // gets the object from the queue
public boolean isEmpty() {

return (size == 0);
}
public int size() {

return size;
}
public Object first() {

if (first == null)
return null;
else
return first.elem;
}
} // class LinkedQueue
clase 3 Habiendo trabajado con las estructuras de datos dinámica lineales, ya estamos
conclusiones listos para afrontar, estructuras no lineales.
La idea es que nuestros desarrollos sean eficientes y que a la hora de desarrollar

podamos contemplar el funcionamiento general del equipo, por lo cual si nosotros
administramos bien el uso de la memoria para trabajar con datos, mejor y más
performante va a ser nuestro desarrollo.
Nos vemos en la próxima clase.

ESTRUCTURAS DE DATOS DINÁMICAS NO LINEALES
clase 4
introducción Hasta el momento hemos estudiados estructuras de datos lineales, es decir que
su crecimiento o decrecimiento, se hace en línea. Tanto un array, como una lista,
pila o cola puede verse como una línea en donde agregamos o sacamos elemen-
tos sin perjuicio de dicha linealidad.
En esta clase aprenderemos que existen estructuras que su crecimiento o decre-

cimiento pueden afectar a la estructura, desequilibrando o equilibrando la misma.
Me imagino que estará intrigado, entonces le pido me acompañe.
clase 4 Árboles
tema 1
Miremos la imagen
¿Qué podemos ver? Sí, no se equivoca, es un árbol. Ahora le pido que se detenga
en el árbol, el mismo tiene raíz, ramas, si se le dan los cuidados habituales crece
de una manera armoniosa, es decir no hay una rama que crezca más que otra
todos los niveles van adquiriendo mayor tamaño, de una manera proporcional.
Resulta que en informática, existe una estructura de datos que tiene el mismo
comportamiento. Por esa causa se denomina árbol. Es una estructura de datos
dinámica y no lineal.
Gráficamente lo podemos ver así:

Un árbol es un conjunto de nodos o vértices y un conjunto de
aristas o arcos que satisface que a cada nodo hijo le llega una
arista de otro nodo padre. Se establece la relación padre-hijo: p
es padre de h, h es un hijo de p.
El nodo donde comienza la jerarquía se llama raíz y no es hijo
Atención
de ningún nodo padre. Existe un camino único entre la raíz y
cualquiera de los nodos del árbol.
Tipos de Nodos
● Raíz que no tiene padres.

● Hoja que no tienen hijos
● Internos, cuando tiene descendientes. También se los denomina rama.
Topología de Nodos
Todos los árboles tienen cierta manera de crecer y ello define un camino, profun-
didad y altura de los mismos. Veamos de qué se trata esto:
El camino existente entre dos nodos, es la secuencia de “arcos”

que nos llevan, siguiéndoles de forma consecutiva del primero
al segundo. La longitud es el número de aristas que contiene.
Atención

- Profundidad de un nodo es la longitud del camino de la raíz a ese nodo.

- Altura de un árbol es la profundidad máxima entre todos los nodos extremos
del árbol. Es decir, “la profundidad del nodo más profundo”.
Nosotros veremos el caso de los árboles binarios.
Un árbol binario es un árbol en el que cada nodo tiene 0 ó 2

hijos (el hijo izquierdo y el derecho).
Atención
Veamos algunos ejemplos gráficos para tener una idea conceptual de lo que esta-
mos hablando.

Tipos de Árboles
● Árboles Binarios: Un árbol binario es un conjunto finito de elementos, el

cual puede estar vacío o dividido en tres subconjuntos: raíz del árbol,
subárbol izquierdo y subárbol derecho
● Árbol de búsqueda binario auto-balanceable: Es aquél que intenta man-

tener su altura, tan pequeños como sea posible en todo momento y en
forma automática.
● Árboles AVL: están siempre equilibrados de tal modo que para todos los
nodos, la altura de la rama izquierda no difiere en más de una unidad de
la altura de la rama derecha o viceversa.

● Árboles Rojo-Negro: Es un árbol binario de búsqueda en el que cada
nodo tiene un atributo de color cuyo valor es rojo o negro.
● Árboles AA: se utiliza para almacenar y recuperar información ordenada

de manera eficiente
● Árbol de segmento: estructura de datos en forma de árbol para guardar
intervalos o segmentos
● Árboles Multicamino: es un árbol ordenado y sus nodos deben tener un
número conocido de hijos.
● Árboles B: Es un árbol de búsqueda que puede estar vacío o pueden
tener varios hijos, existiendo una relación de orden entre ellos.
Recorridos de Árboles
Preorden:
1. Visitar la Raíz
2. Recorrer el subárbol izquierdo
3. Recorrer el subárbol derecho

Inorden:
2. Visitar la raíz
Postorden:
3. Visitar la raíz

Les dejo un enlace con un video que podrá visualizar desde la
plataforma, que explica los recorridos.
https://www.youtube.com/watch?v=Vsuo0eKJHEQ
Ahora vamos a ver un ejemplo de todo lo antedicho, pero en Java. En el mismo

podemos ver la creación de los nodos y del árbol, con los recorridos ya ilustrados.
package pruebaarbol;
import pruebaarbol.model.Nodo;
public class Pruebaarbol {
/**
* @param args the command line arguments
*/
//Se asignan los valores a los nodos = 1,2,3,4,5 y 6 dentro del arbol
//Nodo raiz = 1
Nodo raiz = new Nodo(1);
//Nodo2 Izquierdo = 2
Nodo nodo2 = new Nodo(2);
//Nodo3 Derecho = 3
Nodo nodo3 = new Nodo(3);
//Se asigna el valor 6 al nodo que sera hijo del nodo 3 a la derecha
nodo3.setNodoDerecho(new Nodo(6));
//Se asigna el valor 5 al nodo que sera hijo del nodo 3 a la izquierda
nodo3.setNodoIzquierdo(new Nodo(5));
//Se asigna el valor 4 al nodo que sera hijo del nodo 4 a la izquierda
nodo2.setNodoIzquierdo(new Nodo(4));
//Se crean el Nodo 2 a la izquierda y el Nodo 3 a la derecha de la raiz

raiz.setNodoIzquierdo(nodo2);
raiz.setNodoDerecho(nodo3);
//Resultado en pantalla
System.out.println(“Recorrido Preorden: “);
preOrden(raiz);

System.out.println(“Recorrido Inorden: “);
inorden(raiz);
System.out.println(“Recorrido PostOrden: “);
posOrden(raiz);
}
//Metodo Preorden
private static void preOrden(Nodo raiz) {
if (raiz != null) {
System.out.print(raiz.getDato() + “ - “);
preOrden(raiz.getNodoIzquierdo());
preOrden(raiz.getNodoDerecho());
}
}
//Metodo Inorden
private static void inorden(Nodo raiz) {
if (raiz != null) {
inorden(raiz.getNodoIzquierdo());
System.out.print(raiz.getDato()+ “ - “);
inorden(raiz.getNodoDerecho());
}
}
//Metodo PostOrden
private static void posOrden(Nodo raiz) {
if (raiz != null) {
posOrden(raiz.getNodoIzquierdo());
posOrden(raiz.getNodoDerecho());
System.out.print(raiz.getDato() + “ - “);
}
}

Leer
Actividad 1: Marque con una cruz la respuesta correcta
Actividad

Grafos
clase 4
tema 2 Miremos la imagen
¿Qué podemos ver?. Sí, no se equivoca, son distintos destinos y conexiones

áreas. Ahora le pido que se detenga a mirar el mapa, como puede ver hay oríge-
nes y destinos, conectados y dirigidos.
Resulta que en informática, existe una estructura de datos que tiene el mismo
comportamiento. Se denomina grafo. Es una estructura de datos dinámica y no
lineal.
Un grafo es un par ordenado donde es un

conjunto de nodos (vértices) y es un conjunto de aristas o
Atención arcos que relacionan o enlazan a estos nodos.
Gráficamente lo podemos ver así:
Los grafos tienen gran cantidad de aplicaciones

● Representación de circuitos electrónicos analógicos y digitales
● Representación de caminos o rutas de transporte entre localidades
● Representación de redes de computadores.

Una de las cuestiones más importantes en los grafos es el de encontrar el camino
de coste mínimo.
Partes de un Grafo

Vértices: Son los nodos con los que está conformado un grafo. Diremos que el
grado de un vértice es el número de aristas de las que es extremo. Se dice que
un vértice es `par’ o `impar’ según lo sea su grado.

CLASIFICACIÓN DE LOS GRAFOS
TIPOS DE GRAFOS

RECORRIDOS DE UN GRAFO
REPRESENTACIÓN DE GRAFOS EN PROGRAMAS
Hay tres maneras de representar un grafo en un programa: mediante matrices,

mediante listas y
mediante matrices dispersas.

El video que se coloca en enlace, que podrá visualizar desde pla-
taforam, trabaja lo conceptual de los grafos
https://www.youtube.com/watch?v=gYtwwEkyHB0 , muy intere-

sante.

Leer
Actividad 2: Representamos en forma de grafo
En esta actividad les pido que representen en forma de grafo el

Actividad siguiente problema
Implementando Grafos en Java: Matriz de Adyacencia
● En el siguiente código se puede ver cuáles son los métodos de objeto

que podremos utilizar sobre las variables de la clase Grafo (no etiquetado
ni ponderado) aparecen en la siguiente interfaz:

● La siguiente sintaxis muestra la implementación de la clase grafo con un
matriz de adyacencias:
● En las siguientes líneas de código se puede ver la implementación de

dos constructores, el primero de un grafo no dirigido y el segundo de un
grafo dirigido.

Algoritmos básicos de modificación: insertar y eliminar aristas.
Algoritmos básicos de modificación: insertar vértices
Implementando Grafos en Java: Lista de Adyacencia
● Implementación de la clase Grafo como una lista de adyacencias.
● La implementación de los distintos métodos de la clase Grafo aquí pro-

puesta utiliza los siguientes métodos de Lista:

● La siguiente sintaxis muestra la implementación de la clase grafo con una
lista de adyacencias:
● Constructores de Grafo
El constructor Grafo(boolean d) se utiliza para crear un grafo vacío, con un tamaño

máximo y número de vértices igual a 0. El argumento booleano indica si se trata
de un grafo dirigido o no dirigido.
También se puede incluir un constructor al que se le pasen como argumentos el

número de vértices del grafo y el valor para el campo dirigido. Se crea un vector
de n listas inicializadas.
● Algoritmos básicos de modificación: insertar aristas.
● Algoritmos básicos de modificación: eliminar aristas.

● Algoritmos básicos de modificación: insertar vértices
RECORRIDOS DE GRAFOS
Profundidad
Amplitud

Leer
Ejemplo de Uso
Se dispone de una matriz de tipo boolean que representa un mapa de un archi-

piélago.Un valor true en una posición (x,y) indica que hay tierra en ese punto,
mientras que un valor false indica que hay mar.

PRACTICANDO - SIN CLAVE DE CORRECCIÓN - ITEM DEL TRABAJO FINAL
clase 4
tema 3 Como es costumbre en esta materia, el último tema de la clase lo dedicamos a
practicar. Cuando hablamos de grafos tal vez debemos pensar un poco más en
donde lo usamos, o para qué lo aplicaríamos.
Esta vez vamos a practicar pero pensando en el examen final, por ese motivo,
realizaremos con una serie de ejercicios de orden teórico - práctico. Los destina-
dos a examen
Sabemos que los grafos se usan:

● Circuitos electrónicos
○ Tarjetas impresas
○ Circuitos integrados
● Redes de transporte
○ Autopistas
○ Vuelos
● Redes de ordenadores
○ LANs
○ Internet
● Web
○ Planeación (rutas críticas)
○ Planificación de las tareas que completan un proyecto
● Redes sociales
○ Facebook
Actividad 3: Nos preparamos para el examen final
Actividad ESTA ACTIVIDAD DEBE PRESENTARLA RESUELTA

EN SU EXAMEN FINAL, POR LO CUAL SE ACON-
SEJA REALIZARLA Y CONSULTAR LAS DUDAS DEL
TEMA CON SU TUTOR.
Por ello vamos a analizar el caso de Facebook. Mire atentamente esta imagen

Como puedes notar es un grafo. Lo que se pide en este ejercicio que:
● Realice el grafo de su usuario Facebook.

● Codifique un nodo en Java.
● Indique que tipo de grafo es.
● ¿Utilizará matriz de adyacencia o lista de adyacencia? ¿Por qué?
clase 4
claves de corrección Actividad 1: Marque con una cruz la respuesta correcta

Solución

Actividad 2: Representamos en forma de grafo

Consulte con su tutor
clase 4 Con esta clase hemos visto la mayoría de las estructuras de datos que son de
conclusiones utilidad a la hora de desarrollar una aplicación. Cuando nos piden un desarrollo a
veces es necesario decidir por un tipo de estructura o bien realizar una combina-
ción de algunas de ellas.
Espero que haya sido de utilidad, pues a partir de ahora las vamos a usar.

clase 5 Los ordenamientos son algoritmos que nos permiten manipular los datos de tal
introducción manera que los podamos procesar de una manera más eficiente.
En clases anteriores y en PII, hemos hablado de ordenamientos. Llegó la hora de

profundizar cada algoritmo de ordenamiento, mostrando el grado de eficiencia de
cada uno y como así también las ventajas y/o desventajas.
Espero me acompañen en esta nueva aventura.
clase 5
Tipo de ordenamientos
tema 1
Para empezar esta clase, miremos estas imágenes:
¿En cuál de las dos situaciones encontraríamos más rápido un juguete? Seguro
que respondieron lo mismo.
La imagen que muestra cierto orden y criterio, permite identificar más rápido el
objeto y de esa manera la búsqueda es más eficiente.
En informática los métodos o algoritmos de ordenamiento tienen el mismo obje-

tivo, hacerle las cosas más sencillas a la computadora y al desarrollo en general.
Las estructuras de datos son utilizadas para almacenar informa-

ción, para poder recuperarla de manera eficiente es deseable
que esté ordenada.
Atención
Ordenamiento de “Burbuja”
Funciona comparando cada elemento de la lista que va a ser ordenada con el

siguiente, intercambiándolos de posición si están en el orden equivocado.
Se debe revisar varias veces toda la lista hasta que no se necesiten más inter-
cambios, lo cual significa que la lista está ordenada.
Veamos lo antedicho con imágenes:

Comenzamos con una lista de valores desordenada
Tomamos los primeros dos elementos, se los compara según el criterio de orden
y si no están ordenados se intercambian los lugares:
Se repite el proceso con los siguientes dos elementos:
El proceso continua hasta llegar al final

Lo que hemos visto es la primera pasada. En la siguiente pasada el último ya
queda ordenado, por lo cual no se considerará en la próxima vuelta.
Actividad 1: ¡A trabajar!
Con la lista de valores que tiene este ítem y las imágenes realice
Actividad el resto de las pasadas (puede usar imágenes).
LECTURA COMPLEMENTARIA- Para profundizar el tema se

aconseja la lectura del material Ordenamientos ic 1
Leer
Ordenamiento de “Burbuja Bidireccional”
Es una mejora de burbuja, hace dos recorridos. Uno de inicio a fin y otro de fin a
inicio, eso me asegura que hace la mitad de las comparaciones o eso pretende.
Como hicimos con el método anterior observemos las imágenes que siguen.
Comenzamos con una lista de números desordenada:
Hacemos el intercambio inicial de los primeros dos elementos:

El proceso continúa hasta que termine con los valores.
Una vez que hizo la primera pasada de izquierda a derecha, luego lo hace de
derecha a izquierda.

Al finalizar la segunda iteración se marcan como ordenados el primer y último
número comparado. Y como ya no queda más nada que ordenar la lista queda:
Ordenamiento por inserción
Su funcionamiento consiste en el recorrido por la lista de valores seleccionando

en cada pasada un valor como clave y compararlo con el resto insertándolo en
el lugar correspondiente según un criterio de orden establecido.
Como hicimos en los métodos anteriores veamos en imágenes el corazón del
método.
Se selecciona el segundo dato como clave y se lo compara con los valores ubi-
cados a su izquierda y se inserta en el lugar correspondiente según un criterio
(menor que, por ejemplo)
Se selecciona el siguiente número como clave y se repite el proceso para todos

los valores anteriores

Se selecciona la siguiente clave
Finalmente se selecciona la última clave

Al finalizar el algoritmo tenemos como resultado la lista ordenado
Ordenamiento por Casilleros
Es un algoritmo de ordenamiento que distribuye todos los elementos a ordenar

entre un número finito de casilleros. Cada casillero sólo puede contener los ele-
mentos que cumplan ciertos criterios de orden, como por ejemplo que se encuen-
tren entre ciertos valores. Los criterios deben ser mutuamente excluyentes, para
evitar que un elemento pueda ser clasificado en dos casilleros distintos al mismo
tiempo. Después cada uno de esos casilleros se ordena individualmente algún
otro algoritmo de ordenamiento (que podría ser distinto según el casillero).
Si lo tuviéramos que describir en pasos, podría resumirse en:
1. Crear una colección de casilleros vacíos
2. Colocar cada elemento a ordenar en un único casillero
3. Ordenar individualmente cada casillero
4. Devolver los elementos de cada casillero concatenados por orden
Como podemos ver en la imagen
Debemos destacar que los criterios de ordenamientos por casillero deberían ser
los mismos, pues en caso contrario se produciría más desorden que ordenar. Es
decir todos de menor a mayor o todos de mayor a menor.

Ordenamiento por cuentas
Primero se debe averiguar cuál es el intervalo dentro del que están los datos a
ordenar (valores mínimo y máximo). Luego se crea un vector de números ente-
ros con tantos elementos como valores haya en el intervalo [mínimo, máximo],
y a cada elemento se le da el valor 0 (0 apariciones). A partir de ahí se recorren
todos los elementos a ordenar y se cuenta el número de apariciones de cada
elemento (usando el vector que hemos creado). Para terminar debemos recorrer
este vector para tener todos los elementos ordenados.
Veamos el siguiente ejemplo:

● Tenemos una lista de valores
● Buscar mìnimo y màximo:
● Crear un vector auxiliar:
● Recorrer la lista de números y contar elementos, el valor en la lista de

entrada se usa como índice en el vector auxiliar

● Recorriendo el vector auxiliar obtenemos la lista de números ordenada
Ordenamiento por Mezcla
Para comenzar veremos la siguiente imagen
Como se puede ver en la imagen partimos la lista desordenada en tantas bisec-

ciones hasta que nos quedemos con los elementos sueltos, para luego comenzar
a comparar y unir.
Los pasos podrían resumirse en:
1. Si la longitud de la lista es 0 ó 1, entonces ya está ordenada. En otro
caso:
a. Dividir la lista desordenada en dos sublistas de aproximadamente
la mitad del tamaño.
b. Ordenar cada sublista recursivamente aplicando el ordenamiento
por mezcla.
c. Mezclar las dos sublistas en una sola lista ordenada.

Ordenamiento con Árbol Binario
Ordena sus elementos haciendo uso de un árbol binario de búsqueda. Se basa

en ir construyendo poco a poco el árbol binario introduciendo cada uno de los
elementos en forma ordenada.
Se caracteriza por su buen rendimiento, es estable y no requiere de espacio extra
de almacenamiento.
Veamos ahora gráficamente cómo sería este ordenamiento:

Como podrá notar al crear el árbol, con un criterio de orden, el resultado es una
lista de valores ordenada.

Actividad 2: Participamos en un FORO
Actividad Los invito a participar de un Foro de ordenamiento. Los orde-

namientos trabajados en este tema responden a la clasificación
“métodos estables” pero existen otros métodos como:
● Shell
● Selección
● Heapsort
● Quicksort
¿Por qué se dicen inestables o no estables? Explicar la causa de
en cada caso.
Leer atentamente la intervención de sus compañeros y fundamen-

tar la suya. ¡Adelante!

Leer
clase 5
tema 2 Tipo de ordenamientos en Java
Ordenamiento de “Burbuja”
Dijimos que funciona comparando cada elemento de la lista que va a ser ordenada
con el siguiente, intercambiándolos de posición si están en el orden equivocado.
Se debe revisar varias veces toda la lista hasta que no se necesiten más inter-
cambios, lo cual significa que la lista está ordenada.
El código para ordenar un array sería:

Ordenamiento de “Burbuja Bidireccional”
Es una mejora del burbuja, hace dos recorridos. Uno de inicio a fin y otro de fin a
inicio, eso me asegura que hace la mitad de las comparaciones o eso pretende.
Como hicimos con el método anterior observemos las imágenes que siguen.
Veamos pues su código:

Ordenamiento por inserción
Su funcionamiento consiste en el recorrido por la lista de valores seleccionando

en cada pasada un valor como clave y compararlo con el resto insertándolo en
el lugar correspondiente según un criterio de orden establecido.
Su código se vería así:
Ordenamiento por Casilleros
Es un algoritmo de ordenamiento que distribuye todos los elementos a ordenar

entre un número finito de casilleros. Cada casillero sólo puede contener los ele-
mentos que cumplan ciertos criterios de orden, como por ejemplo que se encuen-
tren entre ciertos valores. Los criterios deben ser mutuamente excluyentes, para
evitar que un elemento pueda ser clasificado en dos casilleros distintos al mismo
tiempo. Después cada uno de esos casilleros se ordena individualmente algún
otro algoritmo de ordenamiento (que podría ser distinto según el casillero).
Si lo tuviéramos que describir en pasos, podría resumirse en:
1. Crear una colección de casilleros vacíos
2. Colocar cada elemento a ordenar en un único casillero
3. Ordenar individualmente cada casillero
4. Devolver los elementos de cada casillero concatenados por orden

Veamos el código:
1 import java.util.*;
2
3
4 public class BucketSort
5 {
6
7 public static Vector<Integer>
sort(Vector<Integer> lista, int inferior,int superior)
8 {
9 int rango= (superior-inferior);
10 int bucket_size = rango/10;
1 1
12 Vector<Vector> listas = new Vector<Vector>();
13 /* creamos las listas de ordenamiento */
14 for(int i=0;i<10;i++)
15 listas.addElement(new Vector<Integer>());
1 6
17 /*
18 agregamos cada uno de los elemento en la lista que corresponde
19 */
20 for(int i=0;i<lista.size();i++)
21 {
22 /* calculamos en la lista que le corresponde */
23 int casilla = (lista.elementAt(i)-inferior)/bucket_size;
24 /* Agregamos el elemento a la lista calculada */
25 Vector<Integer> vCasilla = listas.elementAt(casilla);
26 vCasilla.addElement(lista.elementAt(i));
27 }
2 8
29 /* Ordenamos las listas con un metodo de ordenamiento
30 en este caso utilizaremos el mismo metodo de ordenamiento
31 el BucketSort recursivo. */
32 Vector<Integer> out= new Vector<Integer>();
33 for(int i=0;i<listas.size();i++)
34 {
35 int inf= inferior+(i*bucket_size);
36 int sup= inferior+(i*bucket_size)+bucket_size;
37 /* en tmp vamos a guar-
dar cada una de las listas pero ya ordenadas */
38 Vector<Integer> tmp = null;
39 /* si el rango es igual a 1 quiere
decir que ya no hay por que ordenar si la lista tiene
un elemento quiere decir que la lista esta ordenada */
40 if( sup-inf == 1 || listas.elementAt(i).size() == 1)
41 {
42 tmp =listas.elementAt(i);
43 }

44 else
45 {
46 /*si no se cumple ninguna de las condiciones anteriores
entonces la lista no esta ordenada pero procedemos a ordenarla */
47 tmp = BucketSort.sort(listas.elementAt(i),inf,sup);
48 }
49 /*
50 temp contiene los elementos de una lista ordenada
51 Agregamos todos los elementos de las listas a una sola lista
52 */
53 for(int j=0;j<tmp.size();j++)
54 out.addElement(tmp.elementAt(j));
55 }
56 /*regresamos el contenido de todas las listas en una sola */
57 return out;
58 }
59 public static void main(String [] args)
60 {
61 Random r = new Random();
62 Vector<Integer> lista = new Vector<Integer>();
6 3
64 for(int i=0;i<1000;lista.addElement(r.nextInt(1000)),i++);
65 System.out.println(“Imprimiendo generados”);
66 for(int i=0;i<lista.size();System.
o u t . p r i n t l n ( l i s t a . e l e m e n t A t ( i + + ) ) ) ;
6 7
68 Vector<Integer> resultado = BucketSort.sort(lista,0,1000);
69 System.out.println(“Imprimiendo resultados”);
70 for(int= 0;i<resultado.size();i++)
71 System.out.println(resultado.elementAt(i));
7 2
73 }
7 4
75 }
Ordenamiento por cuentas
Primero se debe averiguar cuál es el intervalo dentro del que están los datos a
ordenar (valores mínimo y máximo). Luego se crea un vector de números ente-
ros con tantos elementos como valores haya en el intervalo [mínimo, máximo],
y a cada elemento se le da el valor 0 (0 apariciones). A partir de ahí se recorren
todos los elementos a ordenar y se cuenta el número de apariciones de cada
elemento (usando el vector que hemos creado). Para terminar debemos recorrer
este vector para tener todos los elementos ordenados.

Veamos su código:
Ordenamiento por Mezcla
Los pasos podrían resumirse en:

1. Si la longitud de la lista es 0 ó 1, entonces ya está ordenada. En otro
caso:
a. Dividir la lista desordenada en dos sublistas de aproximadamente
la mitad del tamaño.
b. Ordenar cada sublista recursivamente aplicando el ordenamiento
por mezcla.
c. Mezclar las dos sublistas en una sola lista ordenada.
Veamos su código:
public int[] mergeSort(int array[])

// pre: arreglo completo, todos los elementos enteros
// post: arreglo ordenado de mayor a menor
{
//si el array tiene más de 1 elemento, tene-
mos que dividir y combinar las mitades ordenados
if(array.length > 1)
{
// cantidad de elementos en sub-array 1
// si es impar, sub-array 1
tiene la media más pequeña de elementos
// p.ej. Si el total de 7 elemen-
tos, sub-array 1 tendrá 3, y sub-array 2 tendrá 4
int elementsInA1 = array.length / 2;
// inicializamos la longitud de sub-matriz de 2 a
// igual a la longitud total menos la longitud del sub-array 1
int elementsInA2 = array.length - elementsInA1;
// declarar e inicializar las dos matri-
ces, una vez que hemos determinado sus tamaños

int arr1[] = new int[elementsInA1];
int arr2[] = new int[elementsInA2];
// copiar la primera parte de ‘array’ en ‘arr1’
for(int i = 0; i < elementsInA1; i++)
arr1[i] = array[i];
// copiar los elementos restantes del ‘array’ en ‘arr2’
for(int i = elementsInA1;
i < elementsInA1 + elementsInA2; i++)
arr2[i - elementsInA1] = array[i];
// llamar en forma recursiva mer-
geSort en cada una de las partes para ordenarlas
arr1 = mergeSort(arr1);
arr2 = mergeSort(arr2);
int i = 0, j = 0, k = 0;
while(arr1.length != j && arr2.length != k)
{
// si el elemento actual de
arr1 es menor que el elemento actual de arr2
if(arr1[j] < arr2[k])
{
// copiar el ele-
mento actual de arr1 en el arreglo final
array[i] = arr1[j];
i + + ;
j + + ;
}
// si el elemento actual de
arr2 es menor que el elemento actual de arr1
e l s e
{
array[i] = arr2[k];
i + + ;
k + + ;
}
}
while(arr1.length != j)
{
array[i] = arr1[j];
i + + ;
j + + ;
}
while(arr2.length != k)
{
array[i] = arr2[k];
i + + ;
k + + ;
}
}
return array;
}

Ordenamiento con Árbol Binario
Ordena sus elementos haciendo uso de un árbol binario de búsqueda. Se basa

en ir construyendo poco a poco el árbol binario introduciendo cada uno de los
elementos en forma ordenada.
Se caracteriza por su buen rendimiento, es estable y no requiere de espacio extra
de almacenamiento.
A continuación desarrollamos una clase para la administración de un árbol binario
ordenado.
public class ArbolBinarioOrdenado {

class Nodo
{
int info;
Nodo izq, der;
}
Nodo raiz;
public ArbolBinarioOrdenado() {
raiz=null;
}
public void insertar (int info)

{
Nodo nuevo;
nuevo = new Nodo ();
nuevo.info = info;
nuevo.izq = null;
nuevo.der = null;
if (raiz == null)
raiz = nuevo;
else
{
Nodo anterior = null, reco;
reco = raiz;
while (reco != null)
{
anterior = reco;
if (info < reco.info)
reco = reco.izq;
else
reco = reco.der;
}
if (info < anterior.info)
anterior.izq = nuevo;
else
anterior.der = nuevo;
}
}
private void imprimirPre (Nodo reco)

{
if (reco != null)
{
System.out.print(reco.info + “ “);

imprimirPre (reco.izq);
imprimirPre (reco.der);
}
}
public void imprimirPre ()
{
imprimirPre (raiz);
}
private void imprimirEntre (Nodo reco)

{
if (reco != null)
{
imprimirEntre (reco.izq);
imprimirEntre (reco.der);
}
}
public void imprimirEntre ()

{
imprimirEntre (raiz);
}
private void imprimirPost (Nodo reco)

{
if (reco != null)
{
imprimirPost (reco.izq);
imprimirPost (reco.der);
}
}
public void imprimirPost ()

{
imprimirPost (raiz);
}
public static void main (String [] ar)

{
ArbolBinarioOrdenado abo = new ArbolBinarioOrdenado ();
abo.insertar (100);
abo.insertar (50);
abo.insertar (25);
abo.insertar (75);
abo.insertar (150);
System.out.println (“Impresion preorden: “);
abo.imprimirPre ();
System.out.println (“Impresion entreorden: “);
abo.imprimirEntre ();

System.out.println (“Impresion postorden: “);
abo.imprimirPost ();
}
}
Hagamos algunas aclaraciones:

● En el video que encontrarán en el enlace https://www.
youtube.com/watch?v=hf-_c7DFb3U y disponible desde
la plataforma, se muestra el ordenamiento por burbuja en
Java, con una explicación.
● En el video que encontrarán en la plataforma, se muestra

el ordenamiento por inserción en Java, con una explica-
ción.
Obviamente que cuando se necesite hacer un ordenamiento ustedes podrán

optar por cualquiera de los trabajados en esta clase, pero yo les puedo decir que
existen algunos más eficientes que otros.
La eficiencia es fundamental a la hora de desarrollar, gracias a procesos eficientes
tendremos software eficiente de respuesta ágil y por ende un usuario contento.

Actividad 3: ¡A resolver!
Actividad

Leer
clase 5 Practicando
tema 3 En este momento vamos a comenzar a practicar. Resuelva el siguiente caso:
Esta actividad deberá presentarla en el Examen Final
Enunciado:
Actividad Se pide que realice un programa ordenador de arreglos. El mismo
consiste en la carga de un vector, que se debe mostrar el conte-
nido del mismo, agregar un elemento al vector y vaciarlo.
Por otra parte debe presentar un menú de opciones con los
siguientes métodos de ordenamiento:
“1. Burbuja Derecha Izquierda”
“2. Burbuja de derecha a Izquierda”
“3. Inserción Directa”
“4. Selección Directa”
“5. Metodo Shell”
“6. Ordenamiento rápido”

Le recuerdo que como es una actividad destinada al examen
final, no posee clave de corrección, pero usted puede consultar
a su tutor ante cualquier duda durante su desarrollo.
Atención
LECTURA COMPLEMENTARIA
● Para poder afrontar los ejercicios, deben haber leído tema
1 y tema 2 de esta clase.
Leer ● Si quieren profundizar les recomiendo lean del material
complementario Weiss, Mark Allen. Estructuras De
Datos En Java. Pearson Educación, 2013.
clase 5 Actividad 1: con la lista de valores que tiene este ítem y las imágenes realice el
claves de corrección resto de las pasadas (puede usar imágenes).
Solución
Pasada 2

Pasada 3
Pasada 4
Actividad 2: Participamos en un FORO
Para poder participar en el foro recuerde que:

● La participación debe ser pertinente y respetuosa.
● El foro permite leer e interactuar con otros, permitiendo hacer un análisis
de lo leído en el tema de esta clase.
Actividad 3: ¡A resolver!

Solución
import javax.swing.JOptionPane;
public class MetodosDeOrdenamiento {
public static void main(String [] args){
int vector[] = new int[10];
for(int i=0;i < vector.length;i++){
vector[i] = Integer.parseInt(JOptionPane.showInputDialog((i+1)+ “º
Numero :”,0));
}
String Cadena =”Numeros Sin Ordernar \n”;
Cadena = Cadena + vector[i] + “ “;
}
Insercion(vector);
Cadena = Cadena + “\nNumeros Impares Ordenados De Forma Ascen-
dente”;
if(vector[i]%2!=0){
Cadena = Cadena + “\n” + vector[i] ;
}
}
JOptionPane.showMessageDialog(null,Cadena);
}
public static void Insercion (int[] vector) {
for (int i=1; i < vector.length; i++) {
int aux = vector[i];
int j;
for (j=i-1; j > =0 && vector[j] > aux; j--){
vector[j+1] = vector[j];
}
vector[j+1] = aux;
}
}
}
Solución

public class MetodosDeOrdenamientoJugadores {
public static void main(String [] args){
int x =Integer.parseInt(JOptionPane.
showInputDialog(“Ingrese Total De Equipos”,0));
int puntos[]= new int[x];
String equipos[]= new String[x];
for(int i =0;i < x;i++){
equipos[i]= JOptionPane.showInputDialog(“Ingrese Nombre De Equipo” );
puntos[i]= Integer.parseInt(JOptionPane.showInputDialog(“Ingrese Puntos”,0));
}
Burbuja(puntos,equipos);
String Cadena = “Equipos Y Sus Puntos \n”;
for(int i =0;i < x;i++){
Cadena = Cadena + equipos[i] + “ “ + puntos[i] + “\n”;
}
JOptionPane.showMessageDialog(null, Cadena);
}
public static void Burbuja(int[]matrix,String[]equipos){
int temp;
String tempe;
for(int i=1;i < matrix.length;i++){
for (int j=0 ; j < matrix.length- 1; j++){
if (matrix[j] < matrix[j+1]){
temp = matrix[j];
matrix[j] = matrix[j+1];
matrix[j+1] = temp;
tempe = equipos[j];
equipos[j] = equipos[j+1];
equipos[j+1] = tempe;
}
}
}
}
//a = Inicio ; b = Final
public static void Rapido(int matrix[], int a, int b){
matrix = new int[matrix.length];
int buf;
int from = a;
int to = b;
int pivot = matrix[(from+to)/2];
do{
while(matrix[from] < pivot){
from++;
}
while(matrix[to] > pivot){
to--;
}
if(from < = to){
buf = matrix[from];
matrix[from] = matrix[to];
matrix[to] = buf;
from++; to--;
}

}while(from < = to);
if(a < to){
Rapido(matrix, a, to);
}
if(from < b){
Rapido(matrix, from, b);
}
}
}
Actividad: Ordenar [50, 26, 7, 9, 15, 27] usando el método de ordenamiento que
desee.
//método java de ordenación por selección

public static void seleccion(int A[]) {
int i, j, menor, pos, tmp;
for (i = 0; i < A.length - 1; i++) { // tomamos como menor el
primero
menor = A[i]; // de los elementos que quedan por ordenar
pos = i; // y guardamos su posición
for (j = i + 1; j < A.length; j++){ // buscamos en el resto
if (A[j] < menor) { // del array algún elemento
menor = A[j]; // menor que el actual
pos = j;
}
}
if (pos != i){ // si hay alguno menor se intercambia
tmp = A[i];
A[i] = A[pos];
A[pos] = tmp;
}
}
}

Consulte con su tutor
clase 5 En esta clase pudimos ver que no siempre se usa el mismo algoritmo de ordena-
conclusiones miento, pues dada la situación, los datos o el desarrollo a veces el que es más
eficiente en un caso, no lo es en otro.
El ordenamiento es vital a la hora de listar, insertar o buscar, establece jerarquías

y eso permite tener salidas (ya sea en pantalla o disco) que faciliten los accesos
a los datos.
Espero que les haya servido.

clase 6 ENCAPSULAMIENTO, HERENCIA Y POLIMORFISMO
introducción
Durante las clases anteriores estuvimos trabajando de un manera tradicional
utilizando un estilo de programación denominada estructurada (ver P-II).
A partir de esta clase trabajaremos con programación orientada a objetos (ver

IPOO) y sus conceptos más importantes a la hora de desarrollar, encapsula-
miento, herencia y polimorfismo entre otras cuestiones.
Estamos a la mitad de la materia y esto implica que la integración de contenidos

vistos es fundamental, sigamos adelante entonces.
clase 6 Conceptos y Ejemplos

tema 1
A diferencia de las otras clases, vamos a empezar con un video, para luego expla-
yarnos, ejemplificar y practicar cada caso.
Lo invito a ver, en la plataforma, el video del enlace https://www.

youtube.com/watch?v=DemX62WPxXM que define en forma
escueta los conceptos de la clase y a la vez le muestra cómo se
codifica en Java usando un ejemplo.
Luego de ver este audiovisual, le habrá quedado claro, que cuando trabajamos
con encapsulamiento, herencia y polimorfismo, estamos dentro del paradigma
orientado a objetos (ver IPOO)
Para ello vamos a retomar algunos conceptos básicos vistos en la materia IPOO
de la carrera, los repasaremos y así podremos avanzar.
Cuando hablamos de Programación Orientada a Objetos, sabemos que el mundo

que tal vez debamos modelar para luego desarrollar un software, debe ser visto
como clases y objetos.

Debemos recordar que los objetos tienen atributos y métodos.
- ATRIBUTO - Valores o características de los objetos nos per-

miten definir el estado del objeto u otras cualidades
- MÉTODO - Acciones que puede realizar un objeto
Atención

Por otra parte sabemos que existe un sistema de mensajería entre los objetos,
que les permite comunicarse entre sí. Si un objeto desea que otro objeto haga
algo le envía un mensaje que puede tener información adicional en forma de
parámetros.
LECTURA COMPLEMENTARIA A manera de repaso del tema, se

aconseja la lectura del material complementario D.J. Barnes y M.
Kölling, Programación orientada a objetos con Java. Una introduc-
Leer ción práctica usando BlueJ. Pearson Educación, 2007.
Una vez que hemos repasado las bases, vamos a encarar el tema de la clase.
Ahora definiremos los términos más importantes:
Abstracción
Abstracción en la POO hace referencia a poder identificar el posible comporta-

miento de un objeto para luego convertirlo en sus métodos y funciones dentro de
una clase.
Encapsulamiento
Supongamos que creamos una clase, una serie de programadores tienen acceso
a dicha clase y la utilizan a su antojo, luego dicha clase comienza a comportarse
de una manera inesperada debido a que los valores que algunas variables han
tomado no fueron anticipados lo cual genera ciertas dificultades y para corregir el
problema se crea una versión más nueva de dicha clase.
Esto le llamamos flexibilidad y capacidad de mantenimiento, características y

beneficios de la programación Orientada a Objetos (OO) pero para que una clase
pueda cumplir dichas funciones los programadores debemos de hacer algo.
La manera de proteger el código es escribiendo un método que nos permita regu-

lar los valores que cada variable puede tener y esconder las variables para que
puedan ser accedidas de manera directa, esto es encapsulamiento.

Herencia:
En la POO las clases no se encuentran aisladas, sino que pueden interactuar con
otras clases compartiendo atributos y métodos que puedan existir entre estas.
Por ejemplo la clase CELULAR hereda a la clase CELULAR_NUEVOy CELU-
LAR_MALOGRADO. CELULAR tendría los datos comunes entre ambos.
A continuación veremos un código ejemplo de la clase persona.

Ahora vamos a crear una clase profesor, subclase de la clase persona:
El diagrama de clases y el resultado del test son del tipo que mostramos a con-
tinuación:
Los aspectos a destacar del código son:
a) La clase persona es una clase “normal” y la clase Profesor es una subclase

de Persona con ciertas peculiaridades.
b) Los objetos de la subclase van a tener campos nombre, apellidos y edad
(heredados de Persona) y un campo específico IdProfesor. El constructor de una
subclase ha de llevar obligatoriamente como parámetros al menos los mismos
parámetros que el constructor de la superclase.
c) El constructor de la subclase invoca al constructor de la superclase. Se incluye,
obligatoriamente, la palabra clave super como primera línea del constructor de
la subclase, irá seguida de paréntesis con los parámetros del constructor de la
superclase al que queramos invocar.

Polimorfismo:
Es la acción de poder usar múltiples posibilidades en una misma propiedad. Tam-

bién podríamos decir que a nivel de programación sería usar un método, función,
entre otros llamados de la misma forma pero con para diferentes cosas.
Veamos el siguiente ejemplo, en el que se define una clase forma de la que se
heredan las clases círculo y cuadrado
La clase forma define los métodos dibujar y borrar. En la definición de estos

métodos se implementará el código común a todos los objetos de la clase. Sin
embargo cuando definamos las clases hijas, círculo y cuadrado, será necesario
modificar estos métodos para adaptarlos a las nuevas subclases. El método de
la clase padre implementa aquellas acciones comunes. Las clases hijas añaden
las operaciones particulares que necesiten. Cuando utilicemos los métodos de la
clase forma no tendremos que hacer distinción entre cuadrados y círculos. Gra-
cias al polimorfismo se ejecutará el método adecuado en función de la subclase
a la que pertenezca el objeto
Veamos un ejemplo en Java de un programa Java para tienda de venta de juegos,

música y películas.

El programa está compuesto de seis clases: Test.java, Gestion.java, Producto.
java, Cine.java, Musica.java y Videojuego.java. La clase producto define propie-
dades comunes de los tipos Cine, Música y Video Juego, y cada una de estas
define sus propios atributos. La clase Gestión, como su nombre indica, gestiona
la tienda y la clase Test ejecuta el programa
● Explicación de la forma de desarrollo del programa ejem-

plo
https://www.youtube.com/watch?time_
continue=64&v=FqQSwOSC830
● Código fuente del programa https://drive.google.com/

open?id=0BzQS5pOyF_HjTGpjdnRzQnlfeDA
LECTURA COMPLEMENTARIA En el siguiente enlace encon-

trarán un ejemplo muy completo de los temas definidos. Pueden
replicarlo como práctica. https://www.asociacionaepi.es/progra-
Leer macion-orientada-a-objetos-en-java/?print=pdf

clase 6 Practicando
tema 2
Qué bueno es ejercitar, eso nos permite fortalecer, mente y espíritu. Si somos
desarrolladores practicar es base de nuestra formación.
Ahora llegó el momento de practicar, uniendo todo lo visto hasta

el momento. Para ello a continuación se listan una serie de
situaciones para que pueda practicar. No olvide consultar a su
tutor las dudas.
Las actividades que aquí se coloquen son base de su parcial 1.
Atención Es muy importante realizarlas pues las preguntas que se hagan
en el parcial, tendrán que ver con las actividades realizadas
desde la clase 1 hasta el momento.
LECTURA COMPLEMENTARIA A manera de repaso del tema,

se aconseja la lectura del material complementario D.J. Barnes y
M. Kölling, Programación orientada a objetos con Java. Una intro-
Leer ducción práctica usando BlueJ. Pearson Educación, 2007.

Actividad 1: Productos frescos, productos refrigerados y pro-
ductos congelados
Actividad
Se plantea desarrollar un programa Java que permita la gestión de
una empresa agroalimentaria que trabaja con tres tipos de produc-
tos: productos frescos, productos refrigerados y productos conge-
lados. Todos los productos llevan esta información común: fecha
de caducidad y número de lote. A su vez, cada tipo de producto
lleva alguna información específica. Los productos frescos deben
llevar la fecha de envasado y el país de origen. Los productos refri-
gerados deben llevar el código del organismo de supervisión ali-
mentaria. Los productos congelados deben llevar la temperatura
de congelación recomendada. Crear el código de las clases Java
implementando una relación de herencia desde la superclase Pro-
ducto hasta las subclases ProductoFresco, ProductoRefrigerado
y ProductoCongelado. Cada clase debe disponer de constructor y
permitir establecer (set) y recuperar (get) el valor de sus atributos
y tener un método que permita mostrar la información del objeto.
Crear una clase testHerencia2 con el método main donde se cree

un objeto de cada tipo y se muestren los datos de cada uno de los
objetos creados.
Actividad 2: Seguimos practicando
Actividad Definir una clase Figura, abstracta, con atributos:

● Entero coordenada_x, coordenada_y, ancho, alto
● Con decimales, para perímetro, área
Todos ellos privados, los getters y setters necesario, y método para
calcular el área. Heredando de la clase figura, crear las clases
Triangulo, Rectángulo, Circulo implementando el método “area” e
indica si estas instrucciones darán error
Actividad 3: ¡A ejercitar!
Actividad Modifica la clase de prueba, para utilizar una única línea para
imprimirlo todo, metiendo la instrucción en un método

Actividad 4: A trabajar
Actividad Añadir el método “dibujar” a la clase Rectángulo que dibujará la

figura con el número de asteriscos que se indiquen (menor de 30) y
haz que la clase Cuadrado herede de Rectángulo. Luego modifica
la clase de prueba para que cuando pueda dibuje el rectángulo,
cosa que solo podrá hacer cuando el objeto herede de Rectángulo
Actividad 5: Manos a la obra
Actividad Cree la clase Docente dentro de un paquete demo que tenga

como atributos privados: nombre, apellido, tipo (ciencias y letras),
horas:
- Un constructor público que inicialice a todos los atributos.
- Métodos de acceso: set/get para los atributos.
- Un método que retorne el nombre completo (nombre y apellido)
- Un método que retorne el suelto Bruto (“ciencia”=S/3 , “letras”=
S/5 por horas)
- Un método que retorne el descuento del 0.10
- Un método que retorne el sueldo neto
Actividad 6: Investiga, responde y justifica.
Actividad Marque Verdadero (V) o Falso (F) las siguientes afirmaciones y

Justifique si es necesario coloque un ejemplo.
1. Si una clase Alumno no tiene constructor , entonces se podrá realizar:

Alumno x = new Alumno (10);
2. En la sentencia Alumno x = null; se ha creado un objeto alumno.
3. La palabra reservada para importar paquetes es Imports.
4. El métodos de acceso es get o getters permite modificar datos a los
atributos
5. La palabra reservada para crear una clases es new
6. Se puede realizar la siguiente sentencia Auto x = new Auto(“Luciana”);
public class Auto {
public void autos(String x){}
}
g)La palabra reservada this permite invocar a otro constructor de la misma clase
h)Se puede realizar la siguiente sentencia Auto x = new Auto();
public class Auto {
public Auto(int x){}
}
i)La sentencia arroja errores de compilación
public class Auto{
public Auto (int cadena){ }
public Auto (int codigo){ }
}

j)La impresión de la ejecución de Auto x = new Auto(5); es 56
public class Auto{
public Auto (int num){
this();
imprime(5);
}
public Auto (){
imprime(6);
}
}
No olvide de repasar los contenidos vistos en PII y en IPOO.
Actividad 7: Foro- compartimos ejemplos
Actividad Cuando se traba en equipo todos colaboramos y compartimos

ideas. En este foro les pido que participen compartiendo ejemplos
de los siguientes términos:
● Abstracción
● Encapsulamiento
● Modularidad
● Ocultación
● Polimorfismo
● Herencia
Recordemos que debemos compartir ideas útiles para todos.
Actividad 8: WIKI – ¡A resolver en equipo!
Dado que todos hemos compartido nuestras ideas en el FORO,

Actividad ahora los convoco a desarrollar una actividad grupal. Para ello se
da el siguiente enunciado y ustedes lo resolverán en equipo.
“Codifica la siguiente jerarquía de clases java represen-
tada por este diagrama UML:

EVALUACIÓN: Ud. está en condiciones de resolver el primer parcial
clase 6
claves de corrección Actividad 1: Productos frescos, productos refrigerados y productos conge-
lados
Se plantea desarrollar un programa Java que permita la gestión de una empresa

agroalimentaria que trabaja con tres tipos de productos: productos frescos, pro-
ductos refrigerados y productos congelados. Todos los productos llevan esta
información común: fecha de caducidad y número de lote. A su vez, cada tipo de
producto lleva alguna información específica. Los productos frescos deben llevar
la fecha de envasado y el país de origen. Los productos refrigerados deben llevar
el código del organismo de supervisión alimentaria. Los productos congelados
deben llevar la temperatura de congelación recomendada. Crear el código de
las clases Java implementando una relación de herencia desde la superclase
Producto hasta las subclases ProductoFresco, ProductoRefrigerado y Producto-
Congelado. Cada clase debe disponer de constructor y permitir establecer (set) y
recuperar (get) el valor de sus atributos y tener un método que permita mostrar la
información del objeto. Crear una clase testHerencia2 con el método main donde
se cree un objeto de cada tipo y se muestren los datos de cada uno de los objetos
creados.

Código Resolutivo
SUPER CLASE PRODUCTO
package comidaHerencia;
public class Producto {

String fechaCaducidad, numeroLote;
public Producto(String fechaCaducidad, String numeroLote){

this.fechaCaducidad = fechaCaducidad;
this.numeroLote = numeroLote;
}
public void setFechaCaducidad(String fecha){

fechaCaducidad = fecha;
}
public void setNumeroLote(String num){

numeroLote = num;
}
public String getFechaCaducidad(){

return fechaCaducidad;
}
public String getNumeroLote(){

return numeroLote;
}
}
CLASE PRODUCTO CONGELADO
public class ProductoCongelado extends Producto {

private double tempCongelacionRecomendada;
public ProductoCongelado(String fechaCaducidad, String numeroLote){

super(fechaCaducidad, numeroLote);
tempCongelacionRecomendada = 0;
}
public void setTemperaturaRecomendada(double temperatura){

tempCongelacionRecomendada = temperatura;
}
public double getTemperaturaRecomendada(){

return tempCongelacionRecomendada;
}
}

CLASE PRODUCTO FRESCO
public class ProductoFresco extends Producto {

private String fechaEnvasado, paisDeOrigen;
public ProductoFresco(String fechaCaducidad, String numeroLote){

fechaEnvasado = “Desconocido”;
paisDeOrigen = “Desconocido”;
}
public void setFechaEnvasado(String fecha){

fechaEnvasado = fecha;
}
public void setPaisDeOrigen(String pais){

paisDeOrigen = pais;
}
public String getFechaEnvasado(){

return fechaEnvasado;
}
public String getPaisDeOrigen(){

return paisDeOrigen;
}
}
CLASE PRODUCTO REFRIGERADO

public class ProductoRefrigerado extends Producto{

private String codigoSupervisionAlimentaria;
public ProductoRefrigerado(String fechaCaducidad, String numeroLote){

codigoSupervisionAlimentaria = “Desconocido”;
}
public void setCodigoSupervisionAlimentaria(String codigo){

codigoSupervisionAlimentaria = codigo;
}
public String getCodigoSupervisionAlimentaria(){

return codigoSupervisionAlimentaria;
}
}

CLASE TESTHERENCIA2
public class testHerencia2 {

public static void main(String[]args){
ProductoCongelado nuggets = new ProductoCongelado(“16-10-
2016”,”L1603004”);
ProductoFresco lechuga = new ProductoFresco(“20-10-
2016”,”L1610005”);
ProductoRefrigerado jugo = new ProductoRefrigerado(“25-10-
2016”,”L1609006”);
System.out.println(“Sin datos. \nProducto Congelado: “);
System.out.println(“Fecha de caducidad: “ + nuggets.getFechaCadu-
cidad() + “\nNumero de Lote: “ + nuggets.getNumeroLote()
+ “\nTemperatura Recomendada: “ + nuggets.getTempera-
turaRecomendada() + “C°”);
System.out.println(“Producto Fresco: “);
System.out.println(“Fecha de caducidad: “ + lechuga.getFechaCaduci-
dad() + “\nNumero de Lote: “ + lechuga.getNumeroLote()
+ “\nFecha de envasado: “ + lechuga.getFechaEnvasado()
+ “\nPais de Origen: “ + lechuga.getPaisDeOrigen());
System.out.println(“Producto Refrigerado: “);
System.out.println(“Fecha de caducidad: “ + jugo.getFechaCaduci-
dad() + “\nNumero de Lote: “ + jugo.getNumeroLote()
+ “\nCodigo de supervision alimentaria: “ + jugo.getCodi-
goSupervisionAlimentaria());
nuggets.setTemperaturaRecomendada(-18);
lechuga.setFechaEnvasado(“03-10-2015”);
lechuga.setPaisDeOrigen(“Panamá”);
jugo.setCodigoSupervisionAlimentaria(“B#6745”);
System.out.println(“Con datos. \nProducto Congelado: “);
System.out.println(“Fecha de caducidad: “ + nuggets.getFechaCadu-
cidad() + “\nNumero de Lote: “ + nuggets.getNumeroLote()
+ “\nTemperatura Recomendada: “ + nuggets.getTempera-
turaRecomendada() + “C°”);
System.out.println(“Producto Fresco: “);
System.out.println(“Fecha de caducidad: “ + lechuga.getFechaCaduci-
dad() + “\nNumero de Lote: “ + lechuga.getNumeroLote()
+ “\nFecha de envasado: “ + lechuga.getFechaEnvasado()
+ “\nPais de Origen: “ + lechuga.getPaisDeOrigen());
System.out.println(“Producto Refrigerado: “);
System.out.println(“Fecha de caducidad: “ + jugo.getFechaCaduci-
dad() + “\nNumero de Lote: “ + jugo.getNumeroLote()
+ “\nCodigo de supervision alimentaria: “ + jugo.getCodi-
goSupervisionAlimentaria());
}
}

Actividad 2: Seguimos practicando
Definir una clase Figura, abstracta, con atributos :

● Entero coordenada_x, coordenada_y, ancho, alto
● Con decimales, para perímetro, área
Todos ellos privados, los getters y setters necesario, y método para calcular el
área. Heredando de la clase figura, crear las clases Triangulo, Rectángulo, Cir-
culo implementando el método “area” e indica si estas instrucciones darán error.
Solución

Creamos la clase Triangulo e implementamos el cálculo del área:
Creamos la clase Cuadrado; implementamos el cálculo del área para el cuadrado,

también modificamos ligeramente el constructor, y creamos uno optimizado, por
si queremos utilizarlo, aunque no estará dentro de los comportamientos polimór-
ficos

Creamos la clase Rectangulo, con su correspondiente implementación de “area“
Creamos la clase Circulo, heredando nuevamente de Figura, y escribimos la

nueva fórmula del área; esta vez, un circulo, y como recibimos ancho y alto,
podemos comprobar que son iguales, si no, deberíamos implementar el área de
la elipse; de momento con un cero.

Ya podemos crear una clase para poder jugar con todo esto
Actividad 3: ¡A ejercitar!
Modifica la clase de prueba, para utilizar una única línea para imprimirlo todo,
metiendo la instrucción en un método
Solución
En el anterior, la clase utilizada para hacer la prueba era

Si queremos imprimir desde un método, podemos hacer:
Ver que se ha podido hacer, porque todos los objetos descienden de Figura, y los
métodos getAncho(), getAlto(), y area(), son métodos definidos en la clase padre.
Actividad 4: A trabajar
Añadir el método “dibujar” a la clase Rectangulo que dibujará la figura con el

número de asteriscos que se indiquen (menor de 30) y haz que la clase Cuadrado
herede de Rectángulo.
Solución
Continuando con las soluciones de 2 y de 3 modificamos la clase Rectangulo la

llamamos Rectangulo2.

Como pueden ver, se ha añadido un filtro en el alto y en el ancho, en el cons-
tructor, y se ha codificado el nuevo método para que nos dibuje el rectángulo de
asteriscos, implementando un doble bucle.
Para la adaptación de la clase Cuadrado (Cuadrado2), solo tenemos que cambiar

el origen de la herencia, y borrar todo lo que nos sobra.

Por último, modificamos la clase de prueba:
Actividad 5: Manos a la obra
Cree la clase Docente dentro de un paquete demo que tenga como atributos pri-
vados: nombre, apellido, tipo (ciencias y letras), horas:
- Un constructor público que inicialice a todos los atributos.
- Métodos de acceso: set/get para los atributos.
- Un método que retorne el nombre completo (nombre y apellido)
- Un método que retorne el suelto Bruto (“ciencia”=S/3 , “letras”= S/5 por horas)
- Un método que retorne el descuento del 0.10
- Un método que retorne el sueldo neto
Solución
package demo;
public class Docente{
private String nombre, apellido, tipo;
private int horas;
public Docente(String nombre, String apellido, String tipo, int horas){

this. nombre = nombre;
this. apellido = apellido;
this. tipo = tipo;
this. horas = horas;
}
public String getNombre(){ return nombre;}

public String get Apellido (){ return apellido;}
public String get Tipo (){ return tipo;}
public int get Horas (){ return horas;}

public void setNombre(String nombre){this.nombre = nombre;}
public void set Apellido (String apellido){this. apellido = apellido;}
public void set Tipo (String tipo){this. tipo = tipo;}
public void set Horas (int horas){this. horas = horas;}
public String getNombreCompleto(){

rerturn nombre + “ ” + apellido;
}
public double getSueldoBruto (){
if(tipo.equals(“ciencia”))
return 3 * horas;
else
return 5 * horas;
}
public double getDescuento (){
return 0.10* getSueldoBruto ();
}
public double getNeto (){

return getSueldoBruto () - getDescuento ();
}
}
Actividad 6: Investiga, responde y justifica.
Marque Verdadero (V) o Falso (F) las siguientes afirmaciones y Justifique si

es necesario coloque un ejemplo. (1 Pto cada uno)
a) (V)Si una clase Alumno no tiene constructor , entonces se podrá
realizar:
Alumno x = new Alumno (10);
Porque por defecto solo cuando no se tiene un constructor el com-
pilador le agrega un constructor por defecto
public Alumno(){
b) (F)En la sentencia Alumno x = null; se ha creado un objeto

alumno.
Se crea cuando se realiza el new
Alumno x = new Alumno ();
c) (F)La palabra reservada para importar paquetes es Imports.

La palabra reservada es import
d) (F)El métodos de acceso es get o getters permite modificar datos

a los atributos
Los gets sirven para obtener datos
e) (F)La palabra reservada para crear una clases es new

La palabra reservada es class
f) (F)Se puede realizar la siguiente sentencia Auto x = new

Auto(“Luciana”);

public class Auto {
public void autos(String x){}
}
No tiene el constructor de tipo String
Se podría si
public class Auto {
public Auto (String x){}
}
g) (V)La palabra reservada this permite invocar a otro constructor
de la misma clase
public class Alumno {
public Alumno(double d){ }
public Alumno(int x, int y){ this(15.6);

}
}
h) (F)Se puede realizar la siguiente sentencia Auto x = new Auto();
public class Auto {
public Auto(int x){}
}
No se puede porque no tiene el constructos
public Auto(){}
i) (V)La sentencia arroja errores de compilación

public class Auto{
public Auto (int cadena){ }
public Auto (int codigo){ }
}
j) (F)La impresión de la ejecución de Auto x = new Auto(5); es 56
public class Auto{
public Auto (int num){
this();
imprime(5);
}
public Auto (){
imprime(6);
}
}
La impresión es 65
clase 6
conclusiones Durante esta clase hemos trabajado con conceptos importantes de la POO. La
misma nos permite percibir el mundo que nos rodea, de otra manera a la hora de
interpretarlo para un desarrollo de software.
Espero que les haya sido de utilidad. Sigamos avanzando.

clase 7
introducción COLECCIONES
Como habrán notado en la clase 6 hemos hecho un quiebre y pasamos al ámbito

de la programación orientada a objetos.
Dado que la materia IPOO trabajó las ideas conceptuales de esta forma de pro-
gramación, en P-III veremos la forma de codificar dichos conceptos.
Ahora vamos a trabajar con colecciones, ejemplo claro de la reutilización de

código, cuestión extremadamente importante en nuestra tarea.
Acompáñenme al mundo de las colecciones en Java.
clase 7
Conceptos
tema 1
Generalidades
Cada persona tiene alguna cuestión con las cosas que las rodea. Algunos tienen
afinidad por las estampillas, otros por los trofeos, otros por los juguetes.
Como pueden ver en la imagen, para armar una colección, los objetos deben
compartir ciertas características.
Las colecciones en Java son un ejemplo claro de implementación de código reu-
tilizable utilizando un lenguaje orientado a objetos. Podemos decir que todas las
colecciones son genéricas y que los tipos abstractos de datos se definen como
interfaces.
Cuando detectamos un comportamiento común a varias implementaciones pode-
mos abstraer en clases.
Las mencionadas anteriormente son solo algunas de las cuestiones que vamos
a ver en esta clase.

Características
Define las operaciones comunes a todas las colecciones de Java, permitiendo así
usar colecciones basándonos en su interfaz en lugar de en la implementación.
Los tipos básicos de colecciones son:
Operaciones

La interfaz List<T> define secuencias de elementos a los que se puede acceder
atendiendo a su posición. Las mismas van de 0 a size() -1. Acceder a una
posición ilegal produce la excepción IndexOutOfBoundsException.
Utilizando el método add(T e) su puede añadir al final de la lista.
A las operaciones existentes para las colecciones se añade métodos de acceso

por posición como:
Existen clases que se implementan con la interfaz List <T>. Las mismas son:
Se basa en arrays redimensionables. Las operaciones de inserción y modifica-

ción son ineficientes pero las operaciones de creación y consulta son rápidas.
Se basa en listas doblemente enlazadas, a diferencia de la anterior las Insercio-

nes y modificaciones rápidas, especialmente en el principio y el final.
Existen métodos que no están disponibles en List<T>: addFirst, addLast,
removeFirst, removeLast
Cuando se quiere acceder en forma aleatoria podemos decir que es un proceso
ineficiente. Solo logramos la eficiencia en el acceso al principio y al final de la
lista: getFirst y getLast

Se puede implementar de dos maneras:
Copia de colecciones
Todas las clases que implementan colecciones ofrecen un constructor de copia

y el método clone. En ambos casos construye una copia superficial del objeto
receptor.
Veamos el código de lo antedicho:

Gráficamente veríamos una copia de esta manera:
Orden de los objetos
En el caso de las colecciones ordenadas (SortedSet, SortedMap) nos vamos

a encontrar con dos tipo de ordenamientos: el orden natural de los objetos (por
defecto) o el criterio de ordenación que se establece en el constructor.
La interfaz Comparable nos da el orden natural de los objetos de las clases que
la implementan.
Con el método compareTo obtendremos un entero positivo en el caso de que la

relación sea “mayor que”, negativo para “menor que”y cero si son iguales.
Veamos lo antedicho con un ejemplo:

Lo que vemos en el código es el uso de la interfaz Comparable y de esa manera
poder usar el orden natural. Luego se CompareTo para determinar cual es mayor
o menor.
Ahora veamos un ejemplo del uso de TreeSet que nos permite armar conjuntos
ordenados, usando árbol binario balanceado.
En el código anterior se arma un conjunto con TreeSet. Como utiliza un árbol

binario balanceado para su construcción, ya se crea o agrega ordenadamente.
Se pueden establecer criterios de orden usando la interfaz Comparator.
El método compare devuelve un entero positivo si la relación es “mayor que”,

negativo si es “menor que”y cero si son iguales. Utilizamos un criterio de ordena-
ción cuando los objetos a ordenar no tienen orden natural o ese orden no interesa
usarlo.

Recuerdan el código
Se utilizaba ComapareTo, en el que vamos a ver ahora
se usa la interfaz Comparator y el método compare.

Vamos ahora a ver un ejemplo de código de TreeSet con criterio de ordenación.
El criterio viene dado por Orden de los titulares de las cuentas.
Habiendo aplicado el criterio, ahora vamos a armar el árbol

Iteradores
Las colecciones de Java son iterables, es decir, podemos recorrer todos sus ele-
mentos. Son utilizadas para que el código que realiza el recorrido no se detenga
en particularidades de la estructura de datos: lista enlazada, lista basada en
arrays, que está recorriendo.
Java proporciona la interfaz Iterable<T> que debe ser implementada por

aquellas clases sobre las que puedan ser iteradas:
A los objetos iterables se les exige que creen objetos iterador (Iterator) para
realizar la iteración. Los arrays y la interfaz Collection son iterables.
Si nos detenemos en Iterator<T> posee algunos métodos interesantes.
● hasNext(): indica si quedan elementos en la iteración.
● next(): devuelve el siguiente elemento de la iteración.
● remove(): remueve el último elemento que devuelve la iteración.

for each
Este tipo de recorridos, permite recorrer el objeto iterable sin manejar el objeto
iterador. Es muy utilizada.
Usaremos un iterador cuando queremos eliminar algún elemento de la colección.

Para cerrar lo anterior los invito a ver en la plataforma, el siguiente
video
https://www.youtube.com/watch?v=Q9YlFOr-htk
LECTURA COMPLEMENTARIA A manera de repaso del tema, se

aconseja la lectura del material complementario D.J. Barnes y M.
Kölling, Programación orientada a objetos con Java. Una introduc-
Leer ción práctica usando BlueJ. Pearson Educación, 2007
clase 7 Practicando
tema 2
Mayor Práctica = Mejor desarrollo
Las colecciones son de mucha utilidad, por lo cual vamos a hacer una serie de
ejercicios sobre el tema.
Les recomiendo la lectura del tema 1, pues allí encontrarán todo lo necesario para
afrontar cada uno de los enunciados.

Actividad 1: A resolver los siguientes enunciados
Actividad
Se recomienda tener especial atención al enunciado 2, se harán

preguntas sobre el mismo en el item 1 de la evaluación parcial
2.
Atención

clase 7 Práctica complementaria.
tema 3
Mayor Práctica = Mejor desarrollo
En esta oportunidad les presentamos ejercicios para que practiquen. Los mismos
no tienen claves de corrección. Les sugerimos consultarlos con su tutor
1. Crea una clase Cuenta con los métodos ingreso, reintegro y transferencia. La
clase contendrá un constructor por defecto, un constructor con parámetros, un
constructor copia y los métodos getters y setters.
2. Crea una clase Contador con los métodos para incrementar y decrementar el
contador. La clase contendrá un constructor por defecto, un constructor con pará-
metros, un constructor copia y los métodos getters y setters.
3. Crea una clase Libro con los métodos préstamo, devolución y toString. La
clase contendrá un constructor por defecto, un constructor con parámetros y los
métodos getters y setters.
4. Crea una clase Fraccion con métodos para sumar, restar, multiplicar y dividir
fracciones.
5. Crea una clase Complejo con métodos para sumar, restar, multiplicar y dividir
números complejos.
6. Crea una clase Fecha. La clase contendrá además de constructores, métodos

set y get y el método toString, un método para comprobar si la fecha es correcta
y otro para modificar la fecha actual por la del día siguiente.
7. Crea una clase Empleado. La clase contendrá un atributo estático o atributo

de clase.
8. Crea una clase NIF. Los atributos serán el número de DNI y la letra. La clase
contendrá un método privado que calcule la letra del NIF a partir del número de
DNI

clase 7 Actividad 1: A resolver los siguientes enunciados
Solución
package Ejercicio;
import java.util.*;
public class colegio {
Map alumno = new HashMap();
public void addAlumno(String nac){
if (alumno.containsKey(nac)){
Integer i = alumno.get(nac);
alumno.remove(nac);
alumno.put(nac, i++);
}
else{
alumno.put(nac,1);
}
}
public void showAll(){
Iterator it = alumno.keySet().iterator();
while (it.hasNext()){
Integer key = (Integer) it.next();
System.out.println(“Numero de alumno: “+key+”
Nacionalidad alumno: “+alumno.get(key));
}
}
public void showNacionalidad(){
for (String k :alumno.keySet()){
System.out.println(k+”->”+alumno.get(k));
}
}
public int cuantos(){
return alumno.size();
}

public void borrar(String nac){
alumno.remove(nac);
}
}
Solución
package javaList;
import java.util.*;
public class ejercicio2 {
ArrayList listDias = new ArrayList();
listDias.add(“Lunes”);
listDias.add(“Martes”);
listDias.add(“Miercoles”);
listDias.add(“Jueves”);
listDias.add(“Viernes”);
listDias.add(“Sabado”);
listDias.add(“Domingo”);
listDias.add(4,”Juernes”);
ArrayList listaDos = new ArrayList(listDias);
listDias.addAll(listaDos);
System.out.println(listDias.get(3)+”, “+list-
Dias.get(4));
System.out.println(listDias.get(0)+”, “+list-
Dias.get(listDias.size()-1));
System.out.println(listDias);
listDias.remove(“Juernes”);
if(listDias.remove(“Juernes”)){
System.out.println(“Borrado”);
}
else{
System.out.println(“No existe”);
}

Iterator it = listDias.iterator();
System.out.println(it.next());
}
if (listDias.contains(“Lunes”)){
System.out.println(“Si existe Lunes”);
}
Iterator it2 = listDias.iterator();
while(it2.hasNext()){
if(it2.next().toUpperCase()==”LUNES”){
System.out.println(“Si existe”);
}
}
Collections.sort(listDias);
listDias.clear();
}
Solución
package ejercicio3;
import java.util.*;
public class JavaSets {
HashSet FCBarcelona = new HashSet<>();
public void add(){
FCBarcelona.add(“Jordi Alba”);
FCBarcelona.add(“Pique”);
FCBarcelona.add(“Busquets”);
FCBarcelona.add(“Iniesta”);
FCBarcelona.add(“Messi”);
}
HashSet jugadores = new HashSet<>();
public void add2(){
jugadores.add(“Pique”);
jugadores.add(“Busquets”);
}
public void ShowBarcelona(){
int i = 0;

Iterator it = FCBarcelona.iterator();
System.out.print(it.next());
if(FCBarcelona.size()-1 > i){
System.out.print(“, “);
i++;
}
}
}
public void contains(){

if(FCBarcelona.contains(“Neymar Jr”)){
System.out.println(“Neymar Si está en el
conjunto”);
}
else{
System.out.println(“Neymar No está en el
conjunto”);
}
}
public void jugadoresEnBarcelona(){

Iterator it = jugadores.iterator();
Iterator it2 = FCBarcelona.iterator();
if(FCBarcelona.contains(it2.next())){
System.out.println(it.next()+” está
en el conjunto”);
}
else{
System.out.println(it.next()+” no
está en el conjunto”);
}
}
}
public void unir(){

FCBarcelona.addAll(jugadores);
}
public void borrar(){

jugadores.removeAll(jugadores);
System.out.println(“Jugadores Borrados”);
}
public void ShowJugadores(){

Iterator it = jugadores.iterator();
int i=0;
if(it.hasNext()==false){
System.out.println(“No hay jugadores”);
}
else{
S y s t e m . o u t . p r i n t ( i t .

next());if(jugadores.size()-1 > i){
System.out.print(“, “);
i++;
}
}
}
}
}
package ejercicio3;
public class Test {

JavaSets Barcelona = new JavaSets();
Barcelona.add();
Barcelona.contains();
Barcelona.ShowBarcelona();
Barcelona.add2();
Barcelona.jugadoresEnBarcelona();
Barcelona.ShowJugadores();
Barcelona.unir();
Barcelona.borrar();
Barcelona.ShowJugadores();
Barcelona.ShowBarcelona();
}
}
clase 7 Conclusión
conclusiones
Durante esta clase hemos visto una manera económica de reutilizar el código. La
idea es que como desarrolladores logremos módulos y código coleccionables, de
tal manera que con pequeños ajustes se adapten a la nueva situación.
Espero que esta clase les haya sido de utilidad. Nos vemos en la próxima.

clase 8 EXCEPCIONES Y ARCHIVOS
introducción
Hasta el momento hemos trabajado con datos de tipo volátil. Esto es, en el
momento de apagar el equipo, los datos ingresados y procesados desaparecen
pues estaban en la RAM.
En esta clase veremos el manejo de archivos en Java. Los archivos nos permiten
tener los datos a disposición, sin depender de otros factores, como energía eléc-
trica o estado general del hardware.
Ahora bien, al manejar archivos, también debemos tener en cuenta que se pueden
producir errores y por tal motivo Java nos provee de un mecanismo de informa-
ción, que nos permite salvar situaciones complicadas.
Espero que me acompañen.
clase 8
tema 1 Conceptos y Ejemplos
Veamos la siguiente imagen:
Aparentemente nuestro hombrecito está buscando algo. Lo bueno es que ese

algo que busca se encuentra guardado con algún criterio de orden que le facilite
el proceso de búsqueda.
Esa es la utilidad básica de los archivos y a eso nos vamos a dedicar en esta
clase.
¿Por qué usar archivos?
En la mayoría de los casos tendremos que guardar los datos de nuestro desarro-
llo para poderlos recuperar más adelante. Hay varias formas de hacerlo. Una de
ellas es el uso de archivos.

Escribir en un archivo de texto
Un primer tipo de archivo, son los de texto. Con ellos podremos crear desde un
programa en Java y leer con cualquier editor de textos, o bien crear con un editor
de textos y leer desde un programa en Java, o bien usar un programa tanto para
leer como para escribir.
Para manipular archivos, existen tres pasos:

● Abrir
● Guardar datos o leer datos
● Cerrar
Hay que recordar siempre esos tres pasos:
● si no guardamos o leemos datos, nada hemos hecho;
● si no abrimos archivo, obtendremos un error en el caso de querer acceder
a un dato del archivo.;
● si no cerramos el archivo (un error frecuente), puede que no se llegue a
guardar ningún dato, o no se vacíe el “buffer”.
Veamos un ejemplo:
Además, para cerrar el archivo, usaremos “close”, mientras que para abrir usare-
mos un BufferedWriter, que se apoya en un FileWriter, que a su vez usa un “File”
al que se le indica el nombre del archivo. Veamos:
import java.io.*;
class FicheroTextoEscribir
{
public static void main( String[]
) args
{
System.out.println(“Volcando a fichero de texto...”);
try
{
BufferedWriter ficheroSalida = new BufferedWriter(
new FileWriter(new File(“fichero.txt”)));
ficheroSalida.write(“Hola”);
ficheroSalida.newLine();
ficheroSalida.write(“Este es”);
ficheroSalida.write(“ un fichero de texto”);
ficheroSalida.newLine();
ficheroSalida.close();
}
catch (IOException errorDeFichero)
{
System.out.println(
“Ha habido problemas: “ +
errorDeFichero.getMessage() );
}

}
}
Leer de un archivo de texto
Para leer de un archivo de texto usaremos “readLine()”, que nos devolverá una
cadena un “string”. Si ese string es null, significa que el archivo llegó al fin y no se
ha podido leer. Por eso, lo habitual es usar un “while” para leer todo el contenido
de un archivo.
Usaremos un BufferedReader, que se apoyará en un FileReader:
import java.io.*;
class FicheroTextoLeer
{

) args
{
// Volcar a un fichero las líneas de otro (de texto)
// que empiecen por “A”
// Errores: sólo se comprueba si no existe el de origen
if (! (new File(“fichero.txt”)).exists()
)
{
System.out.println(“No he encontrado fichero.txt”);
return;
}
System.out.println(“Leyendo fichero de texto...”);
try
{
BufferedReader ficheroEntrada = new BufferedReader(
new FileReader(new File(“fichero.txt”)));
String linea=null;
while ((linea=ficheroEntrada.readLine()) != null) {
System.out.println(linea);
}
ficheroEntrada.close();
}
catch (IOException errorDeFichero)
{
System.out.println(
}
}
}

Leer de un archivo binario
Un archivo “binario” es un archivo que contiene “cualquier cosa”. Se puede leer

byte a byte con “read()”. Si el dato lo leemos como “int”, un valor de “-1” indicará
que se ha acabado el archivo. para este tipo de archivo que usaremos será un
“FileInputStream”:
import java.io.*;
class FicheroBinarioLeer
{
) args
{
// Cantidad de “a” en un fichero de cualquier tipo
// Mirando errores solo con try-catch
System.out.println(“Contando \”a\”...”);
int contador = 0;
try
{
FileInputStream ficheroEntrada2 =
new FileInputStream(new File(“fichero.bin”));
int dato;
while ((dato = ficheroEntrada2.read()) != -1) {
if (dato == 97) // Codigo ASCII de “a”
contador++;
}
ficheroEntrada2.close();
}
catch (Exception errorDeFichero)
{
System.out.println(
}
System.out.println(“Cantidad de \”a\”: “ + contador);
}
}
En el ejemplo anterior se cuenta la cantidad de letras “a” que contiene un archivo

de cualquier tipo, ya sea de texto, ejecutable, documento creado con un procesa-
dor de textos o cualquier otro archivo.
Leer y escribir bloques en un archivo binario
Si tenemos que leer muchos datos de un archivo de cualquier tipo, acceder byte
a byte puede resultar muy lento. Lo que se podría hacer es usar un array de bytes
de tal forma que con “read”, le podemos indicar en qué array queremos guardar
los datos y desde donde hasta donde.

Veamos un ejemplo:
import java.io.*;
class FicheroBinarioEscribir
{

) args
{
// ----------------
// Copiar todo un fichero, con bloques de 512 Kb
// Sin ninguna comprobación de errores
System.out.println(“Copiando fichero binario...”);

final int BUFFER_SIZE = 512*1024;
try
{
InputStream ficheroEntrada3 = new FileInputStream(
new File(“fichero.in”));
OutputStream ficheroSalida3 = new FileOutputStream(
new File(“fichero2.out”));
byte[] buf new byte[BUFFER_SIZE];

=
int cantidadLeida;
while ((cantidadLeida = ficheroEntrada3.read(buf, 0,
BUFFER_SIZE)) > 0)
{
ficheroSalida3.write(buf, 0, cantidadLeida);
}
ficheroEntrada3.close();
ficheroSalida3.close();
}
catch (Exception errorDeFichero)
{
System.out.println(
}
System.out.println(“Terminado!”);
}
}

Excepciones en Java
Una excepción es un evento producido en la ejecución de un programa que inte-

rrumpe el flujo normal de instrucciones. Supongamos, si manejamos archivos, es
posible que el archivo no exista en la ruta indicada, la sintaxis es correcta, pero
en tiempo de ejecución no puede realizar la acción, por lo tanto se produce una
excepción.
La clase encargada controlar excepciones esta en java.io. Para capturar una
excepción, debemos usar try-catch, esta es su sintaxis:
try{
//acciones
}catch(clase_maneja_excepciones variable){
//acciones
}
El código que esta dentro del bloque try produce una excepción, se interrumpe el
flujo y pasa al bloque catch, veamos un ejemplo:
import java.io.IOException;
import java.io.FileReader;
public class ExcepcionApp {
try{
//si el nombre del fichero no existe, lanza el catch
FileReader fr=new FileReader(“casa”);
//Esta linea no se ejecuta

System.out.println(“No veras este mensaje”);
}catch(IOException e){
System.out.println(“Error E/S: el fichero no
existe”);
}

Podemos usar más de un bloque catch para manejar distintas excepciones más
específicas. Veamos:
import java.io.FileNotFoundException;
FileReader fr=null;
try{
fr=new FileReader(“casa”);

}catch(FileNotFoundException e){
existe”);
}
catch(IOException e){
System.out.println(“Si el fichero no existe, este
mensaje no se vera”);
}
Podemos añadir un bloque finally después del bloque catch, este nos permitirá
que se produzca o no una excepción se ejecute lo que haya en este bloque.
Veamos un ejemplo:
FileReader fr=null;
try{
fr=new FileReader(“casa”);

existe”);
}finally{
System.out.println(“Este mensaje siempre se eje-
cutara”);
}

}
Podemos “lanzar” las excepciones que se produzcan a un nivel superior, usando

la palabra throws clase_maneja_excepciones. Veamos:
try{
prueba();

existe”);
}
}
public static void prueba() throws IOException{
//Lanzara una excepcion, pero se lanza en el try-

catch del main
FileReader fr=new FileReader(“casa”);
}
}
Para poder cerrar el tema los invito a ver en la plataforma el video

del enlace, que les hace un resumen del manejo de archivos y
excepciones
https://www.youtube.com/watch?v=U3l9Y0vvOJg

A manera de repaso del tema, se aconseja la lectura del material
complementario D.J. Barnes y M. Kölling, Programación orientada
a objetos con Java. Una introducción práctica usando BlueJ. Pear-
Leer
son Educación, 2007.
clase 8
Prácticas
tema 2
De los siguientes ejercicios se seleccionarán al menos 3 que

serán base del ítem 2 de la Evaluación Parcial 2, sobre los
cuales se harán preguntas de orden teórico.
Atención
Actividad 1: Actividades de repaso
Actividad
1. Crea un fichero de texto con el nombre y contenido que tu quieras. Ahora

crea una aplicación que lea este fichero de texto carácter a carácter y
muestre su contenido por pantalla sin espacios. Por ejemplo, si un fichero
tiene el siguiente texto “Esto es una prueba”, deberá mostrar “Estoesuna-
prueba”. Captura las excepciones que veas necesario.
2. Crea una aplicación donde pidamos la ruta de un fichero por teclado y un

texto que queramos a escribir en el fichero. Deberás mostrar por pantalla
el mismo texto pero variando entre mayúsculas y minúsculas, es decir, si
escribo “Bienvenido” deberá devolver “bIENVENIDO”. Si se escribe cual-
quier otro carácter, se quedará tal y como se escribió. Deberás crear un
método para escribir en el fichero el texto introducido y otro para mostrar
el contenido en mayúsculas. IMPORTANTE: cuando pidas por teclado
una ruta con JOptionPane, no es necesario que insertes caracteres de
escape.

3. Crea una aplicación que pida la ruta de dos ficheros de texto y de una
ruta de destino (solo la ruta, sin fichero al final). Debes copiar el contenido
de los dos ficheros en uno, este tendrá el nombre de los dos ficheros
separados por un guion bajo, este se guardara en la ruta donde le haya-
mos indicado por teclado. Para unir los ficheros en uno, crea un método
donde le pases como parámetro todas las rutas. En este método, aparte
de copiar debe comprobar que si existe el fichero de destino, nos mues-
tre un mensaje informándonos de si queremos sobrescribir el fichero. Te
recomiendo usar la clase File y JOptionPane. Por ejemplo, si tengo un
fichero A.txt con “ABC” como contenido, un fichero B.txt con “DEF” y una
ruta de destino D:\, el resultado será un fichero llamado A_B.txt en la ruta
D:\ con el contenido “ABCDEF”. Puedes crear submétodos para realizar
la copia de ficheros, piensa también como podrías optimizar esta copia,
si los ficheros tuvieran mucho contenido. Recuerda que debes controlar
las excepciones que puedan aparecer. En caso de error, mostrar una
ventana de dialogo con información del error.
4. Crea una aplicación que copie un fichero binario a otra localización. En

lugar de leer y escribir byte a byte, crea un array de bytes con el tamaño
del fichero de origen (utiliza el método available()), copia el contenido del
fichero a este array y escribe a partir de este array. Recuerda que debes
controlar las excepciones que puedan aparecer. En caso de error, mos-
trar una ventana de dialogo con información del error.
5. Crea una aplicación que pida por teclado un número de números alea-
torios enteros positivos y la ruta de un fichero. Este fichero contendrá la
cantidad de números aleatorios enteros positivos que se ha pedido por
teclado. Escribe los números usando un DataOutputStream y muestra
por pantalla estos números leyéndolos con un DataInputStream. El rango
de los números aleatorios estará entre 0 y 100, incluyendo el 100. Cada
vez que ejecutemos la aplicación añadiremos números al fichero sin
borrar los anteriores, es decir, si cuando creo el fichero añado 10 núme-
ros y después añado otros 10 al mismo, en el fichero habrá 20 números
que serán mostrados por pantalla.
6. Crea una aplicación que almacene los datos básicos de un vehículo

como la matricula (String), marca (String), tamaño de depósito (double)
y modelo (String) en ese orden y de uno en uno usando la clase DataIn-
putStream. Los datos anteriores datos se pedirán por teclado y se irán
añadiendo al fichero (no se sobrescriben los datos) cada vez que ejecu-
temos la aplicación. El fichero siempre será el mismo, en todos los casos.
Muestra todos los datos de cada coche en un cuadro de dialogo, es decir,
si tenemos 3 vehículos mostrara 3 cuadros de dialogo con sus respecti-
vos datos. Un ejemplo de salida de información puede ser este:

LECTURA COMPLEMENTARIA
● A manera de búsqueda de técnicas de desarrollo, se
aconseja lea los ejemplos de la clase 8 tema 1.
Leer ● A manera de repaso del tema, se aconseja la lectura del
material complementario D.J. Barnes y M. Kölling, Progra-
mación orientada a objetos con Java. Una introducción
práctica usando BlueJ. Pearson Educación, 2007.
clase 8
Actividad 1: Actividades de repaso
1. Crea un fichero de texto con el nombre y contenido que quieras. Ahora

crea una aplicación que lea este fichero de texto carácter a carácter y
muestre su contenido por pantalla sin espacios. Por ejemplo, si un fichero
tiene el siguiente texto “Esto es una prueba”, deberá mostrar “Estoesuna-
prueba”. Captura las excepciones que veas necesario.
Solución
public class Ejercicio1App {
final String nomFichero=”D:\pruebas.txt”;
try(FileReader fr=new FileReader (nomFichero)){
int valor=fr.read();
while(valor!=-1){
//Si el caracter es un espacio no lo escribe
if(valor!=32){
System.out.print((char)valor);
}
valor=fr.read();
}
System.out.println(“Problemas con el E/S “+e);
}
}
}

2. Crea una aplicación donde pidamos la ruta de un fichero por teclado y un
texto que queramos a escribir en el fichero. Deberás mostrar por pantalla
el mismo texto pero variando entre mayúsculas y minúsculas, es decir, si
escribo “Bienvenido” deberá devolver “bIENVENIDO”. Si se escribe cual-
quier otro carácter, se quedara tal y como se escribió. Deberás crear un
método para escribir en el fichero el texto introducido y otro para mostrar
el contenido en mayúsculas. IMPORTANTE: cuando pidas por teclado
una ruta con JOptionPane, no es necesario que insertes caracteres de
escape.
Solución
import java.io.FileWriter;
String ruta=JOptionPane.
showInputDialog(“Introduce la ruta del fichero”);
String texto=JOptionPane.showInputDialog(“Introduce
el texto que quieras escribir en el fichero”);
escribirFichero(ruta, texto);
mostrarFicheroMay(ruta);
}
public static void escribirFichero(String nomFich, String

texto){
try(FileWriter fw=new FileWriter(nomFich);){
//Escribimos el texto en el fichero

fw.write(texto);
System.out.println(“Problemas en la escritura
E/S “+e);
}
}
public static void mostrarFicheroMay(String nomFich){

try(FileReader fr=new FileReader (nomFich)){
int valor=fr.read();
while(valor!=-1){
//Solo cambiara el caracter si es una minuscula o
una mayuscula
char caracter=(char)valor;
if(caracter>=97 && caracter<=122){
caracter-=32;
}else if(caracter>=65 && caracter<=90){
caracter+=32;
}
System.out.print(caracter);

valor=fr.read();
}
System.out.println(“Problema con la E/S “+e);
}
}
3. Crea una aplicación que pida la ruta de dos ficheros de texto y de una
ruta de destino (solo la ruta, sin fichero al final). Debes copiar el contenido
de los dos ficheros en uno, este tendrá el nombre de los dos ficheros
separados por un guion bajo, este se guardara en la ruta donde le haya-
mos indicado por teclado. Para unir los ficheros en uno, crea un método
donde le pases como parámetro todas las rutas. En este método, aparte
de copiar debe comprobar que si existe el fichero de destino, nos mues-
tre un mensaje informándonos de si queremos sobrescribir el fichero. Te
recomiendo usar la clase File y JOptionPane. Por ejemplo, si tengo un
fichero A.txt con “ABC” como contenido, un fichero B.txt con “DEF” y una
ruta de destino D:\, el resultado sera un fichero llamado A_B.txt en la ruta
D:\ con el contenido “ABCDEF”. Puedes crear submétodos para realizar
la copia de ficheros, piensa también como podrias optimizar esta copia,
si los ficheros tuvieran mucho contenido. Recuerda que debes controlar
las excepciones que puedan aparecer. En caso de error, mostrar una
ventana de dialogo con información del error.
Solución
import java.io.*;
//Introducimos los datos

String rutaFichero1=JOptionPane.showInputDialog(“Indica
la ruta del primer fichero”);
String rutaFichero2=JOptionPane.showInputDialog(“Indica
la ruta del segundo fichero”);
String rutaDestino=JOptionPane.showInputDialog(“Indica
la ruta donde quieres guardarlo”);
//Creamos dos objetos File para que nos sea mas sen-
cillo manejarlos
File fichero1=new File(rutaFichero1);
File fichero2=new File(rutaFichero2);
//Troceamos el el nombre del primer fichero para que

se quede sin extension
String primerFichero=fichero1.getName().substring(0,
fichero1.getName().length()-4);

//Crear el nombre de salida del fichero
String nombreFicheroFinal=primerFichero+”_”+fichero2.
getName();
rutaDestino+=nombreFicheroFinal;
File destino=new File(rutaDestino);
UneFicheros(fichero1, fichero2, destino);
public static void UneFicheros (File fich1, File fich2,

File destino){
try (BufferedReader br=new BufferedReader(new

FileReader(fich1));
BufferedReader br2=new BufferedReader(new
FileReader(fich2))){
int eleccion=-1;
if(destino.exists()){
eleccion=JOptionPane.showConfirmDialog(null,
“El fichero ya existe, ¿Quieres sobrescribir el fichero “+des-
tino.getName()+”?”,
“Sobrescribir”,
JOptionPane.OK_CANCEL_OPTION, JOp-
tionPane.INFORMATION_MESSAGE);
}
if(eleccion!=JOptionPane.CANCEL_OPTION){
/*
* Lo creamos aquí, ya que si lo hacemos arriba
* siempre existira porque se crea al abrir
el Stream
*/
BufferedWriter bw=new BufferedWriter(new

FileWriter(destino));
//Copiamos el contenido al fichero destino

copiar(bw, br);
copiar(bw, br2);
}
JOptionPane.showMessageDialog(null, e.getMessage(),

“Error”, JOptionPane.ERROR_MESSAGE);
}
private static void copiar(BufferedWriter bw, Buff-

eredReader br) throws IOException{
String linea=br.readLine();
while(linea!=null){
bw.write(linea);
linea=br.readLine();
}
}
}
4. Crea una aplicación que copie un fichero binario a otra localización. En

lugar de leer y escribir byte a byte, crea un array de bytes con el tamaño
del fichero de origen (utiliza el método available()), copia el contenido del
fichero a este array y escribe a partir de este array.Recuerda que debes
controlar las excepciones que puedan aparecer. En caso de error, mos-
trar una ventana de dialogo con información del error.
Solución
import java.io.*;
//Pedimos las rutas

String origen=JOptionPane.showInputDialog(“Escribe
la ruta del origen”);
String destino=JOptionPane.showInputDialog(“Escribe
la ruta del destino”);
copiaFicheros(origen, destino);
}
public static void copiaFicheros (String origen, String
destino){
try(FileInputStream fis=new FileInputStream(origen);

FileOutputStream fos=new FileOutputStream(destino))
{

//Creamos un array de bytes con el tamaño del
fichero de origen
byte byteA[]=new byte[fis.available()];
//Copia todos los bytes del fichero al array

fis.read(byteA);
//Escribe todos los bytes en el fichero de

destino
fos.write(byteA);
JOptionPane.showMessageDialog(null, e.getMessage(),
“Error”, JOptionPane.ERROR_MESSAGE);
}
}
5. Crea una aplicación que pida por teclado un número de números alea-
torios enteros positivos y la ruta de un fichero. Este fichero contendrá la
cantidad de números aleatorios enteros positivos que se ha pedido por
teclado. Escribe los números usando un DataOutputStream y muestra
por pantalla estos números leyéndolos con un DataInputStream. El rango
de los números aleatorios estará entre 0 y 100, incluyendo el 100. Cada
vez que ejecutemos la aplicación añadiremos números al fichero sin
borrar los anteriores, es decir, si cuando creo el fichero añado 10 núme-
ros y después añado otros 10 al mismo, en el fichero habrá 20 números
que serán mostrados por pantalla.
Solución
import java.io.*;
String ruta=JOptionPane.showInputDialog(“Escribe la
ruta del fichero”);
String numeros=JOptionPane.showInputDialog(“Escribe
el numero de numeros aleatorios”);
int numNumerosAleatorios=Integer.parseInt(numeros);
//Abrimos el fichero desde el final

try(DataOutputStream dos=new DataOutputStream (new
FileOutputStream (ruta, true));
DataInputStream dis=new DataInputStream(new
FileInputStream (ruta))){

escribeFichero(dos, numNumerosAleatorios);
leeFichero(dis);
}catch(EOFException e){
System.out.println(“Fin del fichero”);
JOptionPane.showMessageDialog(null, “Error: “+e.
getMessage() , “Error”, JOptionPane.ERROR_MESSAGE);
}
}
public static void escribeFichero (DataOutputStream dos,
int numNumerosAleatorios) throws IOException{
//Escribimos los numeros
for (int i=0;i<numNumerosAleatorios;i++){

int numero=generaNumerosAleatorios();
dos.writeInt(numero);
}
//Guardamos los cambios

dos.flush();
}
public static void leeFichero (DataInputStream dis)
throws IOException{
//Leemos los numeros hasta el final del fichero

while(true){
System.out.println(dis.readInt());
}
}
public static int generaNumerosAleatorios(){

int numero=(int)Math.floor(Math.random()*101);
return numero;
}

6. Crea una aplicación que almacene los datos básicos de un vehículo
como la matricula(String), marca (String), tamaño de deposito (double)
y modelo (String) en ese orden y de uno en uno usando la clase DataIn-
putStream. Los datos anteriores datos se pedirán por teclado y se irán
añadiendo al fichero (no se sobrescriben los datos) cada vez que ejecu-
temos la aplicación. El fichero siempre sera el mismo, en todos los casos.
Muestra todos los datos de cada coche en un cuadro de dialogo, es decir,
si tenemos 3 vehículos mostrara 3 cuadros de dialogo con sus respecti-
vos datos. Un ejemplo de salida de información puede ser este:
Solución
import java.io.*;
final String RUTA=”D:\vehiculos.ddr”;
String matricula=JOptionPane.showInputDialog(“Introduce
la matricula”);
String marca=JOptionPane.showInputDialog(“Introduce
la marca”);
String texto=JOptionPane.showInputDialog(“Introduce
el tamaño del deposito”);
double tamañoDeposito=Double.parseDouble(texto);
String modelo=JOptionPane.showInputDialog(“Introduce
el modelo”);
try(DataOutputStream dos=new DataOutputStream(new

FileOutputStream(RUTA,true));
DataInputStream dis=new DataInputStream(new

FileInputStream(RUTA))){

introduceDatos(dos, matricula, marca, tamañoDe-
posito, modelo);
muestraDatos(dis);
}catch(EOFException e){
JOptionPane.showMessageDialog(null, “Error: “+e.

getMessage() , “Error”, JOptionPane.ERROR_MESSAGE);
public static void introduceDatos(DataOutputStream dos,
String matricula,
String marca,
double tamañoDeposito,
String modelo) throws

IOException{
dos.writeUTF(matricula);
dos.writeUTF(marca);
dos.writeDouble(tamañoDeposito);
dos.writeUTF(modelo);
public static void muestraDatos(DataInputStream dis)

throws IOException {
//Cuando se acabe el fichero saltara la excepcion
while(true){
JOptionPane.showMessageDialog(null, “El vehiculo

tiene una matricula “+dis.readUTF()+
“, su marca es “+dis.readUTF()+”, el tamaño del

deposito es de “+dis.readDouble()+” “ +

“litros y su modelo es “+dis.readUTF());
clase 8 En esta clase hemos visto manejo de archivos y extensiones, que nos permitió
conclusiones facilitar la tarea a la hora del procesamiento de datos para un determinado desa-
rrollo.
Trabajar con archivos, nos da la posibilidad de crear software más complejo, con
mayores prestaciones.
Obviamente esto no es todo, nos preparemos para la clase que viene, donde los
datos pueden provenir de distintas fuentes.
Espero les haya sido de utilidad y me acompañen en la clase 9.

clase 9 JDBC
introducción
Como dijimos antes, los datos pueden provenir de distintas fuentes, primero
vimos los cargados en forma manual, con características de volatilidad; luego
vimos la posibilidad de trabajarlos almacenados en archivos de texto o binarios.
En esta clase vamos a trabajar la posibilidad de obtener los datos desde una base
de datos.
Los invito a recorrer el mundo de JDBC.
clase 9
Concepto. Aplicaciones. Tipos.
tema 1
Java JDBC es una API Java para conectar y ejecutar una consulta a una base
de datos. API JDBC utiliza controladores JDBC para conectarse con la base de
datos.
Antes de JDBC, ODBC API era la API de base de datos para conectar y ejecutar
consultas a una base de datos. Sin embargo, la API de ODBC utiliza controlador
ODBC que está escrito en lenguaje C. Es por ello que Java ha definido su propia
API (API JDBC) que utiliza controladores JDBC (escrito en lenguaje Java).
API (interfaz de programación de aplicaciones) es un documento que contiene la

descripción de todas las características de un producto o software. Representa
las clases y las interfaces de programas de software que pueden para comuni-
carse entre sí. Una API puede estar creada para las aplicaciones, bibliotecas,
sistemas operativos, etc.

Driver JDBC
1) Controlador puente JDBC-ODBC
El controlador puente JDBC-ODBC utiliza controlador ODBC para conectarse a la

base de datos. El controlador puente JDBC-ODBC convierte método de llamadas
JDBC en las llamadas a funciones de ODBC.

2) Native-API driver
El driver nativo API utiliza las bibliotecas de cliente de la base de datos. El contro-
lador convierte método JDBC en llamadas nativas de la API de base de datos. No
está escrito completamente en Java.
3) El controlador de protocolo de red
El controlador de protocolo de red utiliza el middleware (servidor de aplicaciones)

que convierte llamadas JDBC directa o indirectamente en el protocolo de la base
de datos específica del proveedor. Está completamente escrito en Java.

4) Thin driver
Convierte llamadas JDBC en el protocolo de la base de datos específica del pro-
veedor. Es por eso que se conoce como controlador fino. Está completamente
escrito en lenguaje Java.

Cinco pasos para conectarse a una base de datos en Java
Hay 5 pasos para conectar cualquier aplicación java con la base de datos en
Java utilizando JDBC. Son los siguientes:
● Registrar la clase controlador
● Crear de la conexión
● Declarar el objeto de consulta
● Ejecutar consultas
● Cerrar de la conexión
Registrar la clase controlador
El método forName() de Class es usado para registrar el driver. Este método es

usado para cargar dinámicamente el driver.
La creación de la conexión
El método getConnection() de la clase DriverManager se usa para establecer la

conexión con la base de datos.

Declarar el objeto de consulta
El método createStatement() de la interfaz Connection se utiliza para crear la

declaración . El objeto es responsable para ejecutar consultas con la base de
datos.
Ejecutar la consulta
El método executeQuery() de la interfaz Statement se usa para hacer consultas
a la base de datos.. Este método retorna el objeto de ResultSet que nos permite
recuperar registros de la base de datos.
Cerrar la conexión
Con el cierre de conexión, el conjunto de resultados se cerrará automáticamente.

El método close() de la interfaz de conexión se utiliza para cerrar la conexión.

Ejemplo de conectividad con una base de datos Oracle
En el siguiente ejemplo, veremos los 5 pasos que mostramos anteriormente,

adaptado a una base de datos Oracle.

● Algo que debemos tener en cuenta para conectar una
aplicación Java con una base de datos Oracle, ojdbc14.
jar de cargarse previamente. Se puede descargar en
https://www.javatpoint.com/src/jdbc/ojdbc14.jar
● Para poder conectarse a MySql ver el enlace https://
Atención www.javatpoint.com/example-to-connect-to-the-mysql-
database
Especificaciones Importantes
Clase DriverManager
La clase DriverManager actúa como una interfaz entre el usua-

rio y los controladores. Realiza un seguimiento de los drivers
que están disponibles para establecer una conexión entre una
Atención base de datos y el controlador apropiado.
Los métodos de esta clase son:

● public static void registerDriver(Driver driver)
● public static void deregisterDriver(Driver driver)
● public static Connection getConnection(String url)
● public static Connection getConnection(String url,String userName,String
password)
Interfaz de Conexión
Una conexión es la sesión entre aplicaciones Java y base de datos. La interfaz

de conexión es una fábrica de Statement, PreparedStatement y DatabaseMeta-
Data es decir, un objeto de conexión se puede utilizar para obtener el objeto de la
declaración y DatabaseMetaData.
Los métodos más comunes son:

1) public Statement createStatement(): crea un objeto de decla-
ración que se puede utilizar para ejecutar consultas SQL.
2) public Statement createStatement(int resultSetType,int
resultSetConcurrency): Crea un objeto Statement que va a
generar objetos ResultSet con el tipo y la concurrencia dado.
3) public void setAutoCommit(boolean status): se uti-
liza para establecer el commit status.Por defecto es cierto.
4) public void commit(): guarda los cambios realiza-
dos desde la confirmación anterior / rollback permanente.
5) public void rollback(): deshace todos los cam-
bios realizados desde el último commit / rollback.
6) public void close(): cierra la conexión y libera una recursos JDBC inmedia-
tamente.

Interfaz de sentencia
Statement interface proporciona métodos para ejecutar consultas con la base

de datos. La interfaz de sentencia es una fábrica de ResultSet es decir, se propor-
ciona un método para obtener el objeto conjunto de resultados.
Los métodos que utiliza la interfaz son:
1) public ResultSet executeQuery(String sql): se utiliza para ejecutar la con-
sulta SELECT. Se devuelve el objeto de ResultSet
2) public int executeUpdate(String sql): se utiliza para ejecutar una query,
drop, insert, update, delete etc.
3) public boolean execute(String sql): se utiliza para ejecutar consultas que
pueden devolver varios resultados.
4) public int[] executeBatch(): se utiliza para ejecutar lote de comandos .
Estos son los aspectos más relevantes en lo que se refiere a la obtención de

datos a través de una base de datos.
Para que pueda ampliar la información de este tema con una serie
de ejemplos les facilito la siguiente webgrafía:
● https://www.adictosaltrabajo.com/tutoriales/tutorial-
basico-jdbc/
● https://www.tutorialspoint.com/jdbc/
clase 9
tema 2 Ejemplo JDBC
Java JDBC es una API Java para conectar y ejecutar una consulta a una base
de datos. API JDBC utiliza controladores JDBC para conectarse con la base de
datos.
Ahora vamos a ver dos ejemplos en MySql (recordar que en el tema anterior se
sugirió ver un enlace al respecto)

Pero vamos a ir en orden, primero repasamos los cinco pasos:
1. Incluir el jar con el Driver de la base de datos → Cada motor tiene el suyo,
descargar desde aquí http://dev.mysql.com/downloads/connector/j/#downloads
2. Cargar el driver
3. Establecer una conexión con la base de datos
4. Realizar una consulta

5. Cerrar la conexión
Ejemplo 1
Este primer ejemplo consiste en una aplicación que permite almacenar una nueva
cuenta en la base de datos siempre y cuando el código de la cuenta no esté ya en
la base de datos. En este ejemplo se usan PreparedStatements.
package ejemplo1;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.*;
import javax.swing.JLabel;
import org.apache.log4j.Logger;
public class CreaCuenta implements ActionListener {
private Logger log = Logger.getLogger(CreaCuenta.

class);
private Ventana v;
private Connection cn;
private PreparedStatement pstBuscarCodigo;
private PreparedStatement pstInsertarCuenta;
public CreaCuenta(Ventana v) {
this.v = v;
try {
// Driver para conectar con MySQL
Class.forName(“com.mysql.jdbc.Driver”);
// Conexión con la base de datos
cn = DriverManager.getConnection(“jdbc:mysql://
localhost:3306/cuentas”, “root”, “”);
String sqlBusqueda = “SELECT codigo FROM cuentas
WHERE codigo=?”;
pstBuscarCodigo = cn.prepareStatement(sqlBusqu
eda);
String sqlNuevaCuenta = “INSERT INTO cuentas
VALUES (?,?,?,?)”;
pstInsertarCuenta = cn.prepareStatement(sqlNuev
aCuenta);
} catch (SQLException ex) {

log.error(“Error “ + ex.getErrorCode() + “: “ +
ex.getMessage());
} catch (ClassNotFoundException ex) {
log.error(“No se encontro el Driver MySQL para
JDBC.”);

}
}
@Override
public void actionPerformed(ActionEvent e) {
String codigo = v.getTextCodigo().getText();

String nombre = v.getTextNombre().getText();
String email = v.getTextEmail().getText();
double saldo = (double) v.getTextSaldo().getVa-
lue();
JLabel lbMensaje = v.getLbMensaje();
try {
pstBuscarCodigo.setString(1, codigo);
// Si el codigo no esta en la bd se añade la
cuenta
ResultSet rs = pstBuscarCodigo.executeQuery();
if (!rs.next()) {
pstInsertarCuenta.setString(1, codigo);
pstInsertarCuenta.setString(2, nombre);
pstInsertarCuenta.setString(3, email);
pstInsertarCuenta.setDouble(4, saldo);
pstInsertarCuenta.executeUpdate();
lbMensaje.setText(“Cuenta agregada correc-
tamente”);
} else {
lbMensaje.setText(“El codigo indicado ya
esta en la base de datos”);
}
log.error(“Error “ + ex.getErrorCode() + “: “ +
ex.getMessage());
}
}
}
Ejemplo 2: La aplicación del segundo ejemplo sirve para hacer transferencias

entre las cuentas. Con este ejemplo vamos a aprovechar para ver como crear
transacciones y deshacerlas si falla alguna de las operaciones. En este ejemplo
se usan statement para ver lo tedioso que puede ser.

package ejemplo2;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;
import org.apache.log4j.Logger;
public class Transferir implements ActionListener {
private Logger log = Logger.getLogger(Transferir.class);
private Transferencias t;
public Transferir(Transferencias t) {
this.t = t;
}
@Override
public void actionPerformed(ActionEvent e) {
Connection cn = null;
try {
// Driver para conectar con MySQL
Class.forName(“com.mysql.jdbc.Driver”);
cn = DriverManager.getConnection(“jdbc:mysql://
localhost:3306/cuentas”, “root”, “”);
// Obtenemos la fecha actual

Date date = new Date();
Date fecha = new java.sql.Date(date.getTime());
String sqlCuenta1 = “UPDATE cuentas SET saldo = saldo - “
+ t.getTfCantidad().getValue()
+ “ WHERE codigo = ‘” + t.getTfCuenta1().getText()
+ “’ AND saldo >= “ + t.getTfCantidad().getValue();
String sqlMovimiento1 = “INSERT INTO movimientos SET codigo = ‘”
+ t.getTfCuenta1().get-
Text() + “’, tipo = ‘1’, cantidad= 0-”
+ t.getTfCantidad().
getValue() + “, fecha= ‘” + fecha + “’”;
String sqlCuenta2 = “UPDATE cuentas SET saldo = saldo + “
+ t.getTfCantidad().getValue() +
“ WHERE codigo = ‘” + t.getTfCuenta2().getText() + “’”;
String sqlMovimiento2 = “INSERT INTO movimientos SET codigo = ‘”
+ t.getTfCuenta2().getText() + “’, tipo = ‘1’, cantidad= “
+ t.getTfCantidad().
getValue() + “, fecha= ‘” + fecha + “’”;
Statement st = cn.createStatement();
// Indica que las operaciones no se validan automaticamente
cn.setAutoCommit(false);
// Si se hacen ambas actualizacio-
nes se hace la transaccion y sino se deshace
if ((st.executeUpdate(sqlCuenta1)
!= 0) && (st.executeUpdate(sqlCuenta2) != 0)
&&(st.executeUpdate(sqlMovimiento1)

!= 0) && (st.executeUpdate(sqlMovimiento2) != 0)) {
// Ejecuta la
transaccion
cn.commit();
t.setLbResultado(“Transeferencia completada.”);
} else {
// Deshace los cambios hechos dentro de la transaccion
cn.rollback();
t.setLbResultado(“Error:
La transeferencia no se ha completado.”);
}

log.error(“Error “ + ex.getErrorCode() + “: “ + ex.getMessage());
try {
// Deshace los cambios hechos dentro de la transaccion
cn.rollback();
t.setLbResultado(“Error:
La transeferencia no se ha completado.”);
} catch (SQLException ex1) {
log.error(“Error “ + ex1.getE-
rrorCode() + “: “ + ex1.getMessage());
}
} catch (ClassNotFoundException ex) {
log.error(“No se encontro el Driver MySQL para JDBC.”);
} finally {
try {
cn.close();
log.error(“Error “ +
ex.getErrorCode() + “: “ + ex.getMessage());
}
}
}
}
La siguiente es una actividad guiada, por lo cual siguiendo los

Actividad
pasos debería lograr una aplicación con conexión a una base de
datos.
No tendrá clave de corrección pues la actividad le va mostrando
el paso a paso.
Esta actividad es parte del Examen Final de la materia. Para poder rendir
el mismo, usted deberá completar esta actividad y subir su proyecto e
indicaciones a la plataforma.

Pasos Generales para preparar una Aplicación Java para acceder a una
Base de Datos
1. Cargar el controlador de la base de datos → El controlador define el tipo de

base de datos en nuestro caso, tendremos que indicar el controlador para base
de datos de Access.
2. Crear un objeto conexión (Connection) → Para crear este objeto hay que
indicar la situación del fichero de base de datos, el usuario y la contraseña de
dicha base de datos. El objeto conexión abre el fichero de la base de datos.
3. Crear un objeto sentencia (Statement) → El objeto sentencia se crea a

partir del objeto conexión anterior. Los objetos sentencia permiten realizar accio-
nes sobre la base de datos usando instrucciones SQL.
PREPARANDO NETBEANS
En este ejercicio se pide crear una pequeña aplicación de bases de datos que
permita mostrar los datos de los trabajadores almacenados en la base de datos
BBDD. Para ello vamoa seguir los siguientes pasos:
1. Entre en NetBeans. Cree un nuevo proyecto llamado AccesoBD. Dentro

de este proyecto crea un paquete principal llamado paqueteprincipal y
dentro de él un JFrame llamado ventanaprincipal
2. En la parte superior de la ventana añade un botón con el texto Ver Datos Tra-
bajadores que se llame btnVerDatos.
3. Al pulsar el botón btnVerDatos debería aparecer JOptionPane datos sobre los

trabajadores almacenados en la base de datos.

Los invito a ver los siguientes audiovisuales ilustrativos de la
situación de conexión:
● https://www.youtube.com/watch?v=Nt9gfoM7UJQ
● https://www.youtube.com/watch?v=nbAYB6HyTQI

LA BASE DE DATOS
1. Introducir el fichero de base de datos en la carpeta del proyecto java

que estamos haciendo. Para ello, accede a la carpeta del proyecto
AccesoBD.
2. Ingresar a la carpeta y verá:
3. Crearemos una carpeta llamada Base dentro de la carpeta de proyecto, para

que quede así:
4. Ahora lo único que tiene que hacer es copiar el archivo de base de datos
BBDD.MDB que se encuentra en Mis Documentos dentro de la carpeta Base.
(debe crear una base de datos en Access con ese nombre para poder trabajar en
este proyecto)

5. Así contamos con el archivo de base de datos creado con Access guardado
dentro de la misma carpeta de proyecto java que usará dicha base de datos. Lo
anteriormente explicado es una tarea recomendable en el caso de que debe tra-
bajar con Java y bases de datos.
6. Volvemos a NetBeans.
PREPARACIÓN DE LA APLICACIÓN JAVA PARA EL ACCESO A LA BASE DE

DATOS
1. Para poder acceder y manipular una base de datos, es necesario tener

dos objetos:
a. Un objeto del tipo Connection, al que llamaremos conexion.
Este objeto define la conexión con la base de datos.
b. Un objeto del tipo Statement, al que llamaremos sentencia.
Este objeto permite manipular la base de datos.
2. Lo primero que haremos será definir estos objetos como globales en la
clase de la ventana principal, para así poderlos usar desde cualquier
lado:
3. Preparar nuestro programa para que pueda acceder a la base de datos

BBDD.MDB. Esto se hará en el constructor. Añadir al constructor una llamada a
una función PrepararBaseDatos:

4. Crear el método PrepararBaseDatos debajo del constructor y empieza a codi-
ficar lo siguiente:
5. Añadir el siguiente código a continuación del anterior:
De esta manera tenemos el programa listo para acceder a la base de datos.
REALIZAR CONSULTAS SQL USANDO EL OBJETO SENTENCIA
1. Al pulsar el botón Ver Datos de Trabajadores tendremos que extraer

los datos de la tabla trabajadores para poder mostrarlos. Por lo cual,
escribe el siguiente código dentro del evento actionPerformed del botón
btnVerDatos:

RESULTSET
Cuando se realiza una consulta a una base, la idea es que devuelva un conjunto
de valores solicitados, en este caso usando select * from trabajadores
order by nombre, debería traer el conjunto de trabajadores ordenados en
forma alfabética.
Por lo cual el objeto ResultSet r, trae ese resultado.
Si agregamos este código:
El resultado será:

Estamos situados en la posición del primer trabajador (Ana), podemos extraer
información referente a sus campos. Añade el siguiente código al actionPerfor-
med del botón:
Al ejecutar el programa:
CONCLUSIÓN
Para crear un programa Java que pueda usar una base de datos será necesario
realizar los siguientes pasos:
1. Copiar el archivo de base de datos en una subcarpeta de la carpeta del

proyecto java.
2. Preparar el acceso a la base de datos (en el constructor)
a. Crear dos objetos: conexión (Connection) y sentencia (State-
ment)
b. Cargar el controlador del tipo de base de datos a usar
c. Crear el objeto conexión indicando el fichero de la base de datos.
d. Crear el objeto sentencia a partir del objeto conexión

3. Usar el objeto sentencia para ejecutar consultas SQL en la base de datos.
4. Las consultas SQL ejecutadas en la base de datos se almacenan en
objetos del tipo ResultSet
5. Un objeto ResultSet tiene forma de tabla conteniendo el resultado de la
consulta SQL
a. Los objetos ResultSet tienen métodos para seleccionar el regis-
tro de la tabla
b. Los objetos ResultSet tienen métodos que permiten extraer el
dato de un campo en concreto.
Para que pueda ampliar la información de este tema con una serie
de ejemplos les facilito la siguiente webgrafía:
● https://www.adictosaltrabajo.com/tutoriales/tutorial-
basico-jdbc/
● https://www.tutorialspoint.com/jdbc/
clase 9 En esta oportunidad, no contamos con clave de corrección, pues todas las prác-
claves de corrección ticas y actividades están resueltas dentro de la clase.
Tenga presente que una actividad como la planteada en el tema 2 de esta

clase, formará parte del examen final.
clase 9
conclusiones Hemos visto a manera de introducción, el tratamiento de datos a través de bases
de datos JDBC.
Esto no se agota aquí, los invito a continuar profundizando el tema, investigando,

probando, explorando más posibilidades. Espero que esto les haya servido como
puntapié inicial al mundo de las bases de datos.

clase 10 SWING
introducción
La interacción persona-ordenador, viene dada por un artefacto que permite la
relación amigable con el sistema informático. La interfaz gráfica de usuario (en
inglés Graphical User Interface, GUI) utiliza un conjunto de imágenes y objetos
gráficos (iconos, ventanas, tipografía) para representar la información y acciones
disponibles en la interfaz. En esta clase comentaremos las algunas de las herra-
mientas que se pueden utilizar para desarrollarlas como el paquete Java Swing.
Empecemos.
clase 10
Conceptos y Ejemplos
tema 1
Para comenzar veamos la siguiente imagen
Este es un símbolo que nos tiene que guiar a la hora de hacer Interfaces Gráficas
de Usuario (IGUs de ahora en más).
Ahora nos vamos a concentrar en todo lo necesario en Java para lograr un IGU
apropiada para nuestro desarrollo.
Swing es una biblioteca de interfaces gráficas de usuario (GUI)
para Java. Incluida con el entorno de desarrollo de Java (JDK).
Es una extensión de otra librería gráfica más antigua llamada
Atención AWT. Los paquetes que utiliza son:
Ahora vamos a ir parte por parte describiendo cada una de ellas.
Ventanas
Para poder hacer ventanas usamos la clase JFrame. Posee los constructores:
JFrame() y JFrame(String titulo)
Una vez creado el objeto de ventana, debemos establecer su tamaño, la acción
de cierre y visualizarla.

Vemos aquí un fragmento de código que ilustra lo antedicho:
Si nosotros quisiéramos cerrar la ventana, tendríamos que recurrir a:
● JFrame.EXIT_ON_CLOSE: Abandona aplicación

● JFrame.DISPOSE_ON_CLOSE: Libera los recursos asociados a la ven-
tana.
● JFrame.DO_NOTHING_ON_CLOSE: No hace nada.
● JFrame.HIDE_ON_CLOSE: Cierra la ventana, sin liberar sus recursos.
Se verá algo así:

Se puede extender la clase JFrame, y realizar las operaciones de inicialización en
su constructor. El código sería de esta manera:
Componentes
Los componentes son aquellas piezas de la IGU que hacen posible la existencia
de botones, rótulos, cajas de texto entre otras cosas.
Al crear uno de estos componentes con new, ha de añadirse al contentPane de

la ventana correspondiente mediante su método add.

El código sería:
La salida sería algo así:
Layout Managers
En Java no es habitual indicar explícitamente la posición de los componentes

de la interfaz dentro de la ventana. Los layout managers permiten de colocar los
componentes de la interfaz de usuario en la ventana contenedora. Podemos con
ellos especificar la posición y el tamaño de componentes.
Algunas de las cuestiones que podemos administrar:
● FlowLayout
● GridLayout
● BorderLayout
● GridBagLayout, entre otras.

FlowLayout
Podemos colocar los elementos uno a continuación de otro, usando los métodos:
GridLayout
También podemos colocar todo en forma de grilla, usando el constructor y sus

métodos:
Constructor:
● GridLayout(int filas, int columnas)
Métodos:
● setHgap(int separacion)
● setVgap(int separacion)
El código de la situación sería:

Quedará algo así:
BorderLayout
Si queremos poner o cambiar el tamaños de algunos componentes para se que

se ajusten a los bordes y parte central de la ventana, tenemos la posibilidad de
hacerlo usando BorderLayout.
Los métodos utilizados:

Interfaces complejas: JPanel
Empecemos por ver una:
Veamos un fragmento del código que hace la interfaz anterior:

Manejo de eventos
Un evento es un suceso que se da como consecuencia de la interacción del usua-

rio con la interfaz gráfica. Por ejemplo:
● Pulsación de un botón.
● Cambio del contenido en un cuadro de texto.
● Deslizamiento de una barra.
● Activación de un JCheckBox.
● Movimiento de la ventana.
Vamos a explayarnos en la pulsación de botón. La clase JButton tiene un método,
void addActionListener(ActionListener l)
Cuando el usuario pulse el botón, se llamará al método actionPerformed de todos

los manejadores de eventos que se hayan registrado.
Los métodos de ActionEvent son:
● public Object getSource()
● public int getModifiers()

Cuadros de diálogos definidos
La clase JOptionPane proporciona métodos de utilidad para mostrar ventanas

de aviso y de confirmación estándar.
Veamos algunas:
La clase JOptionPane proporciona métodos de utilidad para mostrar ventanas de

aviso y de confirmación estándar, por ejemplo:
int showConfirmDialog(Component padre,Object mensaje, String titulo, int
tipoOpciones, int tipoMensaje)

Dibujo de gráficos
Supongamos que queremos obtener esto:
Contamos con métodos que nos permiten lograrlo. Cada componente tiene un
método llamado paintComponent, que se encarga de pintarlo en pantalla.
Para realizar un dibujo solo con heredar de un componente (normalmente un JPanel),
y sobreescribir su método paintComponent → void paintComponent(Graphics
g)
Los métodos son los siguientes:
● void drawPolygon(int[] x, int[] y, int puntos)
● void drawRect(int x, int y, int ancho, int alto)
● void fillRect(int x, int y,int ancho, int alto)
● void drawOval(int x, int y,int ancho, int alto)
● void fillOval(int x, int y,int ancho, int alto)
● void drawString(String cad, int x, int y)
● void setColor(Color c)
● void setFont(Font f)

Veamos el código destinado a dibujar el sol:
Obviamente hay muchas más posibilidades, les facilito unos enla-

ces que les ampliará un poco lo básico dado hasta el momento.
● https://www.youtube.com/watch?v=HrEiL-2cokw

● https://www.youtube.com/watch?v=AY_RNiaFDzk
● https://www.youtube.com/watch?v=uxM30tdwIzg
● https://www.youtube.com/watch?v=7XQKvL9WKls

● https://www.youtube.com/watch?v=SLyosEYr4JQ
clase 10 Practicando
tema 2
Les recomiendo realizar las siguientes prácticas para lograr buenas inter-
faces. En el Examen Final deberán presentar sus desarrollos usando al
menos 5 IGUs.
Actividad 1) Crea un saludador personalizable. Consiste en un simple

JFrame con un campo de texto (JTextField) y un botón (JButton).
Cuando pulsemos el botón, aparecerá un mensaje emergente
(JOptionPane) con el texto “¡Hola <texto escrito en el campo de
texto>!”.

2) Crea una simple lista de peliculas. tendremos un JComboBox, donde alma-
cenaremos las peliculas, que vayamos almacenando en un campo de texto. Al
pulsar el botón Añadir la pelicula que hayamos metido, se introducirá en el JCom-
boBox.
3) Crea una mini encuesta gráfica. Daremos una serie de opciones para que el
usuario elija. La encuesta preguntará lo siguiente:
● Elige un sistema operativo (solo una opción, JRadioButton)
○ Windows
○ Linux
○ Mac
● Elige tu especialidad (pueden seleccionar ninguna o varias opciones,
JCheckBox)
○ Programación
○ Diseño gráfico
○ Administración
● Horas dedicadas en el ordenador (usaremos un slider entre 0 y 10)
Para el slider, les recomiendo usar un JLabel, que les diga qué valor tiene el
slider, usad el evento stateChanged.

4) Crea un generador de números gráfico. Nosotros escribiremos seleccionare-
mos dos números en unos JSpinner (contadores) y se nos mostrara en un JText-
Field, el número generado entre esos dos números, al pulsar en el botón. El
JTextField no debe ser editable.

5) Vamos a crear un imitador, como si fuera un espejo. Tendremos dos pares de
conjunto de elementos separados (puedes usar un separador) y cuando nosotros
pinchamos en un elemento o escribimos en un campo, se debe cambiar el otro
lado.
Por ejemplo, si yo tengo un campo de texto y escribo en él, el campo de texto que
es su reflejo también recibirá ese texto.
Puedes usar los elementos que quieras, les recomiendo: JTextField, JRadioBut-
ton, JCheckBox, JTextArea, JSpinner, etc.
Solo puedes modificar de un lado, el otro conjunto no lo puedes modificar, es
decir, que no es bidireccional.

Obviamente hay muchas más posibilidades, les facilito unos enla-
ces que les ampliará un poco lo básico dado hasta el momento.
● https://www.youtube.com/watch?v=HrEiL-2cokw
● https://www.youtube.com/watch?v=AY_RNiaFDzk
● https://www.youtube.com/watch?v=uxM30tdwIzg
● https://www.youtube.com/watch?v=7XQKvL9WKls
● https://www.youtube.com/watch?v=SLyosEYr4JQ
clase 10
Los enlaces los podrá descargar desde la plataforma
1)
Solución 1 → Pincha aquí para descargar el proyecto. Impórtalo en tu Net-
Beans.
2)
Beans.
3)
Beans.
4)
Beans.
5)
Solución 5 → Pincha aquí para descargar el proyecto. Impórtalo en tu
NetBeans.
clase 10 Lo importante de las interfaces gráficas, es la sencillez y practicidad. El lema

conclusiones “menos es más” debe aplicarse en todos los ámbitos, inclusive en el desarrollo
de software, esto hace que el usuario acceda a los datos de una aplicación rápi-
damente y pueda a su vez dar respuestas a sus requerimientos. Espero que esta
clase haya sido de utilidad. Nos vemos en la próxima.

clase 11 SERVLETS. CONCEPTOS Y EJEMPLOS.
introducción
Como todo en este materia es gradual, hemos programado con datos volátiles,
luego usamos archivos, pasamos a conexiones con bases de datos. Como no
nos conformamos con interfaces de consola, hicimos interfaces gráficas. ¿Qué
tal si ahora trabajamos para conectar con servidores?
En esta parte de la materia, nos iniciaremos en el mundo de los que nos permi-
tirán hacer desarrollos para conectar a diferentes servidores web o no. Acompá-
ñenme y veamos juntos de que se trata este tema.
clase 11
Conceptos y Ejemplos.
tema 1
¿Qué son los servlets?
Los Servlets son módulos escritos en Java. Se utilizan en un

servidor, que puede ser o no ser servidor web, para extender su
capacidad de respuesta a los clientes al utilizar las potenciali-
Atención dades de Java.
Los Servlets no tienen una interfaz gráfica. Estos pueden incluirse en servidores
que soporten la API de Servlet. Por ejemplo, un servlet podría ser responsable
del procesamiento de datos desde un formulario en HTML, registrar la transac-
ción, actualizar una base de datos, contactar algún sistema remoto y retornar un
documento dinámico o redirigir a otro servlet u alguna otra cosa.
¿Cuándo utilizamos Servlets?
● Cuando tenemos una página web basada en datos que proporciona el

usuario, como es el caso de e-commerce sites.
● Cuando los datos cambian muy a menudo por ejemplo, los partes meteo-
rológicos.
● Cuando la página web que usamos utiliza información de BDs u otras
fuentes, como las aplicaciones comerciales.

Para graficar el funcionamiento veamos la imagen:
Como podemos ver en la imagen, el usuario hace una petición al servidor vía
su aplicación, el server se conecta con su serlet, provee la página solicitada, la
devuelve al servidor y el usuario lo solicitado.
Para poder lograr esto se deben cumplir algunos requisitos:
● El servidor debe:
○ Contar con una máquina virtual Java.
○ Soportar la API de los servlets Java.
■ Servidores capaces de ejecutar servlets:
● Apache Tomcat
● Java Web Server
● O’Reilly WebSite Professional
● Lotus Domino Go WebServer
● Novell IntraNetWare
● IBM Internet Connection Server – Otros
Veamos cómo se hace en NetBeans 8.2
Sin ahondar en detalles, les mostraré paso a paso como generar un SERVLET
sencillo, queda en ustedes profundizar en función de las necesidades de sus
desarrollos.
1. El primer paso es generar un nuevo proyecto, File-->New Project

2. En la sección de categorías seleccionamos “Java Web” y en la sección de
proyectos seleccionamos “Web Application”.
3. Se nombra el proyecto, en este ejemplo: “JavaServlet”

4. A continuación se configura el servidor web en el que se ejecutará el ser-
vlet. En este ejemplo se usa GlassFish.
5. Pulsamos el botón Finish. Se obtiene el proyecto con la siguiente estruc-

tura:
6. Se observa que se ha creado un archivo llamado “index.html”. En este

archivo se agregará un formulario que será el encargado de invocar el
servlet.

7. En la siguiente figura se indica con un recuadro rojo la definición del for-
mulario. En el atributo action se indica que se llamará Servlet. Se crea
el servlet de la siguiente manera: click derecho sobre el proyecto, opción
New, Servlet:
8. Definimos un nombre para el servlet (en este ejemplo le llamaremos Ser-

vlet, ya que fue el que definimos en el atributo action del formulario), pul-
samos el botón finish. Se crea un archivo llamado Servlet.java

9. Agregamos el código que aparece en el recuadro rojo, que se encarga de
generar una página html.
10. Finalmente pulsamos el botón Run que aparece en la parte superior para
ejecutar el servlet.
11. Aparecerá:
Ahora es el momento que usted pruebe hacer el propio.
Para ver otros ejemplos les facilito los siguientes enlaces a audio-
visuales sobre Servlet y sus aplicaciones:
● https://www.youtube.com/watch?v=CZzyi_0ImwI

● https://www.youtube.com/watch?v=YUO0NoAMOlg
clase 11
tema 2
Prácticas
Lo ideal antes de comenzar a practicar es “precalentar”. Para

ello le sugiero que relea el tema anterior y le facilito este enlace
con un resumen para el armado de un Servlet (incluye ejemplo
con código fuente) http://bedford-computing.co.uk/learning/wp-
Atención
content/uploads/2016/03/Java-Servlet-Tutorial.pdf

Actividad 1: Informe de Asignatura
En este servlet, se muestra una página HTML con las distintas

Actividad asignaturas que hay en la tabla Asignatura de la base de datos.
La consulta SQL sería:
SELECT nombre,tipo,cuatrimestre,
creditosPracticos, creditosTeoricos
FROM asignatura;
Los métodos a usar:
● cabeceraHTML: Este método escribe la cabecera.
● doGet: se encargará de conectarse a la base de datos
extraer los datos y mostrar el informe
● doPost: Hace una rellamada a doGet.
● init: default
● pieHTML: Escribe el pie de la página.
● tablaAsignaturas: Escribe una tabla HTML a partir del
conjunto de resultados de una consulta
● tituloHTML: Escribe el título de la página HTML aunque
también sirve para mostrar un posible error de la BD.
Debería quedar así:
Actividad 2: Informe de matrícula
Aquí implementamos el informe Matriculas, el cual muestra una

Actividad página HTML donde, para cada alumno, nos muestre las matrícu-
las realizadas y los pagos de la misma. La consulta SQL utilizada
ha sido:

SELECT matricula.idmatricula, tipo, numeroplazos, fechaex-
pedicion, curso,
cantidad, abonado, fechapago,
persona.nombre, persona.apellido1, persona.apellido2
FROM pago, matricula, persona
WHERE (pago.idmatricula=matricula.idmatricula) and
(matricula.idalumno=persona.pid);
Usamos los mismos métodos que en el ejercicio anterior, pero la tabla es tabla-
Matriculas. El método tablaMatriculas muestra el resultado de la consulta reali-
zada.
La salida por pantalla será:
Actividad 3: Formulario Persona
Implementamos el formulario Persona, el cual crea un formula-

Actividad rio HTML donde nos mostrará las personas que hay dentro de
nuestra base de datos, habiendo un botón de anterior y otro de
siguiente para poder ir visualizando los distintos registros de la
tabla persona. También nos permite modificar y borrar el registro
visualizado, así como añadir uno nuevo.
En este ejemplo se tienen los mismo métodos que en el informe Asignaturas, y

se agregan:
muestraFormulario: Escribe una tabla HTML con un formulario que muestra la

tupla en memoria, para consultar/crear/introducir/modificar los datos de la tabla
Persona
barraHerramientas: Añade a la página la barra de herramientas.
barraHerramientasNuevo Añade a la página la barra de herramientas cuando se
va a añadir un nuevo registro, sólo hay dos acciones Crear y Cancelar.
cogeParametros: Recoge los parámetro que recibe el servlet desde el formulario
HTML.
cogeRegistro: Se obtiene de la base de datos mediante una consulta el registro
que se quiere mostrar en el formulario HTML
doGet: Se encargará de conectarse a la base de datos, mostrar el formulario e
interpretar la acción a ejecutar.

Lo veremos así:
La Actividad 3 es base de preguntas de la Evaluación Parcial

2, por lo que se aconseja prestar atención en esta actividad.
Atención
clase 11
claves de corrección Prácticas
Descargue desde la plataforma los archivos con las soluciones
Actividad 1: Informe de Asignatura

Solución 1 → Hacer click aquí para obtener el programa fuente 01
Actividad 2: Informe de matrícula

Actividad 3: Formulario Persona

Cuando trabajamos nos conectamos a servidores, tenemos mayores posibilida-

clase 11 des de acción, nuestro desarrollo tiene acceso (si el administrador lo permite) a
conclusiones recursos que mejoran la performance de nuestra aplicación.
Espero que lo visto aquí haya sido de utilidad.

J2EE
clase 12
introducción Hemos llegado al final de la materia, vimos cómo desarrollar una solución compu-
tacional a problemas específicos, desde un programa sencillo, hasta la utilización
de Servlets.
En esta última clase, los voy a introducir al mundo J2EE, a las aplicaciones
empresariales escalable.
Es un tema que no se agota en un par de páginas, solo les dejo la información, la

inquietud por ahondar más.
Recuerden que un buen desarrollador, no se queda con la primera opción, busca

alternativas, investiga y avanza a la medida de las circunstancias que convocan
sus servicios.
clase 12
¿Qué es J2EE?
tema 1
Las aplicaciones web J2EE y los webservices son parte de las aplicaciones web
orientadas al negocio (Oracle BPM y ADF). J2EE (Java 2 Enterprise Edition), es
una plataforma para el desarrollo y la implementación de aplicaciones empresa-
riales multinivel. Esta plataforma se apoya en el lenguaje Java y proporciona:
● Componentes Web :
○ Tales como Servlets (Componente web dinámico)
○ JSP (Java ServerPages: Creación de páginas web dinámicas).
● Componentes Activos:
○ EJB (Enterprise Java Beans : Manejo de persistencia y transac-
ción).
● Servicios:
○ JDBC
○ JTA
○ JNDI
○ JMS
○ JavaMail
○ XML
¿Cuál es la arquitectura de esta plataforma?
En las aplicaciones web, la comunicación entre el cliente y el servidor se esta-

blece mediante el protocolo TCP/IP que se encarga del enrutamiento de infor-
mación entre los sitios (el tránsito de la información se realiza según el protocolo
HTTP).
J2EE está sujeta a la arquitectura cliente-servidor y al patrón de diseño MVC
(Modelo vista controlador) en la cual tenemos:
● una petición (request) realizada por el cliente
● una respuesta (response) dada por el servidor.

- El patrón de diseño MVC permite separar la presentación
(JSP) y la lógica del negocio (Servlet).
-Un Servlet es una clase Java que se encarga de obtener una

solicitud del cliente y retornar la respuesta
Atención
-Una página JSP es una página HTML que contiene fragmentos
de código Java (por tal motivo es una página dinámica).
¿Qué es una aplicación web?
Una aplicación web es un conjunto de recursos web. Consta de Servlets, JSP,

biblioteca de clases java utilitarias, elementos web estáticos (HTML, imágenes,
videos y sonidos) y elementos de cliente dinámicos (JavaBeans y clases).
Las aplicaciones web tienen de un descriptor llamado web.xml que define las
relaciones entre las URL y los Servlets/JSPs, directivas de seguridad, definicio-
nes de los recursos de acceso a la base de datos, EJBs, entre otros (este archivo
esta contenido dentro del WEB-INF).
A continuación veremos cómo desarrollar una aplicación web sencilla usando

todo lo visto hasta el momento.
Ejemplo 1
La aplicación de demostración gestiona una página básica de libro de visitas.

Cada visitante puede firmar el libro de visitas rellenando un sencillo formulario.
La IGU final sería:
Software necesario
Para este tutorial, necesitará el siguiente software:
● Java JDK 6.0 (O superior).

● NetBeans 7.0 (O superior)
● La última versión de ObjectDB (Descargar: Disponible en: https://www.
objectdb.com/download)

Para ello vamos a seguir los siguientes pasos:
Comencemos
Comenzamos por crear un nuevo proyecto de aplicación Web Java EE 6 en Net-

Beans:
● Abrir [New Project] mediante el uso File > New Project…
● Seleccionar Java Web > Web Application y haga clic Next.
● Elija un nombre de proyecto (e.g. Guestbook) y haga clic Next.
● Seleccionar GlassFish Server 3 (O superior) y Java EE 6 Web y haga
clic Next.
● Haga clic en el Finish para crear el proyecto (Frameworks no son nece-
sarios ).
Para añadir soporte ObjectDB / APP para el proyecto:

● Right click la carpeta Bibliotecas en [Projects] y seleccione Add
Jar/Folder...
● Seleccione el archivo objectdb.jar desde la carpeta bin del directo-
rio de instalación y haga clic con ObjectDB Open.

Ahora usted debería tener un proyecto de aplicación Web 6 NetBeans Java EE
con el apoyo ObjectDB / APP.
Para almacenar objetos en una base de datos utilizando

JPA ObjectDB tenemos que definir una clase de entidad:
● Abre el [New Entity Class]

● ( en la ventana[Projects]) y seleccione New > Entity Class... (or
New > Other... > Persistence > Entity Class y haciendo clic Next).
● Ingresar Guest como el nombre de la clase.
● Ingresar guest como el nombre del paquete
● Click Next para crear la nueva clase de entidad.

En el paso [Provider and Database] simplemente haga click Finish para generar
un archivo predeterminado persistence.xml Si el botón Finish está desactivado
llenar los campos con valores arbitrarios para habilitarlo.
Una nueva clase de entidad que debe representar Guest en la base de datos fue
creada en el proyecto ( debajo Source Packages > guest).
Utilizar copiar y pegar para reemplazar el nuevo contenido del archivo fuente con
el siguiente código:
package guest;
import java.io.Serializable;
import java.sql.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@ E n t i t y
public class Guest implements Serializable {
private static final long serialVersionUID = 1L;
// Persistent Fields:
@Id @GeneratedValue
Long id;
private String name;
private Date signingDate;
// Constructors:
public Guest() {
}
public Guest(String name) {

this.name = name;
this.signingDate = new Date(System.currentTimeMillis());
}
// String Representation:
@Override
public String toString() {
return name + “ (signed on “ + signingDate + “)”;
}
}
A default JPA persistence unit (with default settings) was generated in a persis-
tence.xml file that was added to the project (under Configuration Files).
Open the persistence.xml file in a text editor (by right clicking and selecting Edit or
by double click and then moving to the Source or XML tab in the editor window).
Use copy and paste to replace the default content of the persistence.xml file with
the following new content:
<?xml version=”1.0” encoding=”UTF-8”?>

<persistence version=”2.0” xmlns=”http://
j a v a . s u n . c o m / x m l / n s / p e r s i s t e n c e ”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/per-
s i s t e n c e / p e r s i s t e n c e _ 2 _ 0 . x s d ” >
<persistence-unit name=”GuestbookPU” transaction-type=”JTA”>

<provider>com.objectdb.jpa.Provider</provider>
<properties>
<property name=”javax.persistence.
jdbc.url” value=”$objectdb/db/guests.odb”/>
<property name=”javax.persistence.jdbc.user” value=”admin”/>
<property name=”javax.persis-
tence.jdbc.password” value=”admin”/>
</properties>
</persistence-unit>
</persistence>

Las operaciones en la base de datos se llevarán a cabo por una instancia de una
clase bean de sesión (EJB) que definiremos en este paso:
● Abrir [New Session Bean] haciendo clic derecho en el nodo del
paquete guest (en la ventana [Projects]), seleccionando New >
Other... > Java EE (o Enterprise JavaBeans) > Session Bean y
haciendo clic Next.
● Ingresar GuestDao como nombre de la clase EJB - usar exacto.
● El nombre del paquete de Java debe ser guest.
● Click Finish para crear el nuevo bean-session (EJB).
Ahora reemplace el contenido del nuevo archivo fuente con el siguiente código:
package guest;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
@ S t a t e l e s s
public class GuestDao {
// Injected database connection:
@PersistenceContext private EntityManager em;

// Stores a new guest:
public void persist(Guest guest) {
em.persist(guest);
}
// Retrieves all the guests:

public List<Guest> getAllGuests() {
TypedQuery<Guest> query = em.createQuery(
“SELECT g FROM Guest g ORDER BY g.id”, Guest.class);
return query.getResultList();
}
}
En este paso vamos a añadir un servlet para gestionar las solicitudes libro de
visitas web:
● Abrir [New Servlet] haciendo click derecho en el paquete guest

● Seleccionar New > Servlet...
● Ingresar GuestServlet como class name
● El nombre del paquete podría ser guest.
● Click Finish.

Reemplazar el código, por el siguiente:
package guest;
import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(name=”GuestServlet”, urlPatterns={“/guest”})
public class GuestServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
// Injected DAO EJB:

@EJB GuestDao guestDao;
@Override
protected void doGet(
HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Display the list of guests:

request.setAttribute(“guests”, guestDao.getAllGuests());
request.getRequestDispatcher(“/
guest.jsp”).forward(request, response);
}
@Override
protected void doPost(
HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Handle a new guest:

String name = request.getParameter(“name”);
if (name != null)
guestDao.persist(new Guest(name));
// Display the list of guests:

doGet(request, response);

}
}
En este paso vamos a añadir el JSP que genera el resultado de la página libro
de visitas:
● Abrir [New JSP File] hacer clic derecho en el nodo Web Pages
● ( en la ventana [Projects] and selecting New > JSP...
● Enter guest as the jsp file name - use exactly that case sensitive
class name.
● Click Finish to create the new JSP file
Ahora reemplace el contenido del nuevo archivo JSP con el siguiente contenido:
<%@page contentType=”text/html;
charset=ISO-8859-1” pageEncoding=”ISO-8859-1”%>
<%@page import=”java.util.*,guest.Guest”%>
<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”

“http://www.w3.org/TR/html4/loose.dtd”>
< h t m l >
<head>
<title>JPA Guest Book Web Application Tutorial</title>
</head>
<body>
<form method=”POST” action=”guest”>

Name: <input type=”text” name=”name” />
<input type=”submit” value=”Add” />
</form>
<hr><ol> <%
@SuppressWarnings(“unchecked”)
List<Guest> guests = (List<Guest>)
r e q u e s t . g e t A t t r i b u t e ( “ g u e s t s ” ) ;
if (guests != null) {
for (Guest guest : guests) { %>
<li> <%= guest %> </li> <%
}
} %>
</ol><hr>
<iframe src=”http://www.objectdb.com/pw.html?jee-netbeans”
frameborder=”0” scrolling=”no”
width=”100%” height=”30”> </iframe>
</body>
</html>

Puede ejecutar la aplicación ahora haciendo clic derecho en el nodo GuestSer-

vlet (en la ventana [Projects]), seleccionando Run File, y click en OK ( no hay
necesidad de cambiar la ejecución de servlets URI ).

Puesto que estamos utilizando ObjectDB en modo incrustado - el archivo de base
de datos se crea en el directorio de GlassFish ( p.ej. en domains\domain1\eclip-
seApps\Guestbook\WEB-INF).
Puede detener el servidor GlassFish y abrir el archivo de base de datos en

ObjectDB Explorer:
Con todo lo antedicho (desde la clase 1 hasta el momento) ya está en condicio-

nes de hacer alguna aplicación sencilla.

Actividad 1: Actividad final
Actividad
Esta actividad formará parte del Examen Final, por lo tanto deberá ser
presentada en esa instancia. Esta aplicación es parte de examen.
Se pide que modifique la aplicación anterior de tal manera que, supongamos que
es un libro de visitas de la Iglesia de Candonga - Provincia de Córdoba - Argen-
tina, usted llega de visita con el guía turístico. El guía le facilita una aplicación,
donde se debe cargar:
• Nombre
• Apellido
• Dirección de Procedencia
• Edad
• Ocupación
Puede tomar como base el ejemplo y hacer las modificaciones pertinentes.
EVALUACIÓN: Ud. está en condiciones de resolver el segundo parcial
clase 12
claves de corrección Actividad 1: Actividad final
Les facilito unos videotutoriales, que los ayudarán a integrar todos los contenidos
vistos y así hacer las modificaciones necesarias en la aplicación dada. Espero les
sea de utilidad.
● https://www.youtube.com/watch?v=BvyCo_za0s8

● https://www.youtube.com/watch?v=A7YEAMPT6Bs
● https://www.youtube.com/watch?v=q10XMtDjTtg
● https://www.youtube.com/watch?v=5MKod5t_p0E
clase 12
conclusiones Hemos terminado. Espero hayan acumulado saberes para luego aplicarlos en
sus desarrollos. Recuerden que cada uno de los temas puede ampliarse, siem-
pre hay más por aprender. Todos los desarrolladores, debemos en cierta medida
aprender a buscar las fuentes documentales de cada lenguaje o software que nos
toque enfrentar.
Sean investigadores e inquietos, consulten, indaguen, estudien. Como les dije en

cada clase espero que les haya sido de utilidad esta materia.

Programación III Java ISP

Cargado por

Información del documento

Descripción original:

Título original

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

Programación III Java ISP

Cargado por

Copyright:

Formatos disponibles

Instituto

TDS - Tecnicatura en Desarrollo de Software

impresión total del documento ! 278 páginas

ISP | Programación III | Tercer Cuatrimestre 2

Cabe destacar que esta asignatura es la continuación de PROGRAMACIÓN II y

La materia se compone de cinco módulos: en el primero (que abarca las clases 1

El programa está pensado en función de la siguiente idea:

La programación es una profesión en continuo crecimiento y su constante com-

Por lo tanto, las prácticas están focalizadas en la programación orientada a obje-

En cada clase se le presentarán conceptos, explicaciones, lecturas y ejercicios

ISP | Programación III | Tercer Cuatrimestre 3

Disponible tambien en https://www.youtube.com/

• Deben entregar, enviar, compartir o subir a plataforma las actividades del

ISP | Programación III | Tercer Cuatrimestre 4

∙ Aprender la metodología de resolución de problemas con la finalidad de

∙ Identificar la magnitud de un problema, para poder usar herramientas

∙ Descomponer un problema en tantas partes como sea necesario de

∙ Desarrollar módulos Java de fácil comprensión que expresen claramente

∙ Desarrollar habilidades para generar código Java eficientes que utilicen

ISP | Programación III | Tercer Cuatrimestre 5

Módulo 3: Introducción a Programación con Objetos en Java - Parte 1

Módulo 4: Introducción a Programación con Objetos en Java - Parte 2

ISP | Programación III | Tercer Cuatrimestre 6

• BARNES D.J. y KÖLLING M. Programación orientada a objetos con Java.

• BELL, Douglas y PARR, Mike. Java para estudiantes. 6ta. edición,

• TEO, F.J.M. Manual imprescindible de Java 7. Anaya Multimedia-Anaya

• WEISS, Mark Allen. Estructuras de datos en java. Pearson Educación,

ISP | Programación III | Tercer Cuatrimestre 7

Es hora de comenzar a revisar. ¿Me acompaña?

Cuando realizamos desarrollos, dependemos de variables. Ellas son necesarias

ISP | Programación III | Tercer Cuatrimestre 8

Para hacerlo gráfico

ISP | Programación III | Tercer Cuatrimestre 9

En programación, las variables son espacios reservados en la

Los arreglos se pueden clasificar en

ISP | Programación III | Tercer Cuatrimestre 10

ISP | Programación III | Tercer Cuatrimestre 11

Con los arreglos podemos hacer operaciones como:

Dado que los arreglos tienen mucha utilidad en el ámbito de la programación y

Mira la animación animación1

ISP | Programación III | Tercer Cuatrimestre 12

Mira la animación animación3

ISP | Programación III | Tercer Cuatrimestre 13

LECTURA COMPLEMENTARIA Si quieren profundizar les reco-

ISP | Programación III | Tercer Cuatrimestre 14

Veamos el siguiente cuadro:

● Tipo Referencia: Las variables de tipo referencia a objetos almacenan

ISP | Programación III | Tercer Cuatrimestre 15

Dichas palabras son:

(*) son palabras reservadas, pero no se utilizan en la actual implementación del

Veamos un ejemplo de declaraciones:

ISP | Programación III | Tercer Cuatrimestre 16

Si quieren revisar las operaciones que se pueden hacer con las

Actividad 1: Refrescando Java

ISP | Programación III | Tercer Cuatrimestre 17

ARREGLOS UNIDIMENSIONALES EN JAVA

Como ya sabemos, un arreglo es una estructura de almacenamiento que per-

Para crear un arreglo se hace así:

ISP | Programación III | Tercer Cuatrimestre 18

Actividad 3: Continuamos trabajando con JAVA

ARREGLOS MULTIDIMENSIONALES EN JAVA

Recordemos que un arreglo multidimensional es aquel que posee más de una