05 Universidad de Java Desde Cero 5

CURSO DE PROGRAMACIÓN CON JAVA
Hola, te saluda nuevamente Ubaldo Acosta. Espero que estés listo para comenzar con esta
lección..
Vamos a estudiar el tema de excepciones en Java.
¿Estás listo? ¡Vamos!
© Todos los Derechos Reservados Global Mentoring Experiencia y Conocimiento para tu Vida 2
Curso de Programación con Java
En esta lección vamos a estudiar el tema de excepciones. Una excepción

es una situación no esperada en la ejecución de un programa.
Un ejemplo de excepción es por ejemplo, si un argumento es válido o no,

si una conversión de tipo de datos es incompatible, si existe una falla en
la conexión a la base de datos, etc.
Existen muchas clases de Excepciones ya creadas en el API de Java para

resolver varios de los problemas mencionados, pero si no existe la clase
que se adecue a nuestras necesidades nosotros podemos crear nuestras
propias clases de excepción, vamos a ver a continuación qué tipos de
excepciones existen y cómo utilizar cada una de ellas.
Vamos a estudiar los tipos de excepciones en el API de Java. Todas las clases en Java descienden de la clase
Throwable y posteriormente existen una jerarquía de clases, sin embargo en general existen dos tipos de
excepciones con las que vamos a trabajar, las que se conocen como checked exceptions y las uncheked
exceptions. Veamos en qué consiste cada una:
A) Checked Exceptions o Excepciones que heredan de la clase Exception: Si nuestro programa arroja este tipo
de excepción el compilador solicitará realizar alguna actividad con este tipo de excepción. Más adelante
veremos como procesar una excepción de este tipo, por ejemplo procesarlas dentro de un bloque try/catch o
arrojándolas en la declaración del método. Un ejemplo de este tipo de excepción de tipo checked exception es
la clase SQLException, la cual desciende de la clase Exception y es arrojada cuando existen algún problema con
temas relacionados con el uso y manejo de bases de datos.
B) Uncheked Exceptions o Excepciones que heredan de la clase RuntimeException: Este tipo de excepciones NO
estamos obligados a procesarlas, por lo que es opcional el uso del bloque try/catch o en la declaración del
método. Este tipo de excepciones también se les conoce como excepciones en tiempo de ejecución. Ejemplos
de este tipo de excepciones son: NullPointerException, ArrayOutOfBoundsException, entre muchas otras.
Existen una polémica respecto a cual de los dos tipos de excepciones utilizar y la estrategia a seguir respecto al
manejo de excepciones en nuestros programas. Sin embargo en los últimos años existe una tendencia respecto
al uso de las excepciones de tipo uncheked exceptions, las cuales no obliga al programador a procesar este tipo
de excepciones y por lo tanto es opcional agregar algún código de manejo de excepciones en nuestros
métodos, obteniendo así un código más limpio y que permite escoger al equipo de programadores si procesan
las excepciones agregando algún código para ello o simplemente dejan un código más limpio y se encargará de
procesar la excepción quien finalmente esté en necesidad de realizar dicho procesamiento.
Ejemplos de equipos de trabajo que han optado por el uso de unchecked exceptions es el equipo de trabajo del
framework de Spring, el cual optó no sólo por utilizar este tipo de excepciones, sino que al usar el framework de
Spring muchas de las excepciones de tipo checked, las convirtió a tipo uncheked, por lo que es opcional
procesar, en la mayoría de los casos, las excepciones que arroja el framework de Spring.
Vamos a revisar a continuación la sintaxis general para el manejo de excepciones, para ello
utilizamos el bloque try/catch.
El bloque finally es opcional, pero si se pone, siempre se va a ejecutar, aunque no ocurra la

excepción, por ello es que en ocasiones lo utilizaremos para asegurarnos que
independientemente del problema que ocurra, se ejecute el código del bloque finally.
Podemos observar que el código que posiblemente arroja la excepción debe estar envuelto por el
bloque try. Y si queremos procesar la excepción lo podremos hacer dentro del bloque catch. Este
bloque es el que recibe el tipo de excepción que queremos procesar, pudiendo ser varios bloques
catch y por cada bloque un tipo de excepción distinto. Cabe mencionar que el orden para
procesar más de una excepción será procesar en primer lugar la excepción que sea la clase de
menor jerarquía y finalmente la excepción de mayor jerarquía según la jerarquía de clases que
describa a las excepciones que vamos a procesar.
Un ejemplo de una excepción, es acceder a un elemento de un arreglo fuera de rango, esto nos
arrojaría una excepción de tipo ArrayOutOfBoundException, por lo que por medio del bloque
try/catch/finally es posible procesar este tipo de excepciones.
El bloque try/catch es opcional agregarlo para las excepciones de tipo unchecked exceptions, es
decir las excepciones que descienden de la clase Runtime Exception. A lo largo de los ejercicios
que vayamos creando iremos viendo varios ejemplos tanto de excepciones de tipo checked y
unchecked exceptions, y así irnos familiarizando con cada una de este tipo de excepciones.
En la figura podemos observar algunas de las excepciones más comunes en Java, y

podemos observar cuales son las clases padre de algunas de ellas. Podemos ver que
de las excepciones más importantes a identificar son la clase Exception y la
RuntimeException, ya que estos son los tipos de excepciones que hemos
comentado anteriormente, la primera como las excepciones de tipo checked
exception y la según las excepciones de tipo unchecked exceptions.
De hecho podemos observar que RuntimeException es una subclase de la clase

Exception, sin embargo el compilador tratará las excepciones de manera distinta a
todas las excepciones que descienda de la clase RuntimeException, de tal manera
que debemos saber y tener claro esta división y cómo trabajar con cada uno de los
tipos de excepción que hemos mencionado.
Vemos que la clase padre de todas las clases de excepción es la clase Throwable, y a
partir de esta tendremos las excepciones más importantes. Las excepciones de tipo
Error son las que normalmente son arrojadas por la máquina virtual de Java, por lo
que normalmente serán errores de los que no nos podremos recuperar, en cambio
las excepciones de tipo Exception o RuntimeException serán provocadas por
nuestro código o el código de otros que estemos utilizando en nuestro programa.
El stacktrace (traza de la pila de errores) de una excepción es el conjunto

de mensajes de error desde el origen del error hasta la última clase que
recibe el error. De esta manera es precisamente como su nombre lo dice,
un rastreo del error de la excepción y con ello podemos conocer más
fácilmente el origen del error y por lo tanto cómo corregirlo.
El log o bitácora de una aplicación normalmente incluye mensajes pero

también el stack trace de los errores que van sucediendo en nuestra
aplicación y por tanto los archivos de log, que son normalmente archivos
de texto, serán muy importantes para detectar la raíz de los problemas
que sucedan en nuestra aplicación.
Así que debemos estar familiarizados con estos términos ya que son de
los que más utilizaremos cuando tengamos problemas en nuestras
aplicaciones Java, y veremos cómo analizar los errores a los que nos
enfrentemos y así empecemos a ganar experiencia para darles solución.
Podemos observar en la figura de una manera más gráfica el mecanismo

en que funciona la pila de excepciones o stacktrace. Según hemos
comentado, una pila de excepciones es aquella que va acumulando las
excepciones desde el método que originó el problema, hasta el método
main, o el último método que recibió el problema, si es que no se cacha
antes dicha excepción.
Si una excepción no se atrapa con un bloque try/catch, se propaga la

excepción al método que lo mando llamar, y así sucesivamente hasta que
algún método lo atrapa, o sino el último método que lo recibe (por
ejemplo el método main) arroja finalmente la excepción, terminando de
manera anormal el programa.
En Global Mentoring promovemos la Pasión por la Tecnología Java. Te invitamos a visitar nuestro
sitio Web donde encontrarás cursos Java Online desde Niveles Básicos, Intermedios y Avanzados,
y así te conviertas en un experto programador Java.
Además agregamos nuevos cursos para que continúes con tu preparación como programador Java
profesional. A continuación te presentamos nuestro listado de cursos:
Programación con Java Hibernate Framework

Fundamentos de Java Spring Framework
Programación con Java JavaServer Faces
Java con JDBC Java EE (EJB, JPA y Web Services)
HTML, CSS y JavaScript JBoss Administration
Servlets y JSP’s Android con Java
Struts Framework HTML5 y CSS3
Datos de Contacto:
Sitio Web: www.globalmentoring.com.mx

Email: informes@globalmentoring.com.mx
www.globalmentoring.com.mx
Crear un ejercicio para uso básico de excepciones. Al finalizar
deberemos observar lo siguiente:
Vamos a crear el proyecto :
Vamos a crear una clase:
Archivo OperationException.java :
package domain;
/**
*
* @author Ubaldo
*/
public class OperationException extends Exception {
public OperationException(String mensaje) {

//Inicializamos el mensaje de error de la clase padre
super(mensaje);
}
}
Archivo Division.java:
package domain;
public class Division {
//atributo de la clase
private int numerador;
//atributo de la clase
private int denominador;
public Division(int numerador, int denominador) throws OperationException {
if (denominador == 0) {
//throw new IllegalArgumentException("Denominador igual a cero");
throw new OperationException("Denominador igual a cero");
}
this.numerador = numerador;
this.denominador = denominador;
}
public void visualizarOperacion() {

System.out.println("El resultado de la división es: " + numerador / denominador);
}
} www.globalmentoring.com.mx
Archivo ManejoExcepciones1.java:
package manejoexcepciones1;
import domain.*;
public class ManejoExcepciones1 {
public static void main(String[] args) {
try {
Division division = new Division(10, 0);
division.visualizarOperacion();
} catch (OperationException oe) {
System.out.println("Ocurrió un error!!!");
oe.printStackTrace();
}
}
El resultado es como sigue:
Archivo ManejoExcepcionesArg.java:
import domain.*;
public class ManejoExcepcionesArg {
public static void main(String args[]) throws OperationException {

try {
int op1 = Integer.parseInt(args[0]);
int op2 = Integer.parseInt(args[1]);
Division div = new Division(op1, op2);
div.visualizarOperacion();
} catch (ArrayIndexOutOfBoundsException aie) {
System.out.print("Ocurrió una excepción: ");
System.out.println("Hubo un error al acceder un elemento fuera de rango");
aie.printStackTrace();
} catch (NumberFormatException nfe) {
System.out.println("Uno de los argumentos no es entero");
nfe.printStackTrace();
} catch (OperationException oe) {
System.out.println("Se trató de realizar una operación erronea");
oe.printStackTrace();
} finally {
System.out.println("Se terminaron de revisar las excepciones");
}
}
}
Ejecutamos el proyecto, pero pasando argumentos:
• Probar con el modo debug del IDE y verificar paso a paso.
• Con este ejercicio hemos puesto en práctica el concepto de
excepciones en Java.
• Este es el primero de los ejercicios que vamos a realizar

acerca del tema de excepciones.
Por: Ing. Ubaldo Acosta
lección..
Vamos a estudiar el tema de excepciones en Java.
En esta lección vamos a continuar revisando más temas acerca de las

excepciones en Java. Vamos a hablar ahora de la clausula throws, la cual
nos permite especificar el tipo de excepción que arroja cierto método.
Esto se puede deber a que el método no atrapó la excepción y por lo

tanto se va a propagar al método que lo mando llamar.
Una excepción que extiende de Exception SÍ estamos obligados a

declararla en la firma del método, ya que este tipo de excepciones, al
igual que cuando comentábamos que se deben procesar por un bloque
try/catch, si no son procesadas por este bloque, entonces estamos
obligados a declararlas dentro del método donde se hace uso del método
que arroja la excepción.
Una excepción que extiende de RuntimeException NO estamos obligados

a declararla en la firma del método al usar un método que arroje este
tipo de excepciones.
Vamos a revisar ahora la cláusula throw. Esta palabra reservada nos permite LANZAR
explícitamente una excepción.
Por ejemplo, podemos utilizar una clase de excepción que extiende de la clase Exception o
cualquier otra clase de tipo exception y en conjunto con el operador new, crear un nuevo objeto
de esta clase y así arrojar una excepción de manera explícita.
En el código podemos observar cómo dentro del métodoX se lanza una nueva excepción de tipo
Exception, utilizando la palabra reservada throw seguida de new y la clase de tipo Exception que
queremos instanciar. Normalmente las clases de excepción en su constructor tiene una cadena
que será el mensaje que se mandará al stacktrace al momento en que ocurra el problema o se
lance la excepción.
Posteriormente lo que observamos es el que método main al hacer uso de metodoX obliga a
procesar la excepción por medio de un bloque try/catch, o a declarar en la firma del método que
es metodoX puede llegar a lanzar la excepción de tipo Exception, y lo vemos en la firma del
método por medio de la palabra throws Exception.
De hecho, con un proceso similar es como nuestra aplicación pueden convertir excepciones de
tipo Exception (checked exceptions) a tipo RuntimeException (uncheked exceptions), creando
nuestras propias clases de tipo runtime exception y al momento de envolver una excepción de
tipo Exception con un bloque try/catch, se puede relanzar una excepción de tipo runtime
exception, de esta manera no obligamos a los métodos que utilicen nuestros métodos a que
declaren el tipo de excepción que se puede arrojar, ya que se han convertido a tipo runtime
exception. Más adelante vamos a ver cómo realizar esta conversión.
Vamos a ver a continuación cómo podemos crear nuestras propias clases de excepción,
las cuales pueden extender de la clase Exception, o RuntimeException.
La intención de crear nuestras propias clase de Excepción es personalizar los mensajes de

error que se envían al usuario, por ejemplo, un error de Base de Datos, se puede atrapar y
convertir en un mensaje de error legible al usuario que usa nuestra aplicación, o como
hemos comentado anteriormente, podemos crear clase de excepción que desciendan de
la clase runtime exception para no obligar a los usuarios a usar bloques try/catch o
declarar en las firmas de los métodos el tipo de excepción que arrojará en caso de que
suceda alguna excepción del tipo que hemos declarado.
Como observamos en el código, estamos creando una clase de tipo MiExcepcion la cual
hereda de la clase Exception, sin embargo puede extender de cualquier otra clase de
excepción que nos interese. Posteriormente esta clase contiene un constructor el cual
recibe el mensaje que nos servirá para inicializar el atributo mensaje de la clase padre,
mandando a llamar el constructor padre por medio de la palabra super. Y con esto queda
inicializada nuestra excepción.
Porteriormente en la clase ArrojarExcepcion2 podemos observar que se lanzamos una

excepción de tipo MiExcepcion, y como es de tipo Excepcion, se obliga al metodoX a
declarar en su firma el tipo de excepción que se lanzará en caso de error. Así es como
crearemos nuestras propias clase de excepción y así también es como las usaremos
dentro de nuestro código Java.
Vamos a revisar ahora el tema de uso de excepciones utilizando herencia. En el

código mostrado vemos dos clases, una llamada MiExcepcion la cual extiende de la
clase Exception. Posteriormente declaramos una clase llamada MiExcepcionHija la
cual es una subclase de MiExcepcion, por lo tanto tenemos una jerarquía de clase
de excepción que hemos creado.
Por otro lado, en la clase ArrojarExcepcion3 se arroja una subclase llamada

MiExcepcionHija dentro del metodoX, pero si observamos a firma del método, el
método declara que se arroja una excepción que es una superclase llamada
MiExcepcion.
La intención de hacer esto, es que el método internamente puede arrojar

excepciones que son subclases, pero la clase que use a este método solo procesa la
excepción más genérica, y con ello podemos tener un rango más amplio para el
manejo de excepciones, utilizando precisamente el concepto de herencia pero
ahora dentro de la definición de clases de tipo Exception, y al igual que cuando
trabajamos con polimorfismo, mucho del código en cualquier lenguaje de
programación y también en Java, es crear métodos lo más genéricos posibles que
nos ayuden a englobar más posibles excepciones en menos líneas de código, que al
final nos ahorrará costos de mantenimiento de nuestras aplicaciones, al tener
código lo más genérico y compacto posible.
Vamos a ver a continuación el uso de excepciones al momento de sobrecargar nuestros métodos en Java.
Algunas de las reglas que debemos respetar son:
Un método que sobreescribe a un método padre que declara una excepción SÍ PUEDE:
• No arrojar ninguna excepción, es decir, omitir la excepción en su firma.
• Arrojar una o más excepciones arrojadas por el método padre.
• Arrojar una o más excepciones que son subclases de la excepción arrojada.
Un método que sobreescribe a un método padre que declara una excepción NO PUEDE:
• Arrojar excepciones adicionales no arrojadas en el método padre.
• Arrojar superclases de las excepciones arrojadas por el método padre.
En el código mostrado observamos una clase padre (ArrojarExcepcionA) y dos clases hijas (ArrojarExB y
ArrojarExC), las cuales sobreescriben el metodoX definido en el padre. Lo que estamos aclarando en este
código las excepciones que podemos utilizar en la firma de los métodos sobreescritos por las clases hijas.
Por un lado observamos que la clase ArrojarExB en la firma del metodoX en lugar de utilizar la misma
excepción que en la firma del método de la clase padre (MiExcepcion), se utiliza una subclase
(MiExcepcionHija), de esta manera es claro que no necesariamente debemos utilizar la misma clase de
excepción en la firma del método, sino que puede ser alguna clase dentro de la jerarquía de clases de
excepción que estamos utilizando, siendo siempre subclases, y no superclases.
Por otro lado, observamos en la clase ArrojarExC que se utiliza precisamente una super clase (Exception)
de la clase de excepción utilizada en el padre (MiExcepcion), y por lo tanto esto no es válido y existe un
problema de compilación en nuestro código. Más adelante veremos un ejemplo de este tipo de manejo de
excepciones en la firma de los métodos que se sobreescriben.

Datos de Contacto:

Crear un ejercicio para uso más avanzado de excepciones. Al
finalizar deberemos observar lo siguiente:
Vamos a crear el proyecto :
Archivo AccesoDatosEx.java:
package excepciones;
public class AccesoDatosEx extends Exception{
public AccesoDatosEx(String mensaje){

super(mensaje);
}
}
Archivo EscrituraDatosEx.java:
public class EscrituraDatosEx extends AccesoDatosEx{
public EscrituraDatosEx(String mensaje) {

super(mensaje);
}
}
Archivo LecturaDatosEx.java :
public class LecturaDatosEx extends AccesoDatosEx{
public LecturaDatosEx(String mensaje) {

super(mensaje);
}
Archivo AccesoDatos.java :
package datos;
import excepciones.AccesoDatosEx;
public interface AccesoDatos {
public abstract void insertar() throws AccesoDatosEx;
public abstract void listar() throws AccesoDatosEx;
public abstract void simularError(boolean simularError);

}
Archivo ImplementacionMySql.java :
package datos;
import excepciones.*;
public class ImplementacionMySql implements AccesoDatos{

private boolean simularError;
@Override
public void insertar() throws AccesoDatosEx {
if (simularError) {
throw new EscrituraDatosEx("Error de escritura de datos");
} else {
System.out.println("Insertar desde MySql");
}
}
@Override
public void listar() throws AccesoDatosEx {
if (simularError) {
throw new LecturaDatosEx("Error de lectura de datos");
} else {
System.out.println("Listar desde MySql");
}
}
public boolean isSimularError() {

return simularError;
}
@Override
public void simularError(boolean simularError) {
this.simularError = simularError;
}
Archivo ManejoExcepciones2.java (Parte 1):
import datos.*;
import excepciones.*;
public class ManejoExcepciones2 {

AccesoDatos datos = new ImplementacionMySql();
//Cambiamos el estado a simularError = true
datos.simularError(true);
ejecutar(datos, "listar");
//Cambiamos el estado a simularError = false

datos.simularError(true);
System.out.println("");
ejecutar(datos, "insertar");
}
Archivo ManejoExcepciones2.java (Parte 2):
private static void ejecutar(AccesoDatos datos, String accion) {
if ("listar".equals(accion)) {
try {
datos.listar();
}
//Si se van a procesar varias excepciones de la misma jerarquia
//siempre se debe procesar primero la excepcion de menor jerarquia
//y posteriormente la de mayor jerarquia
catch (LecturaDatosEx ex) {
System.out.println("Error lectura: Procesa la excepcion mas especifica de lectura de datos");
} catch (AccesoDatosEx ex) {
System.out.println("Error Acceso datos: Procesa la excepcion mas generica de acceso a datos");
} catch (Exception ex) {
System.out.println("Error general");
}
finally {
System.out.println("Procesar finally es opcional, siempre se ejecutara sin importar si hubo error o no");
}
} else if ("insertar".equals(accion)) {
try {
datos.insertar();
System.out.println("Error acceso datos: Podemos procesar solo la excepcion mas generica");
}
finally{
System.out.println("Procesar finally es opcional, siempre se ejecutara sin importar si hubo error o no");
}
}
else
System.out.println("No se proporciono ninguna accion conocida");
}
• Probar con distintos valores y lanzar excepciones padres e

hija para así comprobar como funciona el manejo de
excepciones según la jerarquía de excepciones que hemos
declarado.
• Con este ejercicio hemos puesto en práctica conceptos más
avanzados de excepciones en Java.
• Pudimos observar cómo trabajar con excepciones de tipo

Exception, también es posible convertir estas excepciones a
tipo RuntimeException, simplemente extendiendo de esta
clase en lugar de la clase Excepcion. Esto puede quedar
como un buen ejercicio para que observen cómo el
compilador NO nos obliga a procesar las excepciones de tipo
RuntimeException y así tener un código más limpio.
Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente a este curso de Programación con Java.
En esta lección vamos a revisar el tema de colecciones en Java.
Comencemos de inmediato.
Vamos a estudiar a continuación el tema de colecciones en Java. Una colección es un

conjunto de datos, que pueden o no tener un ordenamiento particular. Las colecciones
es muy similar a los arreglos, sin embargo los arreglos es una estructura más simple que
el manejo de colecciones.
Las colecciones se conocen también como Estructuras de Datos, ya que permiten

almacenar información de manera estructurada y de maneras más variadas que en los
arreglos.
Como podemos observar en la figura, los datos que podemos observar pueden tener
cierto orden, además de posiblemente necesitemos agregar más registros conforme
vamos necesitando, y como sabemos en un arreglo debemos declarar el número de
elemento que contendrá el arreglo. Una colección es más flexible y permite ir agregando
elementos conforme vayamos necesitando de manera más dinámica, además de que
puede tener métodos de ordenamiento, búsqueda, evitar valores duplicados, entre
muchas otras características, todo depende del tipo de colección que utilicemos.
Existe un API ya definida en Java, en la cual se tiene un conjunto de clases que permiten
resolver problemas específicos, como son: Listas doblemente ligadas, Árboles, Mapas de
Datos, entre muchas otras clases. En esta lección veremos algunas de las colecciones más
utilizadas, y con ello podremos familiarizarnos con esta API de Colecciones.
El API de Colecciones, de manera resumida se divide en Listas, Sets (Conjuntos de datos), y Mapas (Llave relacionado a un
dato), los mapas utilizan funciones hash. Esta API permite reducir el esfuerzo de programación y reutilizar código con
algoritmos existentes.
Una función hash es cualquier función con un algoritmo definido que convierte datos complejos a un número entero, con el
objetivo de agilizar la búsqueda u ordenamiento de los elementos en un conjunto de datos. Esto ya lo hemos comentado a
grandes rasgos cuando explicamos el tema del método hashCode, el cual regresa un valor entero combinando los atributos
de una clase, y así poder asignar un entero único a cada objeto que creamos, y de esta manera el ordenamiento de objetos
es más ágil, ya que cualquier confusión respecto a nombres similares o cualquier otro dato similar, los valores hashCode nos
servirán precisamente para diferenciar y ordenar correctamente nuestros elementos. La buena noticia es que nosotros solo
debemos preocuparnos por implementar correctamente el método hashCode, el cual incluso los IDEs nos ayudan en muchos
casos para crear estos métodos de manera más simple y así los ordenamientos o búsquedas en las colecciones serán más
eficientes al utilizar nuestros objetos.
El API de las colecciones en Java contiene un conjunto de Clases e Interfaces, las cuales podemos observar algunas de ellas
en el diagrama de clases mostrado. Vemos que todas la mayoría de las clases desciende de la interface Collection, y de allí
descienden las interfaces de Set y List, y de allí obtenemos clases fundamentales como son HashSet, ArrayList y Vector, entre
muchas otras más. Por otro lado tenemos la interface Map, y obtenemos clases tan importantes como la clase HashMap, y
cualquier otra clase que necesite de relacionar valores de tipo value-key o valor-llave. Veamos ahora que significan algunas
de las clases más utilizadas en el API de Colecciones.
Un Set, es una colección NO ORDENADA de elementos. No se permiten elementos duplicados. Por lo que cualquier elemento
duplicado no se insertará.
Una Lista es una colección ORDENADA, la cual sí permite duplicados.
Un Mapa relaciona una llave (key) con un valor, formando una especia de tabla de datos.
Existen clase de apoyo para trabajar con Colecciones como son Enumeration e Iterator, y para comparar los elementos se
utiliza la interface Comparator. Estos son solo algunos de los temas que tienen que ver con el API de Colecciones, el cual es
bastante amplio y es muy interesante estudiar a fondo, así que una vez que tengamos las bases del uso de sus principales
clases, podremos explorar a más detalle dichas clases.
A continuación te presentamos nuestro listado de cursos:
Lógica de Programación Hibernate Framework

Datos de Contacto:

Por el experto: Ing. Ubaldo Acosta
Poner en práctica el concepto de colecciones en Java. Al
Vamos a crear el proyecto:
Archivo ManejoColecciones.java:
package manejocolecciones;
Map miMapa = new HashMap();
import java.util.*; //Lave, valor
miMapa.put("1", "Juan");
public class ManejoColecciones { miMapa.put("2", "Carlos");
miMapa.put("3", "Rosario");
public static void main(String args[]) { miMapa.put("4", "Esperanza");
List miLista = new ArrayList(); //Se imprimen todas las llaves
miLista.add("1"); imprimir(miMapa.keySet());
miLista.add("2"); //Se imprimen todos los valores
miLista.add("3"); imprimir(miMapa.values());
miLista.add("4");
//Elemento repetido }
miLista.add("4");
imprimir(miLista); private static void imprimir(Collection coleccion) {
for (Object elemento : coleccion) {
Set miSet = new HashSet(); System.out.print(elemento + " ");
miSet.add("100"); }
miSet.add("200"); System.out.println("");
miSet.add("300"); }
//No permite elementos repetidos, lo ignora }
miSet.add("300");
imprimir(miSet);
Ejecutamos el proyecto:
• Se pueden agregar más objetos y probar que todo funcione

correctamente.
Con este ejercicio hemos puesto en práctica el concepto de
colecciones en Java.
Aunque hemos trabajado con el tipo de datos String, podemos

trabajar con cualquier tipo de datos, incluyendo los que
nosotros creamos, de esta manera serán mucho más completo
el uso de colecciones y así simplificar nuestro código al
momento de utilizar conjuntos de datos.
lección.
Vamos a estudiar el tema de Genéricos en Java.
Vamos a estudiar en esta lección los tipos genéricos en Java. Los tipos genéricos o generics, se introdujeron en la
versión 1.5 de Java SE, y fue uno de los mayores cambios para esta versión.
Anteriormente teníamos que saber exactamente el tipo de datos que íbamos a utilizar para poder pasar por ejemplo
parámetros a una función, o para instanciar una clase, sin embargo con ayuda de los genéricos podemos dejar
pendiente el tipo de dato hasta el momento de instanciar alguna clase genérica, o del paso de un parámetro
genérico.
Podemos observar en el código mostrado una clase que define un tipo genérico con el uso del operador diamante <>
en la definición de la clase. Esto quiere decir que el tipo lo conoceremos hasta el momento en que sea utilizada esta
clase, y por ello se conoce como tipo genérico.
La T significa básicamente un tipo genérico que será reemplazado al momento de utilizar esta clase, por lo que la T es
simplemente el nombre que le damos al tipo genérico que vamos a utilizar. Existen varios nombres que podemos
utilizar como veremos en la siguiente lámina.
Posteriormente en la clase definimos un atributo del mismo tipo T, el cual lo inicializaremos por medio del
constructor de esta clase, y podemos ver que cuando utilizamos esta clase en el método main mostrado, al momento
de crear el objeto de esta clase, especificamos por medio del operador diamante el tipo de dato que nos interesa
utilizar.
Y aquí es aquí donde el uso de clases genéricas es muy útil, ya que nos permite definir el tipo de dato que queremos
utilizar hasta el momento de instanciar un objeto de nuestra clase, y así definir funcionalidad cada vez más genérica
valga la redundancia, de hecho al utilizar interfaces, clases abstractas y polimorfismo ya hemos creado varios
métodos genéricos ya que pueden ser utilizados por varios tipos de datos, sin embargo, este concepto de Generics va
un paso más allá, y nos permite definir el tipo a utilizar y crear métodos aún más genéricos de los que hemos creado.
Finalmente el método obtenerTipo() nos permite mandar a consola el tipo de dato que hemos definido para la clase
genérica, y así como hemos utilizado el tipo <Integer> para instanciar nuestra clase genérica, podemos utilizar
cualquier tipo de datos, sin embargo no podemos utilizar tipos primitivos, sino solo tipos Object.
Al utilizar y crear tipos genéricos, podemos utilizar varios nombres, como

la T que ya hemos utilizado. Sin embargo, existen algunas convenciones
que podemos seguir al momento de crear nuestras clases genéricas y así
utilizar buenas prácticas al momento de crearlas. Obviamente también
nos es útil al momento de usar estos tipos genéricos en clases ya creadas
dentro del Api de Java, ya que sabremos con mayor certeza para que
sirve cada clase y tipo genérico que estamos utilizando.
A continuación veremos cómo aplicar los tipos genéricos al framework de

Colecciones de Java.
El tema de genéricos, fue mayormente utilizado para cambiar varias de las APIs de Java, pero en
particular el API de Framework Collections fue de los más beneficiados, ya que como podemos ver,
anteriormente era necesario definir un tipo lista, sin embargo no había una certeza de que
almacenara un solo tipo y así evitar problemas de conversión de objetos al momento de extraer sus
elementos. Por ello anteriormente las listas almacenaban un tipo object, y al momento de extraer el
objeto de la lista el compilador tenia un object, y por tanto era necesario hacer un casting del objeto
extraido, como se observa en el código de la clase SinGenerics.
Sin embargo con las colecciones genéricas, podemos declarar una lista de un tipo en concreto, y
agregar a esta lista solo los tipos o subtipos compatibles según las reglas de downcasting que
mencionamos en el tema de conversión de objetos.
Como podemos observar en el ejemplo de ConGenerics, observamos que para definir la lista estamos
utilizando el operador diamante y estamos especificando que los objetos que podemos agregar a esta
lista son exclusivamente de tipo Integer o subclases del tipo Integer, de esta manera cuando
extraemos los valores de esta lista estamos seguros que serán de un tipo compatible con el tipo
Integer, y por tanto no es necesario hacer un casting o conversión del objeto extraído.
Por lo tanto, las colecciones genéricas ofrecen la seguridad de que en tiempo de compilación los
datos a almacenar son sólo del tipo especificado, eliminan la necesidad de hacer un casting
(conversión de tipos). Solo debemos recordar que se necesita la versión 1.5 o mayor del JDK.
En la figura podemos observar cómo se cambió la definición de las interfaces y clases del API de
Coleccions, y ahora se utilizan tipos genéricos en su definición. Veamos a continuación algunos
ejemplos del uso de colecciones genéricas.

Struts Framework Datos de Contacto:HTML5 y CSS3

Crear el ejercicio de Generics. Al finalizar deberemos observar
lo siguiente:
Archivo ClaseGenerica.java:
package manejogenericos;
//Definimos una clase generica con el operador diamante <>

public class ClaseGenerica<T> {
//Definimos una variable de tipo generico
T objeto;
//Constructor que inicializa el tipo a utilizar

public ClaseGenerica(T objeto) {
this.objeto = objeto;
}
public void obtenerTipo() {

System.out.println("El tipo T es: " + objeto.getClass().getName());
}
}
Archivo ManejoGenericos.java:
package manejogenericos;
public class ManejoGenericos {

// Creamos una instancia de ClaseGenerica para Integer.
ClaseGenerica<Integer> objetoInt = new ClaseGenerica<Integer>(15);
objetoInt.obtenerTipo();
// Creamos una instancia de ClaseGenerica para String.

//Se puede utilizar la inferencia del tipo del lado derecho
ClaseGenerica<String> objetoStr = new ClaseGenerica<>("Prueba");
objetoStr.obtenerTipo();
//Los genericos no pueden ser aplicados a tipos primitivos

//Por lo que esto marcaria un error de compilación
//ClaseGenerica<int> intPrimitivo = new ClaseGenerica<int>(88);
}
}
• Probar con distintos valores y verificar el resultado.
• Con este ejercicio hemos puesto en práctica el manejo
básico de tipos genéricos en Java.
• Para más información consultar:

• https://docs.oracle.com/javase/tutorial/java/generics/index.html
Crear el ejercicio de colecciones genéricas en Java. Al finalizar
Archivo ManejoColeccionesGenericas.java:
package manejocoleccionesgenericas;
Map<String, String> miMapa = new HashMap<>();
import java.util.*; miMapa.put("1", "Juan");
miMapa.put("2", "Carlos");
public class ManejoColeccionesGenericas { miMapa.put("3", "Rosario");
miMapa.put("4", "Esperanza");
public static void main(String[] args) { imprimir(miMapa.keySet());
List<String> miLista = new ArrayList<>(); imprimir(miMapa.values());
miLista.add("1"); }
miLista.add("2");
miLista.add("3"); static void imprimir(Collection<String> col) {
miLista.add("4"); for (String elemento : col) {
miLista.add("4"); System.out.print(elemento + " ");
imprimir(miLista); }
System.out.println();
Set<String> miSet = new HashSet<>(); }
miSet.add("100"); }
miSet.add("200");
miSet.add("300");
miSet.add("300");
imprimir(miSet);
• Con este ejercicio hemos puesto en práctica concepto de
colecciones genéricas en Java. Se deja como ejercicio
comparar la sintaxis de este ejercicio con el ejercicio de
colecciones sin utilizar generics, y así observar las
diferencias y ventajas entre cada código utilizado.
• Para más información consultar:

• https://docs.oracle.com/javase/tutorial/collections/index.html
Hola, te saluda Ubaldo Acosta. Bienvenida o bienvenido nuevamente. Espero que estés listo para
comenzar con esta lección.
Vamos a estudiar el tema de propiedades del sistema en Java.
¿Estás listo? Ok, ¡Vamos!
Curso de Fundamentos de Java
En esta lección vamos a estudiar cómo obtener las propiedades del

sistema. Las propiedades del sistema, es similar al concepto de las
variables de entorno del sistema operativo.
Según el sistema operativo en el que estemos trabajando, pueden variar

las propiedades del sistema.
El método System.getProperties() regresa un objeto de tipo Properties, el

cual es parecido a un mapa (Map), y cada elemento de la lista tiene una
llave y un valor asociado a dicha llave.
Podemos utilizar estos valores para ejecutar algún código basado en

algún valor asociado por ejemplo al sistema operativo que estamos
trabajando, la versión de Java, el tipo de file system, etc. Vamos a ver un
ejemplo de cómo visualizar las propiedades del sistema.

Datos de Contacto:

Crear un programa para visualizar las propiedades del sistema
en Java. Al finalizar deberemos observar lo siguiente:
Archivo PropiedadesSistema.java:
package propiedadessistema;
import java.util.*;
public class PropiedadesSistema {
Properties propiedades = System.getProperties();

Enumeration nombrePropiedades = propiedades.propertyNames();
while (nombrePropiedades.hasMoreElements()) {
String nombrePropiedad = (String) nombrePropiedades.nextElement();
String valorPropiedad = propiedades.getProperty(nombrePropiedad);
System.out.println("Llave:" + nombrePropiedad + "=" + valorPropiedad);
}
}
}
Resultado dees
El resultado la como
ejecución del proyecto. El resultado puede variar:
sigue:
• Con este ejercicio hemos visualizado las propiedades del
sistema, las cuales nos pueden servir para tomar ciertas
decisiones en nuestro código, según el valor de alguna
variable, como el sistema operativo que se está utilizando o
alguna otra variable de nuestro interés.
lección..
Vamos a estudiar el tema de entrada y salida de datos en Java.
En esta lección vamos a estudiar el tema de entrada y salida de datos. En

Java, tenemos un conjunto de clases para leer y escribir información,
tanto a la salida estándar (consola), como a archivos, flujos, y otro tipo de
entradas y salidas de información.
La figura nos muestra los procesos de lectura y de escritura en Java. En

esta lección vamos a revisar algunos de las clases que nos permitirán
escribir y leer información de la consola, también conocida como salida o
entrada de datos estándar.
Existen 3 variables para interactuar con la consola del Sistema Operativo,

también conocida como flujos de entrada/salida estándar.
System.in : Lee de la entrada estándar, y es de tipo InputStream (ej. Lee

datos del teclado).
System.out : Escribe a la salida estándar, y es de tipo PrintStream (ej.

Muestra datos en la pantalla).
System.err : Escribe a la salida estándar de errores, y es de tipo

PrintStream (ej. Muestra datos de error en la pantalla).
En el paquete java.io existen dos grandes clasificaciones, clases que

permiten manejar tipos char y otras de tipo byte. La figura muestra de
manera resumida las clases involucradas en el proceso de lectura.
Las clases del lado izquierdo son para flujos de tipo char y las clases del
lado derecho son para flujos de tipo byte.
Veremos más adelante ejemplos de algunas de estas clases para leer

datos en Java.
Ahora veremos las clases del API de Salida en Java. La figura nos
muestra de manera resumida las clases involucradas en el
proceso de escritura.
Las clases del lado izquierdo son para flujos de tipo char y las
clases del lado derecho son para flujos de tipo byte.
Veremos más adelante ejemplos de algunas de estas clases para escribir

datos en Java.
Veamos ahora la diferencia entre utilizar tipos de datos byte o char en

flujos de datos, lo cual tiene que ver directamente con el tipo de datos
que estamos trabajando.
Los flujos (streams) son utilizados para procesar un byte a la vez, son
recomendados para procesar archivos binarios, como son archivos de
tipo Word, Excel, o cualquier formato que es más complejo que un
simple archivo de texto.
Las clases de tipo Reader’s/Writer’s son utilizados para procesar un

carácter (char) a la vez, son recomendados para procesar texto basado
en algún juego de caracteres como el ASCII o Unicode.
Las clases que tiene buffer son utilizadas para procesar más de un
carácter o byte a la vez.
Veamos ahora como leer datos desde la entrada estándar, esto lo vamos
a lograr por medio de la variable System.in, la cual lee datos de la entrada
estándar.
La clase InputStreamReader accede a la consola estándar, pero solo

puede leer un carácter a la vez. Por lo tanto necesitamos de otra clase
para que podamos leer más datos que simplemente un carácter a la vez.
La clase BufferedReader nos permite capturar una línea completa de

datos, en lugar de solamente un carácter de la entrada estándar y con
ella podremos acceder más fácilmente a más información de nuestra
entrada estándar.
Vamos a crear un ejemplo de lectura de datos de la entrada estándar.
Además del API que ya hemos revisado, en Java se introdujo la clase

Scanner para simplificar el proceso de lectura de datos. Por lo tanto
podemos observar un ejemplo en el cual podemos observar el uso básico
de la clase Scanner, la cual recibe en su constructor el flujo de entrada, ya
sea la consola estándar, un archivo u otro tipo de entrada.
Una vez que se ha creado este objeto, contiene métodos para simplificar
la lectura de la entrada de datos, tal como el método nextLine, nextInt,
nextFloat, y varios más, los cuales como su nombre nos indica nos
permite leer ya sea una nueva línea, un nuevo entero, un nuevo tipo
flotante respectivamente.
Esta clase, como observamos, nos permite simplificar el proceso de

entrada de datos, y más adelante veremos un ejercicio precisamente
para poder entender a más detalle cómo utilizar esta clase Scanner.

Datos de Contacto:

Poner en práctica el concepto entrada de datos en Java. Al
Archivo EntradaDatos.java:
package entradadatos;
import java.io.*;
public class EntradaDatos {
public static void main(String args[]) {

String captura;
InputStreamReader input = new InputStreamReader(System.in);
BufferedReader bInput = new BufferedReader(input);
try {
System.out.println("Introduce un dato:");
captura = bInput.readLine();
while (captura != null) {
System.out.println("Dato introducido:" + captura);
captura = bInput.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}
}
El resultado es como sigue. El programa leerá datos hasta que
detengamos el proceso de Java (botón rojo).
entrada de datos en Java.
• Esta es una forma muy básica de leer datos, sin embargo nos
permite ir entendiendo el uso de las clases del API de
Entrada de datos en Java.
Poner en práctica el concepto entrada de datos en Java
utilizando la clase Scanner. Al finalizar deberemos observar lo
siguiente:
Archivo EntradaDatosScanner.java:
package entradadatosscanner;
import java.util.*;
public class EntradaDatosScanner {

String captura = null;
Scanner scan = new Scanner(System.in);
System.out.println("Introduce un dato:");
captura = scan.nextLine();
while (captura != null) {
System.out.println("Dato introducido:" + captura);
captura = scan.nextLine();;
}
}
}
El resultado es como sigue. El programa leerá datos hasta que
detengamos el proceso de Java (botón rojo).
entrada de datos en Java, pero ahora utilizando la clase
Scanner, la cual nos simplifica el proceso de entrada de datos
en Java, sin embargo es importante conocer ambas opciones
para cuando encontremos código con ambas APIs.
Poner en práctica el concepto entrada de datos creando una
calculadora. Al finalizar deberemos observar lo siguiente:
Archivo Operaciones.java :
package calculadora;
public class Operaciones {
public static int sumar(int a ,int b){

return a + b;
}
}
Archivo CalculadoraEntradaDatos.java :
package calculadoraentradadatos;
import java.util.*;
import static calculadora.Operaciones.sumar;
public class CalculadoraEntradaDatos {

System.out.println("Proporciona el primer valor:");
Scanner scan = new Scanner(System.in);
int a = scan.nextInt();
System.out.println("Proporciona el segundo valor:");
int b = scan.nextInt();
int resultado = sumar(a, b);
System.out.println("El resultado de la suma es:" + resultado);
}
}
• Con este ejercicio hemos puesto en práctica un ejercicio de
calculadora, pero ahora los valores de entrada son
proporcionados dinámicamente. Con esto pusimos en
práctica la entrada de datos con la clase Scanner, utilizando
el método nextInt(). Existen más métodos que podemos
comenzar a explorar de esta clase.
• Para más información de la clase scanner consultar:

• https://docs.oracle.com/javase/tutorial/essential/io/scanning.html
Hola, te saluda Ubaldo Acosta. Bienvenida o bienvenido nuevamente. Espero que estés listo para
comenzar con esta lección.
Vamos a estudiar el tema de manejo de archivos en Java.
¿Estás listo? Ok, ¡Vamos!
En esta lección vamos a estudiar el manejo de archivos en Java. Se utilizan las clases
File, FileWriter y PrintWriter para poder crear un archivo. Es conveniente verificar
que tengamos permisos para escribir el archivo, por ejemplo, podemos crear una
carpeta y asignarle permisos de escritura, de esta manera no tendremos problemas
para crear, leer o modificar el archivo creado.
La clase FileWriter se utiliza para escribir información a un archivo, y como

podemos observar en el código, primeramente creamos un archivo con la clase File,
sin embargo esto no crea físicamente el archivo, para ello necesitamos la clase
FileWriter y finalmente la clase PrintWriter que es la que creará el archivo en el
disco duro. Vemos que el archivo de prueba es creado dentro de una carpeta la cual
ya debe existir para que no arroje errores de creación de archivo.
Una vez creado el archivo, podremos leer y escribir sobre él, a continuación
veremos cómo realizar estos procesos.
Vamos a estudiar ahora cómo escribir información a un archivo. La clase

FileWriter se usa para escribir caracteres a un archivo.
La clase PrintWriter se usa para imprimir líneas completas, con los

métodos print() y println(). La desventaja de este método es que se
pierde la información que tengamos almacenada de manera previa en el
archivo, por lo tanto no nos dice para agregar nueva información, sino
escribir desde cero al archivo.
Más adelante veremos un ejemplo de cómo realizar este proceso.
Veamos ahora cómo leer información de un archivo. Se utilizan las clases

File, FileReader y BufferedReader para poder leer un archivo
El código es muy parecido a la lectura de información de la consola

estándar.
La clase FileReader se utiliza para leer caracteres.
La clase BufferedReader se utiliza para leer líneas completas.
Así que dependiendo de lo que necesitemos leer será el tipo de clase que
podemos utilizar. Más adelante veremos un ejemplo de la lectura de
información de un archivo.
Veamos ahora cómo anexar información a un archivo ya creado.
La diferencia con el ejercicio anterior es la llamada al constructor de la

clase FileWriter, ahora le proporcionamos una bandera true, que significa
que la información se va a agregar a la ya existente, y con ello no se
pierde lo que ya se encuentra en el archivo, sino que anexa la
información proporcionada.
Más adelante veremos un ejercicio para anexar información a un archivo.

Datos de Contacto:

Poner en práctica el concepto de manejo de archivos en Java.
Al finalizar deberemos observar lo siguiente:
Archivo Archivos.java:
package utileria; public static void escribirArchivo(String
nombreArchivo) {
import java.io.*; File archivo = new File(nombreArchivo);
try {
public class Archivos { PrintWriter salida = new PrintWriter(new
FileWriter(archivo));
public static void crearArchivo(String String contenido = "Contenido a escribir
nombreArchivo) { en el archivo";
File archivo = new File(nombreArchivo); salida.println(contenido);
try { salida.println();
PrintWriter salida = new PrintWriter(new salida.println("Fin de escritura");
FileWriter(archivo)); salida.close();
salida.close(); System.out.println("Se ha escrito
System.out.println("El archivo se ha correctamente al archivo\n");
creado correctamente\n"); } catch (IOException ex) {
} catch (IOException ex) { ex.printStackTrace();
ex.printStackTrace(); }
}
} }
( )
Archivo Archivos.java:
public static void leerArchivo(String public static void anexarArchivo(String
nombreArchivo) { nombreArchivo) {
File archivo = new File(nombreArchivo); File archivo = new File(nombreArchivo);
try { try {
BufferedReader entrada = new PrintWriter salida = new PrintWriter(new
BufferedReader(new FileReader(archivo)); FileWriter(archivo, true));
String lectura; String contenido = "Anexando informacion
lectura = entrada.readLine(); al archivo";
while (lectura != null) { salida.println(contenido);
System.out.println("Lectura: " + salida.println();
lectura); salida.println("Fin de anexar");
lectura = entrada.readLine(); salida.close();
} System.out.println("Se ha anexado la
entrada.close(); informacion correctamente\n");
} catch (IOException ex) { } catch (IOException ex) {
ex.printStackTrace(); ex.printStackTrace();
} }
} }
}
Archivo ManejoArchivos.java:
package manejoarchivos;
import static utileria.Archivos.*;
public class ManejoArchivos {
//Nota: Ya debe estar creada la carpeta sobre la que se va a trabajar

//Y en caso necesario se deben asignar permisos de escritura a la carpeta
private static final String NOMBRE_ARCHIVO = "c:\\pruebaJava\\pruebaJava.txt";
//Crear un archivo
crearArchivo(NOMBRE_ARCHIVO);
//Escribir a un archivo
escribirArchivo(NOMBRE_ARCHIVO);
//Leer de un archivo
leerArchivo(NOMBRE_ARCHIVO);
//Anexar informacion a un archivo

anexarArchivo(NOMBRE_ARCHIVO);
//Leer de un archivo
leerArchivo(NOMBRE_ARCHIVO);
}
}
Manejo de Archivos en Java.
• Hemos visto varias operaciones, como son crear, escribir,

leer y anexar información a un archivo. Con esto tenemos las
bases para entender el funcionamiento del manejo de
archivos desde Java.
Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente a este curso de Programación con Java.
Esta es nuestra lección final, por lo que vamos a realizar un ejercicio donde pondremos en
práctica lo visto en el curso de Programación con Java.
Comencemos de inmediato.
En este laboratorio final vamos a crear un ejercicio que simule un catálogo de películas. Para este
ejercicio, vamos a almacenar la información del catálogo de películas en un archivo de texto, en una
carpeta definida por nosotros, por ejemplo en la carpeta: c:\catalogoPeliculas\películas.txt
Vamos a crear varios paquetes, cada uno con tareas específicas a desarrollar en el programa.
Paquetes:
1. Crear un paquete de excepciones, similar a la lección de excepciones vistas en el curso, según se

muestra en el diagrama de clases.
2. Crear un paquete mx.com.gm.películas.domain que incluya una clase llamada Pelicula. Las clases
almacenadas en este paquete, se conoce como las clases del dominio del problema.
3. Crear un paquete llamado mx.com.gm.películas.datos la cual incluye una interface y una clase que
implementa dicha interface. El objetivo de estas clases es agregar la funcionalidad para interactuar
con el archivo donde se va a guardar la información del catálogo de películas.
4. Crear el paquete llamado mx.com.gm.peliculas.negocio el cual incluye las clases para definir la
funcionalidad de nuestra aplicación, también conocido como las reglas de negocio de la aplicación.
5. Finalmente crearemos la clase CPJLaboratorioFinal, que significa
CursoProgramacionJavaLaboratorioFinal, el cual incluye un menú de opciones para escoger la opción
a procesar en el programa.
A continuación veremos a más detalle cada uno de los paquetes de la aplicación Catalogo de Peliculas a
desarrollar.
Esta clase nos servirá para representar el objeto Pelicula. En esta aplicación
dejamos simple la definición de este objeto, sin embargo podría tener más atributos
y hacer más compleja esta aplicación, pero el objetivo es que podamos desarrollar
esta aplicación con la estructura planteada, y no agregar más complejidad de la
necesaria para aplicar los conceptos estudiados a lo largo de este curso.
Por ello este objeto se debe codificar con lo indicado en el diagrama de clase
mostrado.
Esta interfaz define los métodos para interactuar con el archivo que administrará el
catálogo de películas. La clase AccesoDatosImpl es la que finalmente se encargará de
agregar el comportamiento de cada uno de los métodos descritos.
A partir de este proyecto empezaremos a separar los paquetes y clases según la

funcionalidad de cada una de ellas. En el caso del paquete de acceso a datos, su función
es definir la forma en que se interactúa con el archivo que es donde se almacenará la
información.
Sin embargo, el uso de interfaces y su implementación empieza a tomar importancia,

debido a que en el curso de Java con JDBC, en lugar de trabajar con la implementación
para un guardar la información en un archivo, agregaremos la implementación pero
escribiendo a una base de datos. Así que por ello es importante definir la interface que es
la que contiene los métodos que se utilizarán por otras clases en la aplicación, pero la
implementación podemos definir cual se va a utilizar, si por ejemplo una que guarde la
información en un archivo o alguna otra implementación que guarde la información en
base de datos.
Por último, cabe mencionar que la implementación de esta interfaz es completamente

técnica respecto al uso del manejo de archivos, por lo que a diferencia del paquete de
negocios que veremos a continuación, el paquete de datos, realiza las tareas más
técnicas que tienen que ver con la manipulación directa del archivo, en cambio, el
paquete de negocios se encarga más de definir las operaciones y funcionalidad desde el
punto de vista de lo que necesita realizar la aplicación, pero de alguna manera no le
interesa si la información se almacena o proviene de un archivo, ya que de eso se
encargará precisamente el paquete de datos.
El paquete de mx.com.gm.películas.negocio contiene las clases que

implementarán las reglas de negocio de nuestra aplicación. Y a su vez este es el
paquete que será el intermediario entre la interfaz con el usuario (método main) y
el guardado de la información (paquete de datos).
Similar al paquete da datos, este paquete hemos agregado también una interfaz y
una implementación. De esta manera la interfaz de usuario (método main) hará
uso de la interface, y será la implementación de CatalagoPeliculasImpl.java quien
finalmente ejecutará las tareas que sean necesarias para esta aplicación.
A su vez la implementación del catálogo de películas será quien utilice la interface

de AccesoDatos.java, por lo que al hacer uso de interfaces es que en cualquier
momento podríamos cambiar la implementación y afectaríamos lo menos posible al
código que ya hemos programado. A esta característica se le conoce como bajo
acomplamiento, ya que un cambio en un componente o una clase afecta lo menos
posible a otra clase, así que es sólo una de las muchas ventajas de programar
utilizando interfaces y no utilizar directamente la implementación de la
funcionalidad que necesitamos.
Esta clase representa la inteface con la que el usuario interactua. Esta clase solicita via consola la acción
requerida por parte del usuario, y solicita opciones como:
1.- Iniciar catalogo películas
2.- Agregar película
3.- Listar Películas
4.- Buscar Película
0.- Salir
Y dependiendo de la opción elegida por el usuario es la acción que se ejecuta.
Esta clase se apoya de la clase Catalogopeliculas para realizar las operaciones que necesita esta
aplicación.
A su vez la variable opción es la que se encargará de almacenar la opción seleccionada por parte del
usuario.
Y el nombre del archivo indica la ruta donde se almacenará el archivo. Por ejemplo, la cadena Java que
se puede utilizar si estamos en Windows es:
"c:\\catalogoPeliculas\\peliculas.txt“
Sin embargo si es otro sistema operativo, como MacOS, la ruta podría ser:
“/Volumes/gm/catalogoPeliculas/películas.txt “
Debemos recordar que la carpeta sobre la que vayamos a trabajar ya debe estar creada y en caso necesario debe
tener permisos de escritura, esto es particular de los requerimientos de cada sistema operativo.
Según hemos comentado, las opciones que muestra el menú de opciones para el usuario son:
1.- Iniciar catalogo películas
2.- Agregar película
3.- Listar Películas
4.- Buscar Película
0.- Salir
Y como vemos, dependiendo de la opción elegida por el usuario es la acción que se ejecuta. Así
que este es el menú que debemos programar para que el usuario pueda interactuar con la
aplicación.
Así que tenemos todo listo para comenzar a realizar la aplicación de Catálogo de Películas,
manos a la obra y te deseamos el mayor éxito en la realización de tu práctica final.

Datos de Contacto:

Crear el proyecto Catálogo de Películas. Al finalizar deberemos
observar lo siguiente:
Vamos a crear la clase:
Vamos a crear la clase :
Archivo Pelicula.java:
package mx.com.gm.peliculas.domain;
public class Pelicula {
String nombre;
public Pelicula(String nombre) {

this.nombre = nombre;
}
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

this.nombre = nombre;
}
@Override
public String toString() {
return this.nombre;
}
}
Archivo AccesoDatosEx.java:
package mx.com.gm.peliculas.excepciones;
/**
*
* @author gm
*/
public class AccesoDatosEx extends Exception{
String mensaje;
public AccesoDatosEx(String mensaje) {

this.mensaje = mensaje;
}
Archivo EscrituraDatosEx.java:
/**
*
* @author gm
*/
public class EscrituraDatosEx extends AccesoDatosEx{
public EscrituraDatosEx(String mensaje) {

super(mensaje);
}
Archivo LecturaDatosEx.java:
/**
*
* @author gm
*/
public class LecturaDatosEx extends AccesoDatosEx{
public LecturaDatosEx(String mensaje) {

super(mensaje);
}
Archivo AccesoDatos.java:
package mx.com.gm.peliculas.datos;
import java.util.List;
import mx.com.gm.peliculas.domain.*;
import mx.com.gm.peliculas.excepciones.*;
/**
* @author Ing. Ubaldo Acosta
* Interface para manejar datos, desde la creacion, lectura y escritura
*/
public interface AccesoDatos {
boolean existe(String nombreArchivo) throws AccesoDatosEx;
public List<Pelicula> listar(String nombreArchivo) throws LecturaDatosEx ;
void escribir(Pelicula pelicula, String nombreArchivo, boolean anexar) throws EscrituraDatosEx;
public String buscar(String nombreArchivo, String buscar) throws LecturaDatosEx;
public void crear(String nombreArchivo) throws AccesoDatosEx;
public void borrar(String nombreArchivo) throws AccesoDatosEx;

}
Archivo AccesoDatosImpl.java:
package mx.com.gm.peliculas.datos; Dar click para
import java.io.*;
import java.util.ArrayList; descargar el
import java.util.List;
import
import
mx.com.gm.peliculas.domain.*;
mx.com.gm.peliculas.excepciones.*;
código
public class AccesoDatosImpl implements AccesoDatos { completo
@Override
public boolean existe(String nombreArchivo) throws AccesoDatosEx {
File archivo = new File(nombreArchivo);
return archivo.exists();
}
@Override
public List<Pelicula> listar(String nombreArchivo) throws LecturaDatosEx {
File archivo = new File(nombreArchivo);
List<Pelicula> peliculas = new ArrayList();
try {
BufferedReader entrada = new BufferedReader(new FileReader(archivo));
String linea = null;
linea = entrada.readLine();
while (linea != null) {
Pelicula pelicula = new Pelicula(linea);
peliculas.add(pelicula);
linea = entrada.readLine();
}
entrada.close();
//El código completo se puede descargar dando click al nombre del archivo…
Archivo CatalogoPeliculas.java:
package mx.com.gm.peliculas.negocio;
/**
*
* Interface para administrar el catalogo de peliculas
*
* @author Ing. Ubaldo Acosta
*/
public interface CatalogoPeliculas {
public void agregarPelicula(String nombrePelicula, String nombreArchivo);
public void listarPeliculas(String nombreArchivo);
public void buscarPelicula(String nombreArchivo, String buscar);
public void iniciarArchivo(String nombreArchivo);
Archivo CatalogoPeliculasImpl.java:
package mx.com.gm.peliculas.negocio; Dar click para
import
import
java.util.List;
mx.com.gm.peliculas.datos.*;
descargar el
import mx.com.gm.peliculas.domain.*;
import mx.com.gm.peliculas.excepciones.*; código
public class CatalogoPeliculasImpl implements CatalogoPeliculas{ completo
private final AccesoDatos datos;
public CatalogoPeliculasImpl() {
this.datos = new AccesoDatosImpl();
}
@Override
public void agregarPelicula(String nombrePelicula, String nombreArchivo) {
Pelicula pelicula = new Pelicula(nombrePelicula);
boolean anexar = false;
try {
anexar = datos.existe(nombreArchivo);
datos.escribir(pelicula, nombreArchivo, anexar);
System.out.println("Error de acceso a datos");
ex.printStackTrace();
}
}
Archivo CPJLaboratorioFinal.java:
package cpjlaboratoriofinal; Dar click para
import java.util.Scanner;
import mx.com.gm.peliculas.negocio.*;
descargar el
public class CPJLaboratorioFinal { código
private static final Scanner scanner = new Scanner(System.in); completo
private static int opcion = -1;
private static final String nombreArchivo = "c:\\catalogoPeliculas\\peliculas.txt";
private static final CatalogoPeliculas catalogoPeli = new CatalogoPeliculasImpl();
//Mientras la opción elegida sea 0, preguntamos al usuario

while (opcion != 0) {
try {
System.out.println("Elige opción:\n1.- Iniciar catalogo peliculas"
+ "\n2.- Agregar pelicula\n"
+ "3.- Listar Peliculas\n"
+ "4.- Buscar Pelicula\n"
+ "0.- Salir");
opcion = Integer.parseInt(scanner.nextLine());
//Ejemplo de switch case en Java

switch (opcion) {
Ejecutamos el proyecto:
Con este ejercicio concluimos el curso de Programación con Java.
Hemos puesto en práctica muchos de los conceptos aprendidos, y hemos

dado una estructura robusta y flexible a nuestra aplicación, de tal manera
que pueda crecer según las necesidades que se vayan presentando.
Esperamos hayan aprendido y se hayan divertido tanto como nosotros lo

hemos hecho. Los esperamos en los próximos cursos de GlobalMentoring y
la Universidad Java, y así continúen con su especialización en el fabuloso
mundo de la tecnología Java.
!Hasta pronto¡
CURSO DE JAVA CON JDBC
Hola, te saluda Ubaldo Acosta. Bienvenidos nuevamente a este curso de

Java con JDBC (Java Database Conectivity).
En esta primera lección vamos a revisar una introducción a SQL

(Structured Query Language), así como su sintaxis básica. Esto será la
base de las sentencias SQL que ejecutaremos utilizando Java con JDBC, y
así aprender a interactuar con una base de datos utilizando Java.
Así, que si estás listo, nosotros también. Comencemos de inmediato.
SQL significa (Structured Query Language) es un lenguaje que nos permite

interactuar con una base de datos relacional.
Un motor de base de datos (RDBMS) permite administrar a las bases de datos.
Ejemplos de bases de datos son MySql, Oracle, SQLServer, Postgresql, etc.
Una base de datos contiene tablas relacionadas entre sí y cada tabla contiene
renglones y columnas que guardan cierta información, estos son solo algunos
de los conceptos utilizados en las bases de datos, a continuación vamos a
revisar algunos ejemplos de sentencias SQL y así observaremos cómo vamos a
manipular la información almacenada en una base de datos.
En SQL existen varias clasificaciones para poder interactuar con una base de
datos desde administrarla, manipular sus datos, hasta poder corregir
información errónea e incongruente dentro de una base de datos.
En particular para poder manipular la información almacenada de una base

de datos necesitamos utilizar lo que es concepto de DML o en ingles Data
Manipulation Language.
Las sentencias DML en SQL estándar se clasifican en distintas sentencias,

como son:
• Sentencia Select: Selecciona registros de la base de datos.

• Sentencia Insert: Inserta registros en la base de datos.
• Sentencia Update: Actualiza registros en la base de datos.
• Sentencia Delete: Elimina registros de una base de datos.
Ejemplos de sentencias DML son por ejemplo:
La sentencia select. En el ejemplo mostrado esta sentencia nos va a traer

todo lo registros que estén almacenados en la tabla de ALUMNOS.
Si queremos insertar algún registro necesitamos utilizar la sentencia INSERT

esta sentencia nos va a permitir agregar un nuevo registro en la tabla de
ALUMNOS.
A su vez la sentencia UPDATE nos permite actualizar los valores almacenados

en la base de datos, en la cual normalmente vamos a restringir los registros
modificados según queramos modificar la información, con el uso de WHERE.
Y por ultimo, también podemos eliminar información de cierta tabla, en este

caso la tabla ALUMNOS y también estamos restringiendo los registros que van
a ser modificados en la tabla ALUMNOS.
Estos fueron algunos de los ejemplos del uso de sentencias SQL. A

continuación vamos a instalar la base de datos MySql y vamos a poner en
práctica cada una de estas sentencias.

Datos de Contacto:

Instalar el motor de base de datos de Mysql. Al finalizar
Vamos a descargar mysql del siguiente link:
Windows:
http://icursos.net/software/mysql/mysql-installer.msi
Mac OS:
http://icursos.net/software/mysql/mysql-macos.dmg
Otros sistemas operativos:

http://dev.mysql.com/downloads/mysql/
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
( )
Con este ejercicio hemos instalado MySql. Este es el manejador
de base de datos que vamos a estar utilizando en varias de las
prácticas de este curso.
En el siguiente ejercicio crearemos una nueva base de datos,

crearemos una nueva tabla dentro de esta base de datos e
interactuaremos con la información que almacenará esta tabla
de base de datos.

05 Universidad de Java Desde Cero 5

Cargado por

Información del documento

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

05 Universidad de Java Desde Cero 5

Cargado por

Copyright:

Formatos disponibles

CURSO DE PROGRAMACIÓN CON JAVA

Vamos a estudiar el tema de excepciones en Java.

¿Estás listo? ¡Vamos!

En esta lección vamos a estudiar el tema de excepciones. Una excepción

Un ejemplo de excepción es por ejemplo, si un argumento es válido o no,

Existen muchas clases de Excepciones ya creadas en el API de Java para

El bloque finally es opcional, pero si se pone, siempre se va a ejecutar, aunque no ocurra la

En la figura podemos observar algunas de las excepciones más comunes en Java, y

De hecho podemos observar que RuntimeException es una subclase de la clase

El stacktrace (traza de la pila de errores) de una excepción es el conjunto

El log o bitácora de una aplicación normalmente incluye mensajes pero

Podemos observar en la figura de una manera más gráfica el mecanismo

Si una excepción no se atrapa con un bloque try/catch, se propaga la

Programación con Java Hibernate Framework

Sitio Web: www.globalmentoring.com.mx

public OperationException(String mensaje) {

public class Division {

public Division(int numerador, int denominador) throws OperationException {

public void visualizarOperacion() {

public class ManejoExcepciones1 {

public static void main(String[] args) {

public class ManejoExcepcionesArg {

public static void main(String args[]) throws OperationException {

• Este es el primero de los ejercicios que vamos a realizar

Vamos a estudiar el tema de excepciones en Java.

¿Estás listo? ¡Vamos!

En esta lección vamos a continuar revisando más temas acerca de las

Esto se puede deber a que el método no atrapó la excepción y por lo

Una excepción que extiende de Exception SÍ estamos obligados a

Una excepción que extiende de RuntimeException NO estamos obligados

La intención de crear nuestras propias clase de Excepción es personalizar los mensajes de

Porteriormente en la clase ArrojarExcepcion2 podemos observar que se lanzamos una

Vamos a revisar ahora el tema de uso de excepciones utilizando herencia. En el

Por otro lado, en la clase ArrojarExcepcion3 se arroja una subclase llamada

La intención de hacer esto, es que el método internamente puede arrojar

Programación con Java Hibernate Framework

Sitio Web: www.globalmentoring.com.mx

public class AccesoDatosEx extends Exception{

public AccesoDatosEx(String mensaje){

public class EscrituraDatosEx extends AccesoDatosEx{

public EscrituraDatosEx(String mensaje) {

public class LecturaDatosEx extends AccesoDatosEx{

public LecturaDatosEx(String mensaje) {

public interface AccesoDatos {

public abstract void insertar() throws AccesoDatosEx;

public abstract void listar() throws AccesoDatosEx;

public abstract void simularError(boolean simularError);

public class ImplementacionMySql implements AccesoDatos{

public boolean isSimularError() {

public class ManejoExcepciones2 {

public static void main(String[] args) {

//Cambiamos el estado a simularError = false

• Probar con distintos valores y lanzar excepciones padres e

• Pudimos observar cómo trabajar con excepciones de tipo

En esta lección vamos a revisar el tema de colecciones en Java.

Vamos a estudiar a continuación el tema de colecciones en Java. Una colección es un

Las colecciones se conocen también como Estructuras de Datos, ya que permiten

Una Lista es una colección ORDENADA, la cual sí permite duplicados.

A continuación te presentamos nuestro listado de cursos:

Lógica de Programación Hibernate Framework

Sitio Web: www.globalmentoring.com.mx

• Se pueden agregar más objetos y probar que todo funcione

Aunque hemos trabajado con el tipo de datos String, podemos