“Fundamentos de Java” Julio 2008

CURSO - TALLER
“Fundamentos de Java”

AUTOR DEL MANUAL: ÁNGEL CHATA T.

DOCENTE: JOSÉ DEL CARMEN CANCHUCAJA
VÍLCHEZ

Material compartido por el autor para la realización del curso, no utilizar para otros fines distintos a los de la capacitación.
Revisado y adaptado por José Canchucaja V.

Autor: Ing. Ángel Chata T. 0 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

INDICE
INDICE........................................................................................................................................ 1
Tema 1. CONCEPTOS BASICOS Y LENGUAJE DE PROGRAMACIÓN.................................................5
1.1. INTRODUCCION.............................................................................................................. 5
1.1.1 Características de Java...................................................................................................5
1.1.2. Java en la empresa.........................................................................................................5
1.1.3. Java en tu PC.................................................................................................................6
1.1.4. Java Virtual Machine (JVM)........................................................................................21
1.1.5. El recolector de basura (Garbage Collector)...............................................................22
1.2. TIPOS DE DATOS.......................................................................................................... 23
1.2.1 Variables........................................................................................................................23
1.3. OPERADORES............................................................................................................... 25
1.3.1. Operador de asignación...............................................................................................25
1.3.2. Operadores aritméticos................................................................................................25
1.3.3. Operadores Incremento y Decremento........................................................................25
1.3.4. Operadores de Comparación........................................................................................25
1.3.5. Operadores Lógicos.....................................................................................................26
1.3.6. Operadores Compuestos..............................................................................................26
1.3.7. Operadores con Cadenas..............................................................................................26
1.3.8. Precedencia de operadores...........................................................................................27
1.3.9. EJERCICIOS...............................................................................................................27
Ejercicio 2..............................................................................................................................27
1.4. CONTROL DE FLUJO....................................................................................................28
1.4.1 Bloques en Java............................................................................................................28
1.4.2. IF y ELSE....................................................................................................................29
1.4.3. IF anidados...................................................................................................................29
1.4.4. Errores comunes..........................................................................................................30
1.4.5. El operador condicional (?:)........................................................................................30
1.4.6. La sentencia SWITCH.................................................................................................31
1.4.7. EJERCICIOS...............................................................................................................32
1.5. LOS CICLOS REPETITIVOS..........................................................................................33
1.5.1. WHILE.........................................................................................................................33
1.5.2. DO...WHILE................................................................................................................34
1.5.3. EL CICLO FOR...........................................................................................................34
1.5.4. ERRORES COMUNES...............................................................................................34
1.5.5. LA SENTENCIA BREAK...........................................................................................34
1.5.6. LA SENTENCIA CONTINUE...................................................................................35
1.5.7 EJERCICIOS................................................................................................................35
Tema 2. PRINCIPIOS DE LA ORIENTACION A OBJETOS................................................................37
2.1. DEFINICION DE OBJETO..............................................................................................37
2.1.1. Un nuevo paradigma....................................................................................................37
2.2.2 Los objetos son una abstracción...................................................................................37
2.2. Encapsulamiento............................................................................................................ 38
2.3. Relaciones entre objetos.................................................................................................38
2.3.1 Asociación entre objetos...............................................................................................38
2.3.2 Composición de objetos................................................................................................39
2.4. Clases............................................................................................................................. 39
Autor: Ing. Ángel Chata T. 1 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Ejercicio................................................................................................................................. 40
2.5. Herencia......................................................................................................................... 40
2.6. Polimorfismo................................................................................................................... 40
Ejemplos................................................................................................................................41
Ejercicio.................................................................................................................................41
2.7. CLASES EN JAVA.......................................................................................................... 41
2.7.1. Paquetes.......................................................................................................................41
2.7.2. Modificadores de acceso..............................................................................................42
2.7.3. Creación de objetos......................................................................................................42
2.7.4. La referencia null.........................................................................................................43
2.7.5. Asignando referencias..................................................................................................43
2.8. Laboratorio. Uso de Objetos...........................................................................................44
2.9. Métodos.......................................................................................................................... 44
2.9.1. Argumentos..................................................................................................................45
2.9.2. Valores de retorno........................................................................................................45
2.9.3. Recursividad................................................................................................................45
2.9.4. Invocando métodos......................................................................................................46
Laboratorio............................................................................................................................46
2.10. Encapsulamiento.......................................................................................................... 47
Laboratorio............................................................................................................................47
2.11. Paso de variables a métodos........................................................................................47
Laboratorio............................................................................................................................48
Laboratorio............................................................................................................................48
Ejercicio.................................................................................................................................48
Tema 3. TRABAJANDO CON CLASES...........................................................................................50
3.1. DEFINICIONES INICIALES............................................................................................50
3.1.1. Sobrecarga de métodos................................................................................................50
3.1.2. Iniciación de variables de instancia.............................................................................50
3.1.3. Constructores...............................................................................................................51
3.1.4. La referencia this.........................................................................................................52
3.1.5. Variables de clase.........................................................................................................52
3.1.6. Métodos de clase..........................................................................................................53
3.2 EJERCICIOS................................................................................................................... 54
Ejercicio 1..............................................................................................................................54
Ejercicio 2..............................................................................................................................56
Tema 4. TRABAJANDO CON ARREGLOS......................................................................................57
4.1. DEFINICION DE ARREGLOS.........................................................................................57
4.1.1 Definición.....................................................................................................................57
4.1.2. Practica Guiada............................................................................................................57
4.2. ARREGLOS MULTIDIMENSIONALES............................................................................58
4.3. LABORATORIO.............................................................................................................. 59
4.3.1 Ejercicio........................................................................................................................59
4.3.2. Ejercicio.......................................................................................................................59
4.4. CADENAS...................................................................................................................... 60
4.4.1. Definición....................................................................................................................60
4.4.2. Construccion de cadenas..............................................................................................60
4.4.3. Concatenacion..............................................................................................................60
4.5. OPERACIONES CON CADENAS...................................................................................60
4.5.1. Longitud de una cadena...............................................................................................61
4.5.2. Ubicar un carácter mediante un indice........................................................................61
Autor: Ing. Ángel Chata T. 2 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

4.5.3. Extraer una subcadena.................................................................................................61

4.5.4. Convertir a mayúsculas o minúsculas..........................................................................61
4.5.5. Eliminar espacios del inicio y el final de la cadena.....................................................61
4.5.6. Ubicar una subcadena desde una ubicación.................................................................61
4.5.7. Comparando dos cadenas............................................................................................61
4.5.8. Comparando regiones de una cadena..........................................................................62
4.5.9. Obtener cadenas desde las primitivas..........................................................................62
4.5.10. Obtener primitivas desde las cadenas........................................................................62
4.5.11. EJERCICIOS.............................................................................................................62
4.6. ARREGLOS DE CADENAS............................................................................................63
4.6.1. Definicion....................................................................................................................63
4.6.2. Ejercicios.....................................................................................................................63
4.7. MAIN............................................................................................................................... 64
4.8 LABORATORIO............................................................................................................... 64
Segunda Parte........................................................................................................................67
Tema 5. HERENCIA Y POLIMORFISMO.........................................................................................69
5.1. HERENCIA..................................................................................................................... 69
5.1.1 Definición.....................................................................................................................69
5.1.2. La herencia en Java......................................................................................................69
5.1.3. La referencia super......................................................................................................70
5.1.4. Métodos.......................................................................................................................70
5.1.5. La referencia super......................................................................................................71
5.2. Polimorfismo................................................................................................................... 72
5.3. El operador instanceof y cast.........................................................................................74
5.4. Atributos, métodos y clases final.....................................................................................74
5.4.1. Variables final..........................................................................................................74
5.4.2. Métodos final...............................................................................................................74
5.4.3. Clases final...................................................................................................................74
5.5. El método finalize()......................................................................................................... 75
5.6. Ejercicio.......................................................................................................................... 76
5.7. Laboratorio...................................................................................................................... 77
Tema 6. CLASES ABSTRACTAS E INTERFASES.............................................................................81
6.1. CLASES ABSTRACTAS.................................................................................................81
6.2. Interfases....................................................................................................................... 82
Laboratorio............................................................................................................................83
EJERCICIO 1........................................................................................................................84
Ejercicio 2..............................................................................................................................85
Ejercicio adicional.................................................................................................................85
Tema 7. COLECCIONES DE OBJETOS..........................................................................................87
7.1. LA CLASE OBJECT........................................................................................................87
7.1.1. Convertir primitivas en referencias.............................................................................87
7.2. COLECCIONES.............................................................................................................. 87
7.2.1. Arquitectura.................................................................................................................88
7.2.2. Interfaces de colecciones.............................................................................................88
7.3. Ejemplo de clases implementadas. List..........................................................................89
7.3.1. Definiendo una clase....................................................................................................90
7.3.2. Mostrar los elementos de una colección. ArrayList.....................................................90
7.3.3. Evitar objetos duplicados. HashSet.............................................................................91
7.3.4. Manejar colecciones ordenadas. TreeSet.....................................................................93
7.3.5. Ordenar y buscar en Colecciones. Collections............................................................95
Autor: Ing. Ángel Chata T. 3 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

7.4. Ejemplo de clases implementadas. Map.........................................................................97

7.4.1. Ejemplo de HashMap..................................................................................................97
7.4.2. Ejemplo de TreeMap....................................................................................................98
7.5. EJERCICIO..................................................................................................................... 99
Tema 8. MANEJO DE EXCEPCIONES.........................................................................................100
8.1. EXCEPCIONES............................................................................................................ 100
8.1.1. Definiciones...............................................................................................................100
8.1.2. Características del Java..............................................................................................100
8.1.3. Excepciones...............................................................................................................101
8.1.4. Throwable..................................................................................................................102
8.1.5. Que se puede hacer con una Excepción?...................................................................102
8.2. EXCEPCIONES CON JAVA..........................................................................................103
8.2.1. Como capturar y manejar una excepción...................................................................103
8.2.2. Capturando una excepción.........................................................................................103
8.2.3. Capturando múltiples excepciones............................................................................103
8.2.4. Ejecución del bloque finally......................................................................................104
8.2.5. Como pasar la excepción al método invocado..........................................................105
8.2.6. Como lanzar una excepción.......................................................................................105
8.2.7. Como crear una excepción.........................................................................................106
8.2.8. Como capturar una excepción y lanzar otra diferente...............................................106
8.3. LABORATORIO............................................................................................................ 106
8.4. EJERCICIO................................................................................................................... 107
Tema 9. Aplicaciones con Bases de datos en Java.................................................................109
9.1. Conectividad JDBC.......................................................................................................109
9.1.1. Definiciones iníciales.................................................................................................109
9.1.2. Acceso JDBC a base de datos....................................................................................110
9.1.3. Tipos de drivers..........................................................................................................111
9.2. Puente 1. JDBC-ODBC.................................................................................................111
9.2.1 Ventajas.......................................................................................................................112
9.2.2 Desventajas.................................................................................................................112
9.2.3 Resumen......................................................................................................................112
9.3. Java Binario.................................................................................................................. 112
9.3.1 Ventajas.......................................................................................................................113
9.3.2 Desventajas.................................................................................................................113
9.3.3 Resumen......................................................................................................................113
9.4. Java Protocolo independiente.......................................................................................113
9.4.1 Ventajas.......................................................................................................................114
9.4.2 Desventajas.................................................................................................................114
9.4.3 Resumen......................................................................................................................114
9.5. Lista de drivers y de cadenas de conexión....................................................................114
9.6. Ejemplo de una consulta sencilla..................................................................................116

Autor: Ing. Ángel Chata T. 4 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 1. CONCEPTOS BASICOS Y LENGUAJE DE PROGRAMACIÓN

Resumen
Se estudiara los elementos básicos del lenguaje Java, variables, operadores y control de flujo.

1.1. INTRODUCCION.

1.1.1 Características de Java

Simple
Reduce en un 50% los errores más comunes de programación en lenguajes como C y C++ al eliminar
aritmética de punteros, referencias, necesidad de liberar memoria.
Robusto
Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de
ejecución.
Arquitectura neutral
El código compilado tiene un formato independiente de la arquitectura de la máquina en que se
ejecutará.
Seguro
No usa punteros para prevenir el acceso ilegal a la memoria.
Interpretado
Requiere un runtime (JRE) para ser ejecutado, lo que lo hace 10 veces mas lento que un programa C
compilado.
Orientado a objetos
Soporta las tres características propias del paradigma de la orientación a objetos: encapsulamiento,
herencia y polimorfismo
Distribuido
Se ha construido con extensas capacidades de interconexión TCP/IP, presenta librerías con protocolos
http y ftp para obtener información a través de la red.

1.1.2. Java en la empresa.

Java para aplicaciones corporativas

Allí donde la red sea algo crítico, Java facilita la programación corporativa.

Desarrollo rápido de aplicaciones

Java facilita la creación de entornos de desarrollo de aplicaciones mediante el uso de frameworks y
patrones.

Aplicaciones efectivas y eficientes

Las grandes empresas prefieren programas que se desarrollen rápidamente y funcionen a que lo haga
eficientemente.

Portabilidad para programador y programa

La empresa es una pléyade de computadores (PC, Mac, HP, Linux, Windows,...), pero el mismo
programa funcionara en cualquier estación con el mismo programador.

Costos de desarrollo
La llegada de Java e Intranet ha reducido los costos de las aplicaciones, además es creciente el software
gratuito por explotar.

Autor: Ing. Ángel Chata T. 5 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1.1.3. Java en tu PC.

Los programas tienen extensión.java (Hola.java)

Usa el Java Developer Kit (JDK) para compilar el código fuente. (javac.exe)
Genera un compilado con extensión .class (Hola.class)
Usa el Java Virtual Machine (JVM) como interprete (java.exe)

Hola.java

Errores JDK (javac.exe)

Hola.class

JVM(java.exe)

Lenguaje Maquina

Instalación del Java

1. El JDK y el JVM están disponibles en http://java.sun.com en un solo paquete conocido como J2SE.

De clic en el
enlace Java SE

El ejecutable puede ser el siguiente:

jdk-6u5-windows-i586-p.exe
Autor: Ing. Ángel Chata T. 6 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

El cuál fue el correspondiente a la última versión al momento de revisar éste manual.

De clic en
éste botón

De clic en
éste botón

Autor: Ing. Ángel Chata T. 7 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1. Seleccione
la plataforma

2. Seleccione
su idioma

3. Acepte la
licencia

4. De clic en
éste botón

1. De clic
aquí

2. De clic en
éste enlace

Autor: Ing. Ángel Chata T. 8 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

2. En Windows se puede instalar el ejecutable por ejemplo en el directorio

C:\Archivos de programa\Java\jdk1.6.0_05

Ejecute el instalador y acepte de preferencia todas las características ofrecidas.

Acepte la licencia, para ello de clic en el botón Accept.

De clic en el botón Next.

Autor: Ing. Ángel Chata T. 9 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

3. Adicionalmente se debe configurar la PC para que se reconozca su ubicación (Path); por ejemplo en
Windows XP seria:

3.1 Mi PC / Propiedades

3.2 En el diálogo Propiedades del Sistema elija la ficha Opciones avanzadas

3.3 En la ficha Opciones avanzadas de clic en el botón Opciones avanzadas

Autor: Ing. Ángel Chata T. 10 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

De clic en
éste botón

3.4 En el diálogo Variables de Entorno debe crear la variable Path usando el

botón Nueva, si es que ya no existe.

En caso que exista la variable Path elija dicha variable y edítela haciendo
uso del botón Modificar.

3.5 Ahora debe modificar o ingresar por primera vez el valor de la variable
Path

Autor: Ing. Ángel Chata T. 11 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Debe adicionar la ruta donde se halla el directorio bin del JDK que ha
instalado, le recomiendo buscar en: C:\Archivos de programa\Java

En la figura de arriba la ruta del directorio bin es:

C:\Archivos de programa\Java\jdk1.6.0_05\bin

Si en el valor de la variable Path ya existe un valor, cópielo al bloc de

notas (Notepad) o a un editor cualquiera. Por ejemplo si tengo el siguiente
valor:

C:\Archivos de programa\IDM Computer Solutions\UltraEdit-32

Le agrego la ruta anterior de la siguiente manera:

<Ruta anterior> ; <Ruta del bin del JDK del Java>

En el ejemplo sería:

3.6 Ahora debe pegar el contenido del editor y reemplazar el valor de la

variable como se aprecia en la figura de abajo:

Autor: Ing. Ángel Chata T. 12 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

3.7 Para finalizar de clic en el botón Aceptar.

4. En Linux se debe instalarlo en un directorio como /usr/java/jdk1.3.1:

# rpm -ivh jdk-1.3.1.i386.rpm

5. Para cambiar el path debe realizar:

PATH=/usr/java/jdk1.3.1
export PATH

Instalación del NetBeans

Paso 1: Entrar a la página http://www.netbeans.org/ y descargar el instalador

De clic en éste botón

para descargar el
instalador

Luego aparecerá una página donde se le solicitará su correo electrónico y que

elija una de varias opciones, seleccione la que considere más apropiada a su
nivel de experiencia, recomiendo la opción: Java SE para los que se inician en
Java.

Autor: Ing. Ángel Chata T. 13 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Paso 2: Una vez descargado NetBeans, instale el programa.

Siga las instrucciones seleccionando el botón Next en todos los casos.

Autor: Ing. Ángel Chata T. 14 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

De clic en éste botón

para personalizar el De clic en éste botón
instalador para continuar

Autor: Ing. Ángel Chata T. 15 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 16 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 17 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 18 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Finalmente puede registrarse usando una cuenta de correo como usuario.

Autor: Ing. Ángel Chata T. 19 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Características de un programa Java.

 El nombre de la clase debe ser igual al nombre del archivo.

 Se debe respetar las mayúsculas y minúsculas, es “case sensitive”.
 El nombre del archivo tiene extensión java.
 Los comentarios se colocan entre /* y */ o se inician con //
 La clase se encierra entre { y }
 Los métodos también se encierran entre { y }, como el método main.
 Las sentencias (acciones) se terminan con punto y coma.
 Se usa el punto para evocar atributos o métodos de una clase.
 Los argumentos de los métodos se colocan entre ( y ).
 Se usa la identación para obtener un código más legible.

Ejemplo: Crear un programa para saludar a los que se inician con Java

Paso 1: Crear la carpeta Curso_Java en el disco C: o en el que prefiera.

Paso 2: Cargue el bloc de notas (Notepad). Para eso de clic el botón Inicio
del Windows, luego seleccione Ejecutar…, digite lo de abajo

notepad C:\Curso_Java\Hola.java

Y presione la tecla [Enter]. A la pregunta:

Responda que si: de clic en el botón Si.

Paso 3: Luego digite lo siguiente:

/* Primer programa java */
public class Hola {
public static void main(String[] args) {
System.out.println("Hola desde java");
}
}

Ejecución de un programa Java

1. Para compilar un programa java se usa el javac.exe, el programa se

encuentra en el directorio bin del JDK y está ya en el Path del sistema por lo
tanto lo podemos ejecutar desde cualquier lugar. De clic el botón Inicio del
Windows, luego seleccione Ejecutar…, digite

cmd
Autor: Ing. Ángel Chata T. 20 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Y presione la tecla [Enter]. En el DOS entre al directorio de curso, para

ello:
1.1. Digite: C: y presione la tecla [Enter].
1.2. Digite: CD Curso_Java y presione la tecla [Enter].
1.3. Compile el programa use el programa javac.exe, para ello digite

C:\Curso_Java>javac Hola.java
Y presione la tecla [Enter].

2. Para ejecutar el programa ya compilado (seudo compilado, en bytecode) se usa el java.exe. El código
Java se suele trasmitir como bytecode a la máquina receptora, que utiliza un compilador just-in-time para
traducir el bytecode en código máquina antes de su ejecución.

C:\java>java Hola
Y presione la tecla [Enter]. Saldrá:
Hola desde java

4. Al ejecutar un programa java, el JVM empieza a buscar el método main de la clase principal para
ejecutarlo.

1.1.4. Java Virtual Machine (JVM)

JDK y JRE

El JDK es un conjunto de programas que incluye al JVM, y es el acrónimo de Java Development Kit, que
traducido sería Paquete de desarrollo de Java. Comprende a lo siguiente:

 JRE (Java Runtime Environment): Entorno de ejecución de Java.

 Compilador de Java: javac.exe el que se encuentra dentro del directorio bin del JDK
 Programa de ejecución de Java: java.exe el que se encuentra dentro del directorio bin del JDK

JRE es el acrónimo de Java Runtime Environment (entorno en tiempo de ejecución Java) y se

corresponde con un conjunto de utilidades que permite la ejecución de programas java sobre todas las
plataformas soportadas.

JVM (máquina virtual Java) es una instancia de JRE en tiempo de ejecución, este es el programa que
interpreta el código Java y además por las librerías de clases estándar que implementan el API de Java.
Ambas JVM y API deben ser consistentes entre sí, de ahí que sean distribuidas de modo conjunto.

Un usuario sólo necesita el JRE para ejecutar las aplicaciones desarrolladas en lenguaje Java, mientras
que para desarrollar nuevas aplicaciones en dicho lenguaje es necesario un entorno de desarrollo,
denominado JDK, que además del JRE (mínimo imprescindible) incluye, entre otros, un compilador para
Java.

Resumiendo:

El JRE es suficiente para un usuario de aplicaciones hechas en Java. Peor si la aplicación es Web, dicho
usuario ya no lo necesita.

JRE = JVM + API de Java

Autor: Ing. Ángel Chata T. 21 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

El JDK es necesario para quienes desarrollan aplicaciones en Java ya sean aplicaciones cliente servidor o
aplicaciones distribuidas incluyendo a las aplicaciones Web.

JDK = JRE + Paquete de desarrollo de aplicaciones de Java

Lo que usted necesita saber es que para cada sistema operativo (o plataforma operativa) existe un JDK y
por consiguiente un JRE apropiado, por lo que debe descargare el que corresponde a su sistema
operativo preferido.

La buena noticia es que el programa que usted desarrolle por ejemplo en Windows y luego compilado
también en Windows puede correr en Linux o en Unix, etc. sin mayores problemas, salvo que usted haya
puesto instrucciones particulares para el sistema operativo en el que ha desarrollado los programas.

Por eso le sugerimos no salirse de los estándares impuestos por Java, en el curso le ayudaremos a no
salirse de los mismos.

“Write once and run everywhere”, escriba una vez su programa y ejecute donde quiera sin cambios.

1.1.5. El recolector de basura (Garbage Collector)

El concepto de recolección de basura fue inventado por John McCarthy en 1959 para evitar la gestión
manual de memoria en el lenguaje Lisp.

¿Cómo funciona?

Cuando un lenguaje dispone de recolección de basura, el programador no tiene que invocar a una
subrutina para liberar memoria. La reserva de memoria también es más o menos automática sin la
intervención del programador. Por ejemplo:

 En los lenguajes orientados a objetos: se reserva memoria cada vez que el programador crea un
objeto, pero éste no tiene que saber cuanta memoria se reserva ni cómo se hace esto.
 En los lenguajes declarativos: cada vez que se construye una expresión se reserva memoria (de
una manera inteligente), pero el programador no es consciente de ello.

Al compilar el programa, automáticamente se incluye en éste una subrutina correspondiente al recolector

de basura. Esta subrutina también es invocada periódicamente sin la intervención del programador.

El recolector de basura es informado de todas las reservas de memoria que se producen en el programa.
Además, el compilador colabora para que sea posible llevar una cuenta de todas las referencias que
existen a un determinado espacio de memoria reservado.

Cuando se invoca el recolector de basura, recorre la lista de espacios reservados observando el

contador de referencias de cada espacio. Si un contador ha llegado a cero significa que ese espacio de
memoria ya no se usa y, por tanto, puede ser liberado.

El único inconveniente a este mecanismo es determinar cuándo se tiene que ejecutar el recolector de
basura. Existen varios algoritmos para hacerlo, pero el más eficiente es el primero de ellos:

 Esperar a que no quede memoria libre, y entonces, ejecutar el recolector de basura.

 Fijar un umbral de ocupación de la memoria libre y ejecutar el recolector de basura cuando se
supere dicho umbral.
 Ejecutar el recolector de basura a intervalos regulares (no siempre es posible).
 Ejecutar el recolector de basura justo antes de cada reserva de memoria.
 Permitir al programador que invoque explícitamente al recolector de basura cuando quiera.

Autor: Ing. Ángel Chata T. 22 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

En resumen:

El entorno de ejecución de Java dispone de un recolector de basura (garbage collector) que limpia de la
memoria los objetos no utilizados.

 Cuando un objeto no se puede referenciar (acaba la vida de la variable de referencia) marca el

objeto como basura.
 Cuando lo considere oportuno el recolector de basura lo eliminará
 No es un destructor.
 El método finalize() se ejecuta antes de eliminarlo.
 Se puede utilizar para realizar otras operaciones de limpieza, cerrar archivos, etc.

1.2. TIPOS DE DATOS

1.2.1 Variables

1. Es una unidad básica de almacenamiento.

2. En Java debe ser declarada antes de utilizarse.
3. Cada variable tiene un tipo y un identificador.
4. Es un nombre simbólico con un valor.
5. Las variables pueden ser iniciadas.
6. La plantilla de declaración de variables es:
tipo identificador = valor;
7. Ejemplos de declaración de variables:
int miEdad = 36;
boolean estaAprobado = true;
double costoMaximo = 17.98;

Estándares

1. Nombres de archivos fuente: Cliente.java, Hola.java, Producto.java

2. Nombres de programas, clases: Cliente, Hola, Producto.
3. Nombres de métodos, funciones: obtenerCliente, imprimirHola, alquilarProducto.
4. Nombres de variables: nombreCliente, limiteCreditoCliente.
5. Nombres de constantes: PI, MÁXIMO_NUMERO_ITEMS, ANCHO_MINIMO.
6. Java es “case-sensitive” por lo que:
“cliente” es diferente de “Cliente” y es diferente de “CLIENTE”.

Nombre de Variables

1. Deben empezar con una letra del alfabeto ingles o subrayado.

2. Los siguientes caracteres pueden ser dígitos.
3. No se deben usar palabras reservadas.
4. Las palabras reservadas son aquellas propias del lenguaje Java como:
public, void, static, boolean, float, int, class, true, false, null, for, if,
else, extends ...
5. El estándar es iniciar con minúscula y usar mayúsculas para nuevos significados.
6. Ejemplos de nombre de variables

Correcto Pasable Incorrecto

costo costo_Item costo#item
costoItem _costoItem class
costoItem2 costoItemfacturado 2costoItem
costoItemFacturado costoitem costo-item

Autor: Ing. Ángel Chata T. 23 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tipos de Variables

1. Los principales tipos de variables son:

int Desde -2^31 hasta +2^31

long Desde -2^63 hasta +2^63
float Es un numero decimal de 32 bits.
double Es un numero decimal de 64 bits.
char Es un solo carácter, como letra o digito o carácter especial.
boolean Almacena valores de verdad como true o false.

2. Las cadenas no son un tipo de variable sino una Clase de tipo String

String Cadena de caracteres.

Declaración de Variables
1. La forma básica de declarar variables es:
tipo identificador = valor;
2. Las variables de instancia se pueden usar en cualquier lugar de la clase.
3. Las variables locales se pueden usar solo en el ámbito donde son declarados.

Ejercicio
C:\java>notepad Variables.java
public class Variables {
/* Variables instancia */
public static int peliculasAlquilados = 0;

public static void main(String[] args) {

/* Variables locales */
double tasaDeInteres = 0.15;
int peliculasEnStock = 50;
int numeroDeDias = 3;
char categoriaDePelicula = 'G';
System.out.println(peliculasAlquilados);
System.out.println(tasaDeInteres);
System.out.println(peliculasEnStock);
System.out.println(numeroDeDias);
System.out.println(categoriaDePelicula);
}
}

Compilación:

C:\java>javac Variables.java

Ejecución:

C:\java>java Variables

Resultado:

0
0.15
50
3
G

Autor: Ing. Ángel Chata T. 24 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1.3. OPERADORES

1.3.1. Operador de asignación

1. La expresión de la derecha se asigna a la variable de la izquierda.
2. La expresión de la derecha se evalúa antes de la asignación.

int costo = 0, total = 0;

costo = 50;
total = costo + 10;
total = total + 5;
int var1 = 0, var2 = 0;
var1 = var2 = total = 50;

1.3.2. Operadores aritméticos

1. Realizan las operaciones aritméticas básicas.
2. Trabajan sobre variables numéricas.

int a, b, c, d;
a = 2 + 2; // adicion
b = a * 3; // multiplicacion
c = b - 2; // substraccion
d = b / 2; // division
e = b % 2; // resto de la division (modulo)
a = a – 1;

Los datos byte, char y short se convierten en int después de una operación
Si un operando es long, el otro se convierte en long y la respuesta será long.

byte b1 = 1, b2 = 2, b3;
b3 = b1 + b2 // error el resultado es entero

1.3.3. Operadores Incremento y Decremento

1. El operador ++ incrementa en 1 la variable que acompaña.
2. El operador - - decrementa en 1 la variable que acompaña.

int var1 = 3;
var1 ++;
int var1 = 3, var2 = 0;
var2 = ++var1; // Se incrementa var1 y luego se asigna a var2;
var2 = var1++; // Se asigna a var2 y luego se incrementa var2;

int nota = 17, pendientes = 10;

nota++; // es idéntico a nota = nota + 1;
pendientes--; // es idéntico a pendientes = pendientes - 1;

1.3.4. Operadores de Comparación

1. Son relaciones de igualdad y desigualdad.
2. Se debe diferenciar el operador de comparación con el operador de asignación

boolean valor;
int a = 1, b = 2, c = 3, d = 4, e = 3;

Autor: Ing. Ángel Chata T. 25 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

valor = b > a; // mayor que

valor = b >= a; // mayor igual que
valor = c < d; // menor que
valor = c <= d; // menor igual que
valor = a != d; // diferente que
valor = c == e; // igual que

int nivelBuenCredito = 3;
int nivelCreditoCliente;
boolean esBuenCredito = false;
esBuenCredito = (nivelCreditoCliente == nivelBuenCredito);

1.3.5. Operadores Lógicos

1. Los resultados de las operaciones de comparación pueden combinarse con operadores lógicos.

boolean valor;
int a = 1, b = 2, c = 3;
valor = (b > a) || (a > b) ; // operación logica OR
valor = (b > a) && (c > b); // operación logica AND
valor = !(a > b); // operación logica NOT

OR AND NOT
F || F = false F && F = false !F = true
F || T = true F && T = false !T = false
T || F = true T && F = false
T || T = true T && T = true

1.3.6. Operadores Compuestos

1. La operación de asignación puede combinarse con operadores aritméticos como + y -

//
int total = 0, cantidad = 10;
total += cantidad; // asignación con incremento
total -= 3; // asignación con decremento
total *= 2; // asignación con multiplicación
//
int diasDeAlquiler;
diasDeAlquiler = diasDeAlquiler + 3;
diasDeAlquiler += 3;
//
double total = 0, num = 1;
double porcentaje = 0.50;
total = total + num;
total += num;
total -=num;
total *= porcentaje;

1.3.7. Operadores con Cadenas.

1. A la colección de caracteres se les llama cadenas.
2. Los datos de tipo String almacenan cadenas.
3. El operador + tambien puede encadenar dos datos de tipo String.

String nombre = "Isaac";

Autor: Ing. Ángel Chata T. 26 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

String apellido = "Asimov";

String nombreCompleto = nombre + “ ” + apellido;
String letras = "Hola, soy una cadena";
char letrita = 'c';

1.3.8. Precedencia de operadores

operadores sufijo expr++ expr--
operadores unarios +expr -expr !
multiplicadores * / %
suma/resta + -
relacionales < > <= >=
igualdad == !=
AND lógico &&
OR lógico ||
condicional ? :
asignación = += -= *= /= %=

 Determina el orden en el cual se ejecutan los operadores

 Operadores con la misma precedencia se realizan de izquierda a derecha
 Usa el paréntesis para cambiar este orden.

int var1 = 0;
var1 = 2 + 3 * 4;
var1 = 12 – 6 + 3;

1.3.9. EJERCICIOS

Ejercicio 1
Encuentre los errores en el siguiente código:

1. int class = 200;

2. short texto = 43;
3. short hola mundo;
4. int boolean3 = boolean + boolean + boolean;
5. long almuerzo = entrada + sopa + segundo ; // falta postre
6. double viejo = 78.3;
7. doble nuevo = 0.1;
8. boolean consecuezia = true;
9. boolean maximo = 7 > 3;
10. char calle = "Via expresa";
11. char rio = 'N';
12. boolean causa = 7;
13. boolean igualdad = "true";
14. double precio = S/.20.50;
15. int uno = 3;
16. long cinco = uno + uno + uno;
17. boolean comparacion = cinco > uno;

Ejercicio 2.
/* Ejercicio:
* Se pide calcular el costo del alquiler de dos peliculas
* por dos 2 dias.
* Odisea 2001 = 2.95 por dia

Autor: Ing. Ángel Chata T. 27 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

* El padrino = 3.50 por dia

* Impuesto = 17%
*
* Pero solo se tiene un billete de 10.
* Se pueden alquilar?
*/
public class Operadores {

public static void main(String[] args) {

// Declaracion de variables
double pelicula1;
double pelicula2;

// Asignacion de valores
pelicula1 = 2.95;
pelicula2 = 3.50;

// Estas 4 sentencias pueden ser combinadas en una sola:

// double pelicula1 = 2.95, pelicula2 = 3.50;

// Otras variables a usar en este programa

int numeroDeDias = 2;
boolean alquilar;
double totalAlquiler, total, porcentajeImpuesto = 1.17;

// Muestra el precio de los dos peliculas

System.out.println("Odisea 2001 : " + pelicula1);
System.out.println("El Padrino : " + pelicula2);

// Calcula el alquiler total

totalAlquiler =pelicula1*numeroDeDias + pelicula2*numeroDeDias;
System.out.println("Total Alquiler = " + totalAlquiler);

// Calcula el total de la venta aplicando el impuesto

total = totalAlquiler*porcentajeImpuesto;
System.out.println("Total Venta = " + total);

// Verifica si se pueden alquilar

alquilar = total < 10;
System.out.println("Puedo Alquilar? " + alquilar);

}
}

C:\java>javac Operadores.java
C:\java>java Operadores
Odisea 2001 : 2.95
El Padrino : 3.5
Total Alquiler = 12.9
Total Venta = 15.093
Puedo Alquilar? false

1.4. CONTROL DE FLUJO

Autor: Ing. Ángel Chata T. 28 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1.4.1 Bloques en Java

El código se ejecuta secuencialmente por defecto
Un conjunto de sentencias requieren de llaves { } para agruparse como un bloque.
El bloque entre llaves { } se conoce también como sentencia compuesta.
Una sentencia simple es una expresión que termina con punto y coma.
var1 += var2++ + 4;
Cada bloque se ejecuta como una única sentencia dentro del flujo.
{
int i = 0;
boolean termino = true;
System.out.println("i = " + i);
i++;
}

1.4.2. IF y ELSE
Esta sentencia provee una selección de procesos básico. Una expresión boleana controla que sentencia
se ejecutara. Si la expresión es true, se realizara la primera expresión es false se realizara la segunda.

SINTAXIS

if (<Condición Lógica>) <Instrucción>; // La clausula else es opcional.

============================
if (<Condición Lógica >) <Instrucción>;
else <Instrucción>;

============================
if (<Condición Lógica >) {
_________;
_________;
}
else {
_________;
_________;
}
Ejemplos:
if ( i % 2 == 0 )
System.out.println("Es par");
else
System.out.println("Es impar");
//
if (diasDeAlquilerTranscurridos > diasAlquilerContratados )
System.out.println("Primero pagar moras por alquiler");
else
System.out.println("Puede alquilar nuevas peliculas");
//
if ( numero > 0 ) {
System.out.println("El numero es positivo");
}
//
if (mes <= 7) System.out.println("El impuesto es 18%");
else System.out.println("El impuesto es 19%");

1.4.3. IF anidados
Cuando se requieren muchas condiciones, se pueden anidar sentencias IF.
Autor: Ing. Ángel Chata T. 29 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Debe tener cuidado en el correcto uso de la sentencia ELSE

if (velocidad >= 30)

if (velocidad > 100)
System.out.println("Vamos muy rapido");
else
System.out.println("Llegaremos a tiempo.");
else
System.out.println("Que lento vamos");
//
if (velocidad >= 100)
System.out.println("Vas muy rapido");
else if (velocidad > 30)
System.out.println("Vas manejando bien.");
else
System.out.println("Vas muy lento");

Este enfoque es utilizado poco, ya que se crea un código algo complicado de entender.
Es preferible usar las llaves { } para separar los bloques.

//
if (velocidad >= 25) {
if (velocidad > 100) {
System.out.println("Vamos muy rapido!");
}
else {
System.out.println("Llegaremos a tiempo");
}
}
else {
System.out.println("Que lento es la movilidad");
}

1.4.4. Errores comunes.

Encuentre los errores en los siguientes ejemplos.

int x = 3, y = 5;
if ( x >= 0)
if ( y < x )
System.out.println("y es menor que x");
else
System.out.println("x es negativo");

//
int x = 7;
if ( x = 0) // if (x == 0)
System.out.println("x es cero");

//
int x = 15, y = 24;
if ( x % 2 == 0 && y % 2 == 0 );
System.out.println("x e y son pares");

1.4.5. El operador condicional (?:)

Es una alternativa a la estructura if..else
Autor: Ing. Ángel Chata T. 30 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

if (mes <= 7)
impuesto = 0.18;
else
impuesto = 0.19;

Es una expresión que retorna un valor.

Si la expresión lógica es verdadera se obtiene el primer valor.
Si la expresión lógica es falsa se obtiene el segundo valor.

impuesto = ( mes <= 7 ) ? 0.18 : 0.19;

1.4.6. La sentencia SWITCH

Es usada cuando se requiere tomar una accion entre varias en base a una expresión.

 La expresión debe ser byte, char, short o int.

 No puede ser un long, double, float, String o cualquiere otro tipo.
 Si la expresión se iguala a una condicion, esta se ejecuta.
 Si no se iguala a ninguna condicion, se realiza la sentencia marcada con default.
 Las condiciones deben ser constantes.
 Use break para salir del switch
 Siempre coloque una opcion default.

int dia
switch (dia) {
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("Tienes que ir a trabajar");
break;
case 6:
case 7:
System.out.println("Quedate en casa");
break;
default:
System.out.println("En que planeta vives?");
}
char letra='e';
switch(letra);
{
case 'a':
case 'A':
case 'e':
case 'E':
case 'i':
case 'I':
case 'o':
case 'O':
case 'u':
case 'U':
printf("Es una vocal");
break;
default: printf("Es una consonante");
}
Autor: Ing. Ángel Chata T. 31 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

1.4.7. EJERCICIOS

Ejercicio 1
// Que es la Edad?
public class Edad {
public static void main (String [] arg)
{
int edad = 15;
if (edad <= 18)
System.out.println ("Eres un niño");
System.out.println ("La edad es un estado mental");
}
}

Ejercicio 2
// La mejor Nota
public class Nota {
public static void main (String [] arg)
{
int tuNotaFinal = 17;
int miNotaFinal = 12;
int mejorNotaFinal ...

System.out.println ("La mejor nota es: " + mejorNotaFinal);

}
}

Ejercicio 3
// En MegaPlaza se hace un 20% de descuento a los clientes
// cuya compra supere los 300
// ¿Cual será la cantidad que pagara una persona por su compra?
C:\java>notepad Compra.java
public class Compra {

public static void main(String[] args) {

double compra, descuento, total;
compra = 410;
descuento = compra*0.20;
total = compra - descuento;
if (compra>300) {
System.out.println("El descuento es de: " + descuento);
System.out.println("El total a pagar es: " + total);
}
else
System.out.println("Sin descuentos, el total es:" + total);
}
}
C:\java>javac Compra.java
C:\java>java Compra
El descuento es de: 82.0
El total a pagar es: 328.0

Ejercicio 4
Un obrero necesita calcular su salario semanal, el cual se obtiene de la
siguiente manera:
Si trabaja 40 horas o menos se le paga $16 por hora

Autor: Ing. Ángel Chata T. 32 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Si trabaja mas de 40 horas se le paga $16 por cada una de las primeras 40
horas y $20 por cada hora extra.

C:\java>notepad Salario.java
public class Salario {

public static void main(String[] args) {

int horasTrabajadas, horasExtras, salarioSemanal;

horasTrabajadas = 47;

if ( horasTrabajadas > 40 ) {
horasExtras = horasTrabajadas - 40;
salarioSemanal = horasExtras * 20 + 40 * 16;
System.out.println("El salario con horas extras es de " +
salarioSemanal);
}
else {
salarioSemanal = horasTrabajadas * 16;
System.out.println("Su sueldo es de " + salarioSemanal);
}
}

Ejercicio 5
// Un año es bisiesto si es divisible por 4
// excepto aquellos divisibles por 100 pero no por 400
// Según el año determine la cantidad de dias de un mes.
//
public class Mes {
public static void main (String [] arg)
{
int anio = 1948;
int mes = 02;
int dias;
...
System.out.println ("Tiene "+dias+" dias");
}
}

1.5. LOS CICLOS REPETITIVOS

1.5.1. WHILE
El while es la forma mas simple de un bucle.
Tiene la siguiente forma:

int i = 1; // inicializacion
while (i<=10) { // condicion de repeticion
System.out.println(i*3.5); // cuerpo
i++; // iteracion
}

El cuerpo se realizara mientras la condición de repetición sea verdadera true

Autor: Ing. Ángel Chata T. 33 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1.5.2. DO...WHILE
Realiza la condicion de repetición al finalizar el bloque.

Tiene la siguiente forma:

int i = 1; // inicializacion
do {
System.out.println(i*3.5); // cuerpo
i++; // iteracion
} while ( i <= 10 ) // condicion

1.5.3. EL CICLO FOR

Combina en una sentencia la definición de un ciclo repetitivo.
Para el caso del tipo de cambio, el código fuente será:

for (int i=1; i<=10; i++) {

System.out.println(i*3.5);
}

La inicialización y la iteración puede ser compuesta.

for (int i=0, j=10; i<j; i++, j--) {
System.out.println(j-i);
}

Se pueden crear bucles infinitos.

for (;;) {
System.out.println("Hola mundo!");
}

1.5.4. ERRORES COMUNES.

El transbordador espacial se encuentra a una altura de 10 Km y esta en fase de aterrizaje.
// Caso 1
int altura = 10;
while (altura > 0);
System.out.println(altura--);
System.out.println("Hemos aterrizado");
// Caso 2
int altura = 10;
while (altura > 0)
System.out.println(altura);
altura--;
System.out.println("Hemos aterrizado");
// Caso 3
int altura = 10;
for (; altura > 0; altura--);
System.out.println(altura);
System.out.println("Hemos aterrizado");

Autor: Ing. Ángel Chata T. 34 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1.5.5. LA SENTENCIA BREAK

En todo bucle, la sentencia BREAK transfiere el control fuera del bucle. Son necesarias cuando se trata
de bucles infinitos.

EJEMPLO

Un empleado ha llegado a su edad de jubilación (65) y ha trabajado desde los 25 años. Su CTS se
deposita en un banco que le otorga interes por estos depositos. Un nuevo gobierno ha decretado que
esta liquidación tendra un maximo de 250,000 soles

while (edad <= 65) {

liquidación = (liquidación + salario)*(1+interes);
if (liquidación >= 250,000)
break;
edad++;
}

1.5.6. LA SENTENCIA CONTINUE

Se usa solo en ciclos FOR.
Abandona la ejecución del cuerpo y continua a la siguiente iteración.

Mostrar todos los años bisiestos del siglo XXI.

for ( int anio=2001; anio <= 3000; anio++ ) {

if ( (anio % 100 == 0) && (anio % 400 != 0) )
continue;
if (anio % 4 == 0)
System.out.println(anio);
}

1.5.7 EJERCICIOS
Ejercicio 1
Mostrar la conversión de 1 hasta 10 dólares en soles, dólar tras dólar, suponiendo que el tipo de cambio
es 3.50 soles/dolar.

C:\java>notepad Cambio.java
public class Cambio {

public static void main(String[] args) {

int dolar = 1;
while (dolar<=10) {
System.out.println(dolar +" dolares = " + dolar*3.5 +" soles");
dolar++;
}
}
}

Ejercicio 2
Una persona desea invertir $1000.00 en un banco, el cual le otorga un 2% de interés mensual. Cual será
la cantidad de dinero que esta persona tendrá al cabo de un año si todo el dinero lo reinvierte?.

public class Interes {

public static void main(String[] args) {

Autor: Ing. Ángel Chata T. 35 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

double dinero = 1000;

int mes = 1;

while (mes<=12) {
dinero = dinero * 1.02;
mes++;
}
System.out.println(dinero);
}

Ejercicio 3
Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un día desde
las 00:00:00 horas hasta las 23:59:59 horas

public class Reloj {

public static void main(String[] args) {

for (int h=0; h <= 23; h++)

for (int m=0; m <= 59; m++)
for (int s=0; s <= 59; s++)
System.out.println(h +"h "+ m +"m "+ s+"s");
}
}

Ejercicio 4
Una persona desea invertir $1000.00 en un banco, el cual le otorga un 2% de interés mensual. En
cuantos meses tendrá mas de $1500, si reinvierte cada mes todo su dinero?.

public class Dinero {

public static void main(String[] args) {

double dinero = 1000;

int mes = 1;

for (;;) {
dinero = dinero * 1.02;
if (dinero >= 1500) break;
mes++;
}
System.out.println(mes);
System.out.println(dinero);
}
}

Autor: Ing. Ángel Chata T. 36 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 2. PRINCIPIOS DE LA ORIENTACION A OBJETOS

Resumen
Se estudiara el paradigma de la orientación a objetos y como se emplea en Java.

2.1. DEFINICION DE OBJETO.

2.1.1. Un nuevo paradigma

OO es un nuevo paradigma de diseño y programación

OO se basa en modelar objetos del mundo real
OO crea programas reusables
Los objetos contienen en si mismo información y comportamiento.

Que es un objeto?
Definición filosófica: Es una entidad que se puede reconocer.
Para la tecnología de objetos : Es una abstracción de un objeto del mundo real.
En términos de negocios: Es una entidad relevante al dominio del negocio.
En términos de software: Es una estructura que asocia datos y funciones.

Algunos ejemplos de objetos en POO son: Cliente, Factura, Contrato, Película. Un Cliente tiene
un nombre, dirección, crédito. Un Cliente podría alquilar una película, pagar una factura,
devolver una película.

Los objetos realizan operaciones.

Un objeto es útil si tiene alguna función o comportamiento en el sistema.
Cada comportamiento se denomina operación.

Objeto: Mi lapicero azul Objeto: El cajero automático P5

Operación: Escribir Operación: Entregar dinero.

Los objetos tiene valores.

Los objetos conocen cual es su estado actual.
Cada conocimiento del objeto se denomina atributo.

Objeto: Mi lapicero azul Objeto: El cajero automático P5

Atributo: Cantidad de tinta Atributo: Disponible en soles.

2.2.2 Los objetos son una abstracción

Todo depende del contexto.
Cuando se modela un objeto, solo se requiere modelar las operaciones y atributos que son relevantes
para el problema

Objeto: Mi lapicero azul

Operación: Apuntar una pizarra.
Autor: Ing. Ángel Chata T. 37 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Atributos: Longitud, Marca.

2.2. Encapsulamiento
El encapsulamiento oculta como las cosas funcionan dentro de un objeto
Solo nos comunicamos con el objeto a través sus métodos
Los métodos son una interfaz que permite ignorar como están implementados.
No es posible evadir el encapsulamiento en OO

El cajero automático P5 es un objeto que entrega dinero.

El cajero encapsula todas las operaciones a los tarjetahabientes.
Evadir este encapsulamiento es un robo al cajero.

Ejercicio
Complete con operaciones y atributos lo siguiente:
Objeto Operaciones Atributos
Cajero automático P5
Universidad
Computadora
Auto de carreras
DVD
Satélite

2.3. Relaciones entre objetos

Mensajes entre objetos.
Los objetos se comunican unos con otros enviando mensajes.
El trasmisor del mensaje pide que el receptor realice una operación.
El receptor ejecuta el método correspondiente.
En programación estructurada se invocan funciones o procedimientos.
En OO se envía un mensaje a un objeto antes que invocarse un procedimiento.
Los métodos presentan polimorfismo.

Persona
getEdad
Cliente getNombre Edad
o Mensaje getDireccion Nombre
Transmisor getEdad() setEdad Direccion
setNombre
setDireccion

2.3.1 Asociación entre objetos

Para que un objeto envíe un mensaje a otro, el receptor debe ser visible para el transmisor.
Esta visibilidad se da a través de enlaces.

Autor: Ing. Ángel Chata T. 38 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Un objeto envía mensajes a otro invocando sus métodos.

Radar Nueva posición Cambio de

en Tierra
orbita Satélite
Monitorear

Ejemplos:
El radar en tierra monitorea el satélite. El satélite es monitoreado por el radar en tierra.
Un cliente tiene una cuenta de ahorros. La cuenta de ahorros pertenece a un cliente.

2.3.2 Composición de objetos.

Los objetos están compuestos de otros objetos.
Los objetos son partes de otros objetos.
Esta relación entre objetos se conoce como Agregación

El Banco de la Nación es un El cajero automático P5 es El cajero automático P5 esta

objeto un objeto. compuesto por objetos
El cajero es del Banco de la como:
Nación. El teclado
El dispensador de billetes
El lector de la tarjeta

2.4. Clases
Una clase es una molde para crear objetos.
Para definir una clase se tiene que indicar las operaciones y atributos
Los objetos son instancias de la clase.
Cuando se cree un cajero automático P3 no se requiere indicar sus operaciones y atributos.
Solo se requiere indicar a que clase pertenece.

Clase Cliente Película

Atributos int edad String titulo
Métodos String nombre double precio
String dirección String categoria
cambiarDireccion() cambiarPrecio()

Identificación de clases
Reconocer una estructura y comportamiento comunes entre varios objetos.

Objeto Operaciones Atributos

Autor: Ing. Ángel Chata T. 39 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Escribir Cantidad de tinta

Recargar Color de tinta

Lapicero rojo

Escribir Cantidad de tinta

Recargar Color de tinta

Pluma y tinta

Ejercicio
A que clase pertenecen estos dos objetos?

Clases y Objetos.
Las clases son definiciones estáticas que nos permite entender todos los objetos de esa clase.
Los objetos son entidades dinámicas que existen en el mundo real y en simulaciones del mundo
real.

2.5. Herencia
Entre diferentes clases pueden haber similitudes
La herencia es una relación entre clases donde una es padre de otra.
Las propiedades comunes definen la superclase. Clase padre.
Las subclases heredan estas propiedades. Clase hijo.
Un objeto hijo es un-tipo-de una superclase.
Un Helicóptero es un tipo de Nave Aérea.

Nave Aérea

Helicóptero Dirigible
Jumbo
Globo
Ejercicio
Indique que propiedades tiene la clase Nave Aérea.

2.6. Polimorfismo
Significa que la misma operación se realiza en las clases de diferente forma.
Estas operaciones tienen el mismo significado, comportamiento.
Autor: Ing. Ángel Chata T. 40 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Internamente cada operación se realiza de diferente forma.

Abordar pasajeros

Barco Tren Helicóptero

Ejemplos
Enviar calcularIntereses a objetos como: Cuenta de Ahorros, Cuenta CTS, Cuenta Corriente.
En java se representa como: cuenta.calcularIntereses();

Ejercicio
Determine las clases, métodos, atributos y asociaciones del siguiente problema. Puede aplicar
herencia o polimorfismo?

Tacora Films esta en el negocio de alquiler de películas a sus clientes. Y ahora esta
automatizando el proceso de alquiler. El cliente escoge las películas en la tienda y las lleva a la
caja para proceder con el alquiler. El empleado de la tienda solicita la TacoraCard al cliente para
identificarlo y escanea el código de barras de cada película que esta alquilando.

Los clientes tienen que ser socios de Tacora Film Club para poder alquilar películas. Al
suscribirse al club entregan datos como nombre, dirección, teléfono. TacoraCard tiene un único
número impreso que identifica al cliente.

Cada alquiler tiene un número único para identificarlo y en el acuerdo se indica la fecha de inicio
del alquiler y la lista de películas que se están alquilando. No se puede alquilar más de 10
películas. No se sabe cuando exactamente el cliente devolverá la película.

El gerente de Tacora está considerando emplear el mismo programa para alquilar otros artículos
como libros, reproductores de VHS y de DVD, CDs de juegos.

Cada artículo tiene un precio de alquiler, número de días que puede ser alquilado, el titulo de la
película, una descripción breve, el tipo de película (Familiar, Acción, Comedia...)

2.7. CLASES EN JAVA

Una clase es un molde para crear múltiples objetos que encapsula datos y comportamiento.

2.7.1. Paquetes
Un paquete es un contenedor (agrupador) de clases que están relacionadas lógicamente.
Un paquete tiene sus clases en un mismo directorio
Varias clases pueden tener el mismo nombre pero en diferente paquete.

Autor: Ing. Ángel Chata T. 41 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Para el problema de los Paquete: Directorio:

alquileres se encuentran las alquiler C:/alquiler
clases: Clases: Archivos en C:/alquiler
Clase Pelicula alquiler.Pelicula Pelicula.java
Clase Contrato alquiler.Contr Contrato.java
Clase Cliente ato Cliente.java
alquiler.Cliente

2.7.2. Modificadores de acceso

Java controla el acceso a las variables y métodos a través de modificadores de acceso como:
private, public y protected
Un elemento publico puede invocarse en cualquier clase.
Un elemento sin modificador solo se puede invocar desde la misma clase.
Un elemento protegido solo se invocar en clases heredadas
Un elemento privado no puede ser invocado por otra clase.

Paquete alquiler Paquete almacen

NO NO

private

SOLO
SOLO SI
SI protected HEREDA
HEREDA

SI
SI
public

SI NO

2.7.3. Creación de objetos.

1.Cada objeto es una instancia de alguna clase.

Pelicula
private String titulo; Odisea 2001 El Padrino
private String tipo; Ciencia Ficcion Drama
public void mostrarDetalles()
public void obtenerTitulo()

Autor: Ing. Ángel Chata T. 42 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

2.Los objetos se crean con el operador new.

Pelicula pelicula1 = new Pelicula();

Pelicula pelicula2 = new Pelicula();

3.El operador new realiza las siguientes acciones:

- Separa memoria para el nuevo objeto
- Invoca el método de inicio de la clase llamado constructor.
- Retorna la referencia a un nuevo objeto.

La Strada
Pelicula pelicula1 =
pelicula1 Drama
new
Pelicula();

Las variables primitivas Los objetos almacenan referencias

almacenan valores.
int i; 0
i

nu
Pelicul ll
a pelicul int j = 3;
pelicul a1
a1;
3
Dias de Radio

jPelicula pelicula2 =
pelicula2

2.7.4. La referencia null

- Los objetos inician en null Pelicula pelicula1 = null;

if (pelicula1 == null)
- Se puede comparar un pelicula1 = new Pelicula();
objeto con null pelicula1 = null;
- Se puede liberar la referencia con
null.

2.7.5. Asignando referencias

Se puede asignar una variable referencia a otra resultado en dos referencias al mismo objeto.

Pelicula pelicula1 = new Pelicula("Betty Blue");

Película pelicula2 = pelicula1;
Autor: Ing. Ángel Chata T. 43 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

6. Las variables de instancia se declaran en la clase. Estos son atributos de la clase.

public class Pelicula {

public String titulo;
public String tipo;
}

7. Las variables publicas de instancia se acceden con el operador punto.

Pelicula pelicula1 = new Pelicula();

pelicula1.titulo = "Kramer vs Kramer";
if (pelicula1.titulo.equals("El planeta de los simios")
pelicula1.tipo = "Ciencia Ficcion";

2.8. Laboratorio. Uso de Objetos

Complete y realice el siguiente programa.

Pelicula.java
public class Pelicula {
public String titulo;
public String tipo;
}

PruebaPeliculas.java
public class PruebaPeliculas {
public static void main (String[] args) {
Pelicula pelicula1, pelicula2;
...
pelicula1.titulo = "Los sueños de Akira Kurosawa";
pelicula2 = pelicula1;
pelicula2.titulo = "Día de entrenamiento";
System.out.println("La pelicula 1 es "+ ...);
System.out.println("La pelicula 2 es "+ ...);
}
}

2.9. Métodos
Un método es equivalente a una función o subrutina de otros lenguajes.
Los métodos solo se definen dentro de una clase.

modificador tipoDeRetorno nombreMetodo (ListaDeArgumentos) {

// desarrollo del método;
}

Autor: Ing. Ángel Chata T. 44 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

2.9.1. Argumentos
En la definición del método se indica el tipo y el nombre de los argumentos del método.

public void setTipo (String nuevoTipo) {

tipo = nuevoTipo;
}

Si el método tiene varios argumentos, estos se separan por comas.

public void setDatos (String nuevoTitulo, String nuevoTipo) {
tipo = nuevoTipo;
titulo = nuevoTitulo;
}

Si el método no tiene argumentos, se deja solo los paréntesis

public void mostrarDetalles() {
System.out.println("El titulo es "+titulo);
System.out.println("El tipo es "+tipo);
}

2.9.2. Valores de retorno.

Se aplica sólo a las funciones más no a los procedimientos (para estos últimos se usa void).
Se usa la sentencia return para salir del método retornando un valor.
No se requiere return si el tipo de retorno es void.

public class pelicula {

private String tipo;
//...
public String obtenerTipo () { // es una función
return tipo;
}
}

2.9.3. Recursividad
Un método recursivo es aquel que directa o indirectamente se llama a si mismo.
Como ejemplo útil se puede presentar el cálculo de factorial y sumatorias
Factorial de 0 = 1
Factorial de N = N * Factorial de N - 1

Sumatoria de 0 = 0
Sumatoria de N = N + Sumatoria de N - 1

Un método recursivo debe tener al menos un caso no recursivo y otros casos recursivos que se
aproximen al caso no recursivo para evitar la recursión infinita.

Recursion.java

Autor: Ing. Ángel Chata T. 45 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

public class Recursion {

public static void main (String[] args) {
System.out.println( factorial(5) );
System.out.println( sumatoria(5) );
}
public static int factorial (int numero) {
//Factorial;
}
public static int sumatoria (int numero) {
//Sumatoria
}
}

2.9.4. Invocando métodos

Se utiliza el operador punto para invocar el método de una clase, si el método es de la misma
clase, no se requiere el calificador de la clase.

Laboratorio
Pelicula.java
public class Pelicula {
private String titulo,tipo;
//...
public String getTipo () {
return tipo;
}
public String setTipo (String nuevoTipo) {
tipo = nuevoTipo;
}
}
PruebaPeliculas.java
public class PruebaPeliculas {
public static void main (String[] args) {
Pelicula pelicula1 = new Pelicula();
pelicula1.setTipo("Comedia");
if (pelicula1.getTipo().equals("Drama")) {
System.out.println("La pelicula es un drama");
}
else {
System.out.println("La pelicula no es un drama");
}
}
}

Autor: Ing. Ángel Chata T. 46 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

2.10. Encapsulamiento
1. Las variables de instancia de una clase deberían ser declaradas como privadas
Solo un método debería acceder a las variables privadas.
No se debe acceder a las variables de instancia directamente, sino a través de un método.

Pelicula pelicula1 = new Pelicula();

if (pelicula1.titulo.equals("Los doce del patibulo")) {
pelicula1.setTipo("Accion");
}

Cual de estas líneas no cumple con el encapsulamiento?

2. Código de una clase.

Laboratorio
Pelicula.java
public class Pelicula {
private String titulo;
private String tipo;

public void setTitulo (String nuevoTitulo) {

titulo = nuevoTitulo;
}

public void setTipo (String nuevoTipo) {

tipo = nuevoTipo;
}
public String getTitulo () {
return titulo;
}

public String getTipo () {

return tipo;
}

public String toString () {

return "titulo "+titulo+" tipo "+tipo;
}
}

2.11. Paso de variables a métodos.

1. Cuando el argumento es una primitva, se genera una copia de la variable para el método.

Autor: Ing. Ángel Chata T. 47 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Laboratorio
TestPrimitivas.java
public class TestPrimitivas {
public static void main (String[] args)
{
int numero = 150;
unMetodo(numero);
System.out.println(numero);
}

private static void unMetodo(int argumento) {

if (argumento < 0 || argumento > 100) {
argumento = 0;
System.out.println(argumento);
}
}
}

Que valores muestra el programa anterior?

2. Cuando se pasa como argumento un objeto referencia, no se genera copia. El argumento

referencia al objeto original.

Laboratorio
TestReferencias.java
public class TestReferencias {
public static void main (String[] args)
{
Pelicula pelicula1 = new Pelicula();
pelicula1.setTitulo("El Resplandor");
pelicula1.setTipo("Drama");
unMetodo(pelicula1);
System.out.println(pelicula1.getTipo());
}

public static void unMetodo(Pelicula referencia) {

referencia.setTipo("Terror");
}
}

Que muestra el programa?

Ejercicio

Autor: Ing. Ángel Chata T. 48 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

1. Cree la clase Cliente con los atributos código, nombre, dirección, teléfono encapsulados
(métodos set y get).
2. Agregue a la clase Cliente el método toString que muestre en pantalla todos los datos de la
clase Cliente.
3. Cree la clase Pelicula con los atributos código, titulo, tipo, precio de alquiler. Incluya el
método toString.
4. Cree un programa como TacoraFilms.java y cree como objetos a dos clientes con datos
de sus familiares. (cliente1 y cliente2)
5. Agregue al programa principal objetos de dos películas que haya visto recientemente.
(pelicula1, pelicula2)
6. Al final del programa coloque lo siguiente:

System.out.println(cliente1);
System.out.println(cliente2);
System.out.println(pelicula1);
System.out.println(pelicula2);

Que muestra el programa?

Autor: Ing. Ángel Chata T. 49 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 3. TRABAJANDO CON CLASES

Resumen
Se realizara un estudio sobre características avanzadas en la definición de clases.

3.1. DEFINICIONES INICIALES.

El encapsulamiento se basa en los métodos de instancia.
La sobrecarga de métodos nos brinda una interfase mas legible.
Los constructores aseguran una consistente creación de objetos
El Garbage Collector libera espacio en memoria.

3.1.1. Sobrecarga de métodos.

Algunos métodos en una clase pueden tener el mismo nombre.
Estos métodos deben contar con diferentes argumentos.
El compilador decide que método invocar comparando los argumentos.
Se generara un error si los métodos solo varian en el tipo de retorno.

public class Pelicula {

private float precio;
public void setPrecio() {
precio = 3.50;
}
public void setPrecio(float nuevoPrecio) {
precio = nuevoPrecio;
}
}

3.1.2. Iniciación de variables de instancia

Las variables de instancia se pueden iniciar en la declaración.
Esta iniciación ocurre cuando se crea un objeto.

public class Pelicula {

private String titulo; // implicito
private String tipo = "Drama"; // explicito
private int numeroDeOscares; // implicito
}

Las primitivas se inician implícitamente como:

char '0'
byte, short, int, long 0
boolean false
float, double 0.0
Referencia a Objeto null

En forma explicita se puede indicar un valor inicial.

private String tipo = "Drama";

Un constructor provee una iniciación de variables de instancia más compleja.

Autor: Ing. Ángel Chata T. 50 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

3.1.3. Constructores
Para una adecuada iniciación de variables de instancia, la clase debe tener un constructor.
Un constructor se invoca automáticamente cuando se crea un objeto.
Se declaran de forma pública.
Tiene el mismo nombre que la clase.
No retorna ningún valor.
Si no se codifica un constructor, el compilador crea uno por defecto sin argumentos que solo inicia las
variables de instancia.

Laboratorio
Pelicula.java
public class Pelicula {
private String titulo;
private String tipo = "Drama";

public Pelicula() {
titulo = "Pelicula sin definir.";
}

public Pelicula(String nuevoTitulo) {

titulo = nuevoTitulo;
}

public Pelicula(String nuevoTitulo, String nuevoTipo) {

titulo = nuevoTitulo;
tipo = nuevoTipo;
}

public String getTitulo() {

return titulo;
}

public String getTipo() {

return tipo;
}

}
TestConstructores.java
public class TestConstructores {
public static void main (String[] args) {
Pelicula pelicula1 = new Pelicula();
Pelicula pelicula2 = new Pelicula("La lista de
Schindler.");
Pelicula pelicula3 = new Pelicula("El
dormilon.","Comedia");
System.out.println(pelicula1.getTitulo()
+pelicula1.getTipo());
System.out.println(pelicula2.getTitulo()
+pelicula2.getTipo());
Autor: Ing. Ángel Chata T. 51 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

System.out.println(pelicula3.getTitulo()
+pelicula3.getTipo());
}
}

Que muestra el programa?

3.1.4. La referencia this

Los métodos de instancia reciben el argumento this implícitamente que se refiere al mismo objeto.

public class Pelicula {

private String titulo;
public void setTitulo(String titulo) {
this.titulo = titulo;
}
}

Se puede compartir código entre constructores usando la referencia this. Un constructor invoca a otro
pasandole los argumento que requiere.

Laboratorio
Pelicula.java
public class Pelicula {
private String titulo;
private String tipo;

public Pelicula()
{
this("Pelicula sin definir");
}
public Pelicula (String titulo) {
this.titulo = titulo;
}
public String getTitulo() {
return titulo;
}
}
TestThis.java
public class TestThis {
public static void main (String[] args) {
Pelicula pelicula1 = new Pelicula();
Pelicula pelicula2 = new Pelicula("Todo sobre mi madre");
System.out.println(pelicula1.getTitulo());
System.out.println(pelicula2.getTitulo());
}
}

3.1.5. Variables de clase

Las variables de clase comparte un único valor entre todos las instancias de la clase.
Se declaran con el calificador static.

Autor: Ing. Ángel Chata T. 52 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

public Class Pelicula {

// iniciación por defecto
private static double precioMinimo;
private String titulo, tipo;
}

Las variables de clase se pueden iniciar en la declaración.

La iniciación ocurre cuando se carga la clase en memoria.
Para una iniciación compleja se usara un bloque static

public Class Pelicula {

// iniciación explicita
private static double precioMinimo = 3.29;
}

Laboratorio
Pelicula.java
import java.util.*;
public class Pelicula {
private static int numeroDias = 3;
// iniciación compleja
private static double precioMinimo;
static {
Date hoy = new Date();
if (hoy.getDay() == 0) //si es Domingo
precioMinimo = 5.10;
else
precioMinimo = 3.29;
}
public int getNumeroDias() {
return numeroDias;
}
public double getPrecioMinimo() {
return precioMinimo;
}
}
TestStatic.java
public class TestStatic {
public static void main (String[] args) {
Pelicula pelicula = new Pelicula();
System.out.println(pelicula.getNumeroDias());
System.out.println(pelicula.getPrecioMinimo());
}
}

3.1.6. Métodos de clase.

Estos métodos son compartidos por todas las instancias.
Se usan estos métodos principalmente en manipular variables de instancia.
Se les declara con el calificador static
Se invoca a este método de clase con el nombre de la clase o con el nombre de una instancia.

Laboratorio
Pelicula.java
public class Pelicula {
private static float precio = 3.50f;
private String titulo;
Autor: Ing. Ángel Chata T. 53 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

public Pelicula(String titulo) {

this.titulo = titulo;
}
public String getTitulo() {
return titulo;
}

public static void setPrecio(float nuevoPrecio) {

precio = nuevoPrecio;
}
public static float getPrecio() {
return precio;
}
}
TestStatic2.java
public class TestStatic2 {
public static void main (String[] args) {
Pelicula.setPrecio(3.98f);
Pelicula oscar = new Pelicula("Ben Hur");
System.out.println(oscar.getPrecio());
oscar.setPrecio(4.98f);
System.out.println(Pelicula.getPrecio());

}
}

Que resultados se obtienen?

3.2 EJERCICIOS

Ejercicio 1

Cree la clase Cliente que tendrá los siguiente datos código (int) nombre, dirección, teléfono (String)
La clase debe contar con dos constructores.
Uno sin argumentos para autogenerar el código (que inicia en 2000).
Otro que aceptara los datos nombre, dirección, teléfono.
El código del cliente debe ser automático e incrementarse en uno cada vez que se cree una instancia.
Los códigos inician en 2001
Agregue los métodos set y get para estos atributos.
También agregue el método toString() para mostrar los datos del cliente asi como el código creado
automáticamente.

Cree la clase Pelicula con los siguientes datos: codigo (int) titulo, tipo (String) precio (float)
La clase debe contar con dos constructores.
Uno sin argumentos para autogenerar el código (que inicia en 9000).
Otro que aceptara los datos titulo, tipo, precio .
El código de la pelicula debe ser automático e incrementarse en uno cada vez que se cree una instancia.
Los codigos inician en 9001
Agregue los métodos set y get para estos atributos.
También agregue el método toString() para mostrar los datos de la pelicula incluido el código
autogenerado.

Defina la clase BaseDeDatos donde creara 4 clientes (nombres familiares) y 6 películas (que haya visto
en cine o televisión).
Autor: Ing. Ángel Chata T. 54 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Finalmente cree el programa TestClases que muestre toda la base de datos (haciendo uso de la ventaja
del método toString() ). También muestre el ultimo código autogenerado tanto en clientes como en
películas que deberá obtener directamente de sus clases.

Cliente.java
public class Cliente {
private int id;
//...
private static int ultimoId = 2000;
//...
public Cliente() {
this.id = ...
ultimoId++;
}
public Cliente(String nombre...) {
this();
this.nombre = ...
}

Pelicula.java
public class Pelicula {
private int id;
//...
private static int ultimoId = 9000;
//...
public static int getUltimoId() {
return ultimoId;
}
}

BaseDeDatos.java
public class BaseDeDatos {
Cliente cliente1 = new Cliente("Daneel Olivaw","Solaria4","11-2542");
//...
Pelicula pelicula1 = new Cliente("El Padrino","Drama",5.30f);
//...
}

TestClases.java
public class TestClases {
public static void main (String[] args) {

BaseDeDatos bd = new BaseDeDatos();

System.out.println(bd.cliente1);
System.out.println(bd.cliente2);
//...
System.out.println(bd.pelicula1);
System.out.println(bd.pelicula2);
//...
System.out.println(Cliente.getUltimoId());
System.out.println(Pelicula.getUltimoId());
}
}

Autor: Ing. Ángel Chata T. 55 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Ejercicio 2

Cree la clase Vendedor con los siguientes atributos nombre, edad, ventas, sueldoFijo. La clase también
contara con un atributo estático para contar la cantidad de vendedores que se vayan creando. La clase
cuenta con un constructor que recibe nombre, edad, ventas, sueldoFijo como argumentos. En este
constructor se incrementara el contador de vendedores creados.
Contara con un método estático que retornara la cantidad actual de vendedores creados getCantidad().
Otro método retornara el sueldo del vendedor getSueldo(). El sueldo es el 0.25% de las ventas mas el
sueldo fijo.
Agregue otro constructor con dos argumentos como nombre y ventas únicamente.
En el programa AplicacionVendedor.java se encuentra lo siguiente:
...
Vendedor vendedorHari = new Vendedor("Hari Seldon",8000);
Vendedor vendedorSalvor= new Vendedor("Salvor Hardin",30,5000,1300);
System.out.println(Vendedor.getCantidad());
System.out.println(vendedorHari.getSueldo());
System.out.println(vendedorSalvor.getSueldo());
...

Autor: Ing. Ángel Chata T. 56 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 4. TRABAJANDO CON ARREGLOS

Resumen
Se estudiara el uso de arreglos y cadenas en la solución de problemas en Java.

4.1. DEFINICION DE ARREGLOS

4.1.1 Definición
Un arreglo es una colección de variables del mismo tipo.
La longitud de un arreglo es fijo cuando se crea.

Elemento 0 [0] Valor = 1 1

Elemento 1 [1] Valor = 2 2
Elemento 2 [2] Valor = 4 4
Elemento 3 [3] Valor = 8 8

Pasos de la creación de arreglos de primitivas

Se declara el arreglo
Inicialmente la variable referencia un valor nulo potencias-> null
int[] potencias; //forma mas usada
int potencias[];

Se crea el arreglo potencias-> 0

Se requiere la longitud del arreglo 0
potencias = new int[4]; 0
En caso de variables primitivas se inician en 0 o false. Las 0
primitivas no se pueden operar con el valor null.
En caso de variables referencia se inician en null. No
referencian a ningún objeto.

Se inicia los valores del arreglo

Se asignan valores elemento por elemento potencias-> 1
potencias[0] = 1; 2
potencias[1] = 2; 4
potencias[2] = 4; 8
potencias[3] = 8;
Los arreglos pueden ser creados e iniciados al mismo tiempo
int[] potencias = {1,2,4,8};

Los arreglos son muy usados para buscar datos, especialmente si se conocen sus valores cuando se
crean.

int[] diasMesesAnioBisiesto = {31,29,31,30,31,30,31,31,30,31,30,31};

4.1.2. Practica Guiada

Los elementos de un arreglo inician con el valor por defecto de una primitiva.
La propiedad length del arreglo es su longitud.
Autor: Ing. Ángel Chata T. 57 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Cual es el resultado los siguientes bloques.

Encuentre 3 errores en el siguiente código.

// bloque 1
int[] numeros = new int[5];
System.out.println(numeros.length-1); // 4

// bloque 2
int[] truco = new int[3];
System.out.println(truco[0]); // 0

// bloque 3
int[] cubos = {1, 8, 27, 64, 125};
int indice = cubos.length; // 5
System.out.println(cubos[indice]); // Error el índice va de 1 a 4, n
to

// bloque 4
int[] pares = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
int cantidad = 0;
while (cantidad.length < 10) { //while (pares[cantidad] != null) {
cantidad++;
}

// bloque 5
char[] vocales;
System.out.println(vocales.length); // Falta inicializar

Encuentre cuatro errores en el siguiente código

1. int[] a= new int[20];

2. float[] b= new float[10];
3. int a2 = new int[20];
4. int[] b2 = new float[10]; // No asigne float a int
5. a[2] = -5;
6. a[4] = 10;
7. int k = a[6];
8. a[k] = 20;
9. a[20] = 0; // El índice va de 0 a 19: ArrayIndexOutOfBoundsException
10. a[3] = 1.1; // No asigne decimales a números enteros

Errores:

 Ocurre ArrayIndexOutOfBoundsException cuando el índice del arreglo es incorrecto.

 Ocurre NullPointerException cuando se intenta acceder a un elemento no inicializado.
 Una primitiva no se puede comparar o asignar con un valor null(aplica a objetos).
 Solo las referencias se comparan con null (sólo objetos).

4.2. ARREGLOS MULTIDIMENSIONALES

Se trata de arreglos de arreglos y se declara de la siguiente forma:
tipo[][] nombreArreglo =
new tipo[cantidadFilas][cantidadColumnas];

Autor: Ing. Ángel Chata T. 58 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

int[][] tabla = new int[4][2];

tabla[0][0] = 1;

tabla -> tabla[0] -> 1 7

[0] tabla[1] -> 3 5
[1] tabla[2] ->
4 8
[2] tabla[3] ->
[3] 0 0

Definir una matriz de enteros colocando como valores la suma de su numero de fila y columna en la
matriz
{
int n= 10;
int p= 20;
double[][] m = new double[n][p];
for (int i= 0; i<n; i++)
for (int j= 0; j<p; j++)
m[i][j]= i+j;
}

4.3. LABORATORIO

4.3.1 Ejercicio
Se tiene en un arreglo las notas del examen parcial de 10 alumnos. Encuentre la mínima y máxima nota.
Notas.java
package ejercicios;
public class Notas {
public static void main(String[] args) {

int[] notas = {12, 04, 07, 18, 10, 15, 05, 16, 18, 11};
int i = 1;
double min= 20.1;
double max= 00.0;
while (i < 10) {
...
}
System.out.println(max);
System.out.println(min);
}
}

4.3.2. Ejercicio
Se cuenta con los arreglos siete y ocho
Multiplicar el primer elemento del arreglo siete con el primer elemento del arreglo ocho y así
sucesivamente. Almacenar el resultado en otro arreglo y muéstrelo.

Matriz.java
package ejercicios;
public class Matriz {
public static void main(String[] args) {

int[] siete = {7,17,27,37,47,57,67,77,87,97,107};

int[] ocho = {8,18,28,38,48,58,68,98,108,118,198};
...

Autor: Ing. Ángel Chata T. 59 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

}
}

4.4. CADENAS.
4.4.1. Definición.
Una cadena es una secuencia de caracteres
La librería String (o clase String) se usa para definir todas las cadenas en Java.
Las cadenas se delimitan con comillas dobles.

//
System.out.println("Hola Mundo.");
String camara = "Camara";
String luces = camara +" Accion";
String vacio = "";
//

4.4.2. Construccion de cadenas.

También se puede usar la siguiente sintaxis para construir cadenas.

// con una constante

String nombreEmpleado = new String("R. Daneel Olivaw");
// con una cadena vacia
String inicio = new String();
// copiando una cadena
String copiaEmpleado = new String(nombreEmpleado);
// con un arreglo de char
char[] vocales = {'a','e','i','o','u'};
String cadenaVocales = new String(vocales);

4.4.3. Concatenacion.
Para concatenar cadenas puede usar lo siguiente:

// Usando el operador +
System.out.println(" Nombre = " + nombreEmpleado );
// Puede concatenar primitivas y cadenas.
int edad = 22;
System.out.println(" Edad = " + edad );
// Mediante la función concat()
String nombre = "Elijah ";
String apellidos = "Baley ";
String nombreCompleto = nombre.concat(apellidos);

4.5. OPERACIONES CON CADENAS.

4.5.1. Longitud de una cadena.

String nombre = "Hari Seldon";
int longitud = nombre.length();
Autor: Ing. Ángel Chata T. 60 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

> 11

4.5.2. Ubicar un carácter mediante un indice

String nombre = "Gladia Delmarre";
char c = nombre.charAt(0);
> G

4.5.3. Extraer una subcadena

// 0123456789012345
String nombre = "Blissenobiarella";
// 1234567890123456
String subCadena = nombre.substring(2,6);
> isse

4.5.4. Convertir a mayúsculas o minúsculas.

String titulo = "Segunda Fundacion";
String mayusculas = titulo.toUpperCase();
String minusculas = titulo.toLowerCase();
> SEGUNDA FUNDACION
> segunda fundacion

4.5.5. Eliminar espacios del inicio y el final de la cadena.

String autor = " Isaac Asimov ";
String resaltar = "*"+autor.trim()+"*";
> *Isaac Asimov*

4.5.6. Ubicar una subcadena desde una ubicación.

// 0123456789012
String alcalde = "Salvor Hardin";
int ubicacion1 = alcalde.indexOf("vor");
int ubicacion2 = alcalde.indexOf("r",7);
int ubicacion3 = alcalde.indexOf("h");
> 3
> 9
> 0

4.5.7. Comparando dos cadenas.

String password = "FGHPUW";
if password.equals("fgHPUw")
System.out.println("Correcto!");
Else
System.out.println("Error!");
> Error!
Autor: Ing. Ángel Chata T. 61 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

String password = "FGHPUW";

if password.equalsIgnoreCase("fgHPUw")
System.out.println("Correcto!");
else
System.out.println("Error!");
> Correcto!

4.5.8. Comparando regiones de una cadena.

String url = "http://www.uni.edu.pe";
if (url.endsWith(".pe"))
System.out.println("Pagina Nacional");
else
System.out.println("Pagina Extranjera");

String parametro = "ip = 192.100.51.2";

if (parametro.startsWith("ip"))
System.out.println("La direccion "+parametro);
else
System.out.println("El parámetro no es una ip");

4.5.9. Obtener cadenas desde las primitivas.

Se utilizan funciones de la librería String

String seven = String.valueOf(7);

String unoPuntoUno = String.valueOf(1.1);
float pi = 3.141592;
String piString = String.valueOf(pi);
//

4.5.10. Obtener primitivas desde las cadenas.

Para esto se utilizan funciones de las librerías Integer y Float.

//
String alfa = "1977";
int alfaInteger = Integer.parseInt(alfa);
//
String beta = "19.77";
float betaFloat = Float.parseFloat(beta);

4.5.11. EJERCICIOS
Cual es la respuesta de:

// Bloque 1
String s = new String("Viernes");
if (s=="Viernes")
System.out.println("Respuesta A");
if (s.equals("Viernes"))
System.out.println("Respuesta B");
> ?
// Bloque 2

Autor: Ing. Ángel Chata T. 62 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

int num1 = 1234567;

System.out.println(String.valueOf(num1).charAt(3));
> ?
// Bloque 3
String s1 = "Lunes";
String s2 = "Martes";
System.out.println(s1.concat(s2).substring(4,8));
> ?
// Bloque 4
// s3 inicia con 2 espacios y tambien termina con 2.
String s3 = " Lunes ";
System.out.println(s3.indexOf("es"));
System.out.println(s3.trim().indexOf("es"));

4.6. ARREGLOS DE CADENAS

4.6.1. Definicion
Un arreglo de cadenas también sigue los pasos de creación de arreglos.

Declaracion String [] categorías;

Creación categorias = new String[3];
Iniciación. categorias[0] = "Drama";

// Creando una arreglo de cadenas vacias.

String [] arreglo = new String [4];
for ( int i = 0; i < arreglo.length; i++ ) {
arreglo[i] = new String();
}

// Creando e iniciando un arreglo.

String [] categorias = {"Drama", "Comedia", "Accion"};

// Accesando los elementos del arreglo

String [] categorias = {"Drama", "Comedia", "Accion"};
System.out.println(" Comedia = "+ categorías[1].length() );

4.6.2. Ejercicios
Cual es el resultado de:

//
String [] categorias = {"Drama", "Comedia", "Accion", "Infantil"};
int indice = categorías.length – 2;
System.out.println(categorías[indice].length() );
//
String [] categorias = {"Drama", "Comedia", "Accion", "Infantil"};
int indice = categorías.length – 2;
System.out.println(categorías[indice].length() );

4.7. MAIN
main() cuenta con un único parámetro que es un arreglo de cadenas.
Este arreglo de cadenas son los parámetros de la linea de comandos.

Autor: Ing. Ángel Chata T. 63 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

C:\> java Eco Hola Mundo

// Eco.java
package ejercicios;
public class Eco {
public static void main (String [] args) {
if (args.length != 2)
System.out.println("Uso: java Eco Arg1 Arg2");
else
System.out.println(args[0] + " " + args[1]);
}
}

4.8 LABORATORIO
Cree la clase Cliente que tendra los siguiente datos codigo (int) nombre, direccion, telefono (String)
La clase debe contar con dos constructores.
Uno sin argumentos para autogenerar el código (que inicia en cero).
Otro que aceptara los datos nombre, dirección, teléfono.
El código del cliente debe ser automático e incrementarse en uno cada vez que se cree una instancia.
Los códigos inician en 2001
Opcionalmente agregue los métodos set y get para estos atributos.
También agregue el método toString() para mostrar los datos del cliente así como el código creado
automáticamente.

Cree la clase Pelicula con los siguientes datos: codigo (int) titulo, tipo (String) precio (float),
La clase debe contar con dos constructores.
Uno sin argumentos para autogenerar el codigo (que inicia en 1).
Otro que aceptara los datos titulo, tipo, precio .
El código de la Pelicula debe ser automático e incrementarse en uno cada vez que se cree una instancia.
Los códigos inician en 9001
Opcionalmente agregue los métodos set y get para estos atributos.
También agregue el método toString() para mostrar los datos de la pelicula incluido el código
autogenerado.

Cliente.java
public class Cliente {
private int id;
private static int ultimoId=2000;
private String nombre;
private String direccion;
private String telefono;

public Cliente() {
this.id = ultimoId;
ultimoId++;
}

public Cliente(String nombre, String nuevaDireccion,

String nuevoTelefono) {
this();
this.nombre = nombre;
this.direccion = nuevaDireccion;
this.telefono = nuevoTelefono;
}

public void setNombre(String nuevoNombre) {

Autor: Ing. Ángel Chata T. 64 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

nombre = nuevoNombre;
}

public void setDireccion(String nuevoDireccion) {

direccion = nuevoDireccion;
}

public void setTelefono(String nuevoTelefono) {

telefono = nuevoTelefono;
}

public int getId() {

return id;
}

public static int getUltimoId() {

return ultimoId;
}

public String getNombre() {

return nombre;
}

public String getDireccion() {

return direccion;
}

public String getTelefono() {

return telefono;
}

public String toString(){

return ("Codigo : "+id+" "+nombre+" "+direccion+" "+telefono);
}
}
//...
Pelicula.java
public class Pelicula {
private int id;
private static int ultimoId=9000;
private String titulo;
private String tipo;
private float precio;

public Pelicula() {
this.id = ultimoId;
ultimoId++;
}

public Pelicula(String nuevoTitulo,String nuevoTipo) {

this();
this.titulo = nuevoTitulo;
this.tipo = nuevoTipo;
}

public void setTitulo(String nuevoTitulo) {

titulo = nuevoTitulo;
}

Autor: Ing. Ángel Chata T. 65 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

public void setTipo(String nuevoTipo) {

tipo = nuevoTipo;
}

public void setPrecio(float nuevoPrecio) {

precio = nuevoPrecio;
}

public String getTitulo() {

return titulo;
}

public String getTipo() {

return tipo;
}

public int getId() {

return id;
}

public float getPrecio() {

return id;
}

public static int getUltimoId() {

return ultimoId;
}

public String toString() {

return ("Codigo : "+id+" "+titulo+" "+tipo);
}

Defina la clase BaseDeDatos con tres métodos: en el primero creara 4 clientes (nombres familiares) y 6
peliculas (que haya visto en cine o televisión). Los clientes y las películas se encontraran en un arreglo.
El segundo devolvera el objeto cliente ingresando el id del cliente. El tercero realizara lo mismo con el id
de una pelicula.

BaseDeDatos.java
package tacora;
public class BaseDeDatos {

private static Cliente[] cliente = new Cliente[4];

private static Pelicula[] pelicula = new Pelicula[4];

public BaseDeDatos() {
cliente[0] = new Cliente("Daneel Olivaw","Solaria 4",
"511-711-2542");
//...
pelicula[0] = new Pelicula("Neverland","Drama",10.0f);
//...
}

public static Cliente getCliente(int id) {

for (...) {
break;
}
return cliente[];
Autor: Ing. Ángel Chata T. 66 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

public static Pelicula getPelicula(int id) ...

Cree la aplicación Arreglos que permita Cargar la base de datos y mostrar los datos del cliente con
codigo 2002 y la pelicula con codigo 9003

TacoraArreglos.java
package tacora;
public class TacoraArreglos {
public static void main (String[] args) {
int clienteId;
int peliculaId;

if (args.length != 4)
System.out.println("java TacoraArreglos 2002 9003");
else {
clienteId = args[0];
peliculaId = args[1];
}
BaseDeDatos bd = new BaseDeDatos();
System.out.println(bd.getCliente(clienteId ));
System.out.println(bd.getPelicula(peliculaId));
}
}

Segunda Parte
Modifique la clase Pelicula y agregue el atributo: cliente (Cliente) que sera quien alquile la pelicula,
implemente el método set y get correspondientes.
Modifique la clase Cliente y agregue el atributo: importeAlquiler (float) implemente su métodos set y
get correspondiente.
Modifique la clase BaseDeDatos y agregue un método que permite calcular el importe de alquiler de un
cliente. La aplicación debe permitir realizar el alquiler de 3 películas al cliente 2002 y muestre su costo.

Pelicula.java
package tacora;
public class Pelicula {
private Cliente cliente;
//...
public void setCliente(Cliente alquiladoPor) {
cliente = alquiladoPor;
}
}
Cliente.java
package tacora;
public class Cliente {
private float importeAlquiler;
//...
}
BaseDeDatos.java
package tacora;
public class BaseDeDatos {
//...
public static float getImporte(Cliente cliente) {
Pelicula pelicula = null;
Autor: Ing. Ángel Chata T. 67 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

float importe = 0;
for (int i = 0;...) {
if (pelicula[i].getCliente().getId() == cliente.getId()) {
importe += pelicula[i].getPrecio();
}
}
return importe;

}
}

TacoraArreglos.java
package tacora;
public class TacoraArreglos {
public static void main (String[] args) {

int clienteId;
int peliculaId1;
int peliculaId2;
int peliculaId3;

if (args.length != 4)
System.out.println("java TacoraArreglos 2002 9001 9002 9003");
else {
clienteId = args[0];
peliculaId1= args[1];
peliculaId2= args[2];
peliculaId3= args[3];
}
BaseDeDatos bd = new BaseDeDatos();

Cliente cliente = bd.getCliente(clienteId);

Pelicula pelicula1 = bd.getPelicula(peliculaId1);
pelicula1.setCliente(cliente);
Pelicula pelicula2 = bd.getPelicula(peliculaId2);
pelicula2.setCliente(cliente);
bd.getPelicula(peliculaId3).setCliente(cliente);

System.out.println(cliente);
System.out.println(pelicula1);
System.out.println(pelicula2);
System.out.println(bd.getPelicula(peliculaId3));

System.out.println(bd.getImporte(cliente));
}
}

Autor: Ing. Ángel Chata T. 68 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 5. HERENCIA Y POLIMORFISMO

Resumen
Se estudiara el uso de la herencia y el polimorfismo en el reuso de clases.

5.1. HERENCIA
5.1.1 Definición
Permite a una clase compartir la misma estructura de datos y comportamiento de otra clase.
La herencia minimiza la necesidad de duplicar código.
El Polimorfismo permite utilizar el método de acuerdo al objeto heredado.

Item
Superclase

Pelicula Libro Equipo

Subclase
(DVD, VHS)

Que atributos tienen en común las subclases?

Que atributos no tienen en común las subclases?
Que método no tienen en común las subclases?

5.1.2. La herencia en Java

Una subclase se define indicando a que superclase extiende.

public class Item {

// Definición de la superclase Item.
}
public class Pelicula extends Item {
// Atributos y métodos adicionales para distinguir una
// pelicula de otros tipos de item
}

Una subclase hereda todas las variables instancia de la superclase.

Las variables de instancia deben ser private para que instancias de la subclase hereden sus valores.

public class Item {

protected float precio = 0;
protected String estado = "Excelente";
}
public class Pelicula extends Item {
private String titulo = "";
private int duracion = 0;
}

Una subclase no hereda ningún constructor de la superclase, debe declararse explícitamente.

Solo en caso no se declare explícitamente, se ejecutaran los constructores por defecto de las superclases y
finalmente de la subclase.

Autor: Ing. Ángel Chata T. 69 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Pelicula pelicula = new Pelicula ();

// Inicia variables de la clase Item. Constructor por defecto.
// Inicia variables de la clase Pelicula. Constructor por defecto.

Defina las subclases Libro y Equipo.

Como declararía las clases:

Hombre > Homínido > Primate > Placentario
Perro > Canino > Carnivoro > Placentario
Placentario > Mamífero > Vertebrado > Animal > Ser Vivo.

5.1.3. La referencia super

Se refiere a la clase padre
Se usa para invocar constructores de la clase padre
Debe ser la primera sentencia del constructor de la clase hijo
Esta referencia también se usa para invocar cualquier método del padre.

public class Item {

protected float precio = 0;
Item (float precio) {
this.precio = precio;
}
}

public class Pelicula extends Item {

private String titulo = "";
Pelicula (float precio, String titulo) {
super(precio);
this.titulo = titulo;
}
}

5.1.4. Métodos
La superclase define los métodos para todas las subclases.
La subclase puede especificar métodos propios.

Item0.java
public class Item0 {
protected float precio = 0;

Item0 (float precio) {

this.precio = precio;
}

public float getPrecio() {

return precio;
}
}

Pelicula0.java
public class Pelicula0 extends Item0
{
private String titulo = "";

Pelicula0 (float precio, String titulo) {

super(precio);
this.titulo = titulo;
}
public String getTitulo()

Autor: Ing. Ángel Chata T. 70 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

{
return titulo;
}
}

TestSuper.java
public class TestSuper {
public static void main (String[] args) {

Item0 item = new Item0(1.1f);

System.out.println( item.getPrecio() );

Pelicula0 pelicula = new Pelicula0(2.2f,"Zelig");

System.out.println( pelicula.getPrecio() );
System.out.println( pelicula.getTitulo() );

}
}

Que diferencia existe entre this y super?

Se puede reemplazar super(precio); por this.precio = precio; ?

Que métodos puede invocar una subclase?

La subclase hereda todos los métodos del padre.

La subclase puede re-escribir un método del padre.

Item1.java
public class Item1 {
public float calcularImporte(int cliente) {
return 50;
}
}
Pelicula1.java
public class Pelicula1 extends Item1 {
public float calcularImporte(int cliente) {
if (cliente < 500)
return 10;
else
return 30;
}
}
TestSobrescribir.java
public class TestSobrescribir {
public static void main (String[] args) {

Item1 item1 = new Item1();

System.out.println( item1.calcularImporte(599) );

Pelicula1 pelicula1 = new Pelicula1();

System.out.println( pelicula1.calcularImporte(399) );
System.out.println( pelicula1.calcularImporte(599) );

}
}

Cual es la diferencia entre sobre-carga de métodos y sobre-escritura de métodos?

5.1.5. La referencia super

Si una subclase sobrescribe un método de la superclase; el método de la superclase se puede invocar con la
referencia super.

Autor: Ing. Ángel Chata T. 71 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Item2.java
public class Item2 {
public float calcularImporte(int cliente) {
return 50;
}
}

Equipo2.java
public class Equipo2 extends Item2 {
public float calcularImporte(int cliente) {
float seguroEquipo = 25;
float alquiler = super.calcularImporte(cliente);
return seguroEquipo + alquiler;
}
}

TestSuper2.java
public class TestSuper2 {
public static void main (String[] args) {

Item2 articulo = new Item2();

System.out.println( articulo.calcularImporte(599) );

Equipo2 vhs = new Equipo2();

System.out.println( vhs.calcularImporte(599) );

}
}

5.2. Polimorfismo
Permite efectuar una misma operación dependiendo del tipo de objeto.

Ejemplo
TacoraFilms inicia sus operaciones alquilando únicamente películas.
Tres meses después amplia el alquiler a equipos, juegos y libros.

El alquiler de una pelicula es 2 soles por día de alquiler.

El alquiler de un equipo consta de un seguro de 50 soles además de 5 soles por día.
El alquiler de juegos depende del fabricante. PlayStation 2soles/día Nintendo 1sol/día
Los libros no se alquilan, se prestan uno a la vez, mientras sean clientes de la tienda.

Explique por que se obtienen los resultados

Alquiler3.java
public class Alquiler3 {
private int dias;
public Alquiler3(int dias) {
this.dias = dias;
}
public int getDias () {
return dias;
}
}

Item3.java
public class Item3 {
protected float calcularImporte(Alquiler3 contrato) {
return 0;
}
}

Autor: Ing. Ángel Chata T. 72 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Pelicula3.java
public class Pelicula3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
int importe = 2*contrato.getDias();
return importe;
}
}

Equipo3.java
public class Equipo3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
int seguroEquipo = 50;
int importe = seguroEquipo + 5*contrato.getDias();
return seguroEquipo + importe;
}
}
Juego3.java
public class Juego3 extends Item3 {
String fabricante;
public Juego3(String fabricante) {
this.fabricante = fabricante;
}
public String getFabricante() {
return fabricante;
}
protected float calcularImporte(Alquiler3 contrato) {
String fabricante = this.fabricante;
int tasa = 0;
if (fabricante.equals("PlayStation")) tasa = 2;
if (fabricante.equals("Nintendo")) tasa = 1;
int importe = tasa*contrato.getDias();
return importe;
}
}

Libro3.java
public class Libro3 extends Item3 {
protected float calcularImporte(Alquiler3 contrato) {
return 0;
}
}

TestPolimorfismo.java
public class TestPolimorfismo {
public static void main (String[] args) {

Alquiler3 contrato = new Alquiler3(10);

Pelicula3 oscar = new Pelicula3();

System.out.println( oscar.calcularImporte(contrato) );

Equipo3 vhs = new Equipo3();

System.out.println( vhs.calcularImporte(contrato) );

Juego3 mu = new Juego3("Nintendo");

System.out.println( mu.calcularImporte(contrato) );

Libro3 agua = new Libro3();

System.out.println( agua.calcularImporte(contrato) );

}
}

Autor: Ing. Ángel Chata T. 73 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

5.3. El operador instanceof y cast

El operador instanceof permite determinar la clase de un objeto en tiempo de ejecución.
La operación cast permite modificar la clase de un objeto.

public class TestOperador {

public static void main (String[] args) {
Pelicula3 oscar = new Pelicula3();
Equipo3 vhs = new Equipo3();
Juego3 mu = new Juego3("Nintendo");
Libro3 agua = new Libro3();

testOperador(oscar);
testOperador(vhs);
testOperador(mu);
testOperador(agua);
}
public static void testOperador (Item3 articulo) {
if (articulo instanceof Juego3) {
Juego3 juego = (Juego3) articulo;
System.out.println(juego.getFabricante());
}
else {
System.out.println("No tiene Fabricante");
}
}
}

5.4. Atributos, métodos y clases final

5.4.1. Variables final

Una variable final es una constante
Una variable final no puede ser modificada
Una variable final debe ser iniciada
Una variable final por lo general es publica para que pueda ser accesada externamente.

public final static String NEGRO = "FFFFFF";

public final static float PI = 3.141592f;
public final static int MAXIMO_ITEMS = 10;

5.4.2. Métodos final

Un método puede ser definida como final para evitar la sobre-escritura en una subclase.
Un método final no se puede redefinir en una clase hijo.

public final static String getBlanco() {

return "000000";
}
public final boolean verificarPassword(String password) {
if (password.equals(...
}

Autor: Ing. Ángel Chata T. 74 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

5.4.3. Clases final

Una clase final no puede ser padre de otra clase.
Una clase puede ser definida como final para evitar la herencia.
El compilador es mas eficiente con definiciones final por que no buscara estas clases o métodos al tratar clases
heredadas.

public final class Color {

public final static String NEGRO = "FFFFFF";
public final static String getBlanco() {
return "000000";
}
}

Ejercicio: Realizar lo siguiente.

Librería.java
public final class Libreria {
public final static String BLANCO = "000000";
public final static float PI = 3.141592f;

public final static int getModulo10(int numero)

{
// Obtiene el modulo 10 de la suma de digitos
if (numero < 0) numero = -numero;
String cadena = String.valueOf(numero);
int suma = 0;
for (int i=1; i < cadena.length(); i++) {
String caracter = cadena.substring(i-1,i);
int digito = Integer.parseInt(caracter);
suma += digito;
}
int residuo = suma%10;
return residuo;
}
}

TestLibreria.java
public class TestLibreria {
public static void main (String[] args) {
System.out.println(Libreria.BLANCO);
System.out.println(Libreria.PI);
System.out.println(Libreria.getModulo10(11));
System.out.println(Libreria.getModulo10(880385));
}
}

5.5. El método finalize()

Cuando todas las referencias de un objeto se pierden, se marcan para que el Garbage Collector los recoja y libere
ese espacio en memoria.

Pelicula pelicula = new Pelicula("Zelig");

pelicula = null;

El objeto "Zelig" que estaba referenciado por pelicula ha perdido todas sus referencias.
Luego el Garbage Collector liberara el espacio ocupado por "Zelig"

El método finalize es llamado justo antes que el Garbage Collector libere la memoria. En este instante se puede
aprovechar para realizar otras operaciones.

Autor: Ing. Ángel Chata T. 75 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

public class Pelicula4 {

private String titulo;
public Pelicula4(String titulo) {
this.titulo = titulo;
}
public void finalize()
{
System.out.println("Se acabo "+titulo);
}
}

public class TestFinalize {

public static void main (String[] args) {

Pelicula4 globo = new Pelicula4("Zelig");

globo = null;

}
}

5.6. Ejercicio
Encuentre los errores en el siguiente código.

Item.java
1. package alquiler;
2. public class Item {
3. public final int MAXIMO = 5;
4. public String getNombre() return "";
5. private String getColor() return "";
6. protected String getImporte() return "";
7. String getAlias() return "";
8. public final String getFabricante() return "";
9. }

Pelicula.java
1. package alquiler;
2. public class Pelicula extends Item {
3. public final int MAXIMO = 5;
4. public String getNombre() return super.getNombre();
5. private String getColor() return super.getColor();
6. protected String getImporte() return super.getImporte();
7. String getAlias() return super.getAlias();
8. public final String getFabricante()
9. return super.getFabricante();
10. }

Juguete.java
1. package almacen;
2. public final class Juguete {
3. Item item = new Item("");
4. public String getNombre() return item.getNombre();
5. public String getColor() return item.getColor();
6. protected String getImporte() return item.getImporte();
7. String getAlias() return item.getAlias();
8. }

Pelota.java
1. package almacen;
2. public final class Pelota extends Juguete {
3. public String getNombre() return super.getNombre();
4. public String getColor() return super.getColor();
5. protected String getImporte() return super.getImporte();

Autor: Ing. Ángel Chata T. 76 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

6. String getAlias() return super.getAlias();

7. }

5.7. Laboratorio.
Cree una clase Item.java con los siguientes atributos: id (int); titulo, descripción, ranking, categoría (String) , precio
de alquiler por dia (double). Todos estos atributos seran protected.
Agregue un atributo entero privado estático que inicia en 1000 para autogenerar el Id del item.
Agregue un constructor sin parámetros que autogenere un id para el item en base al atributo estático.
Agregue un segundo constructor con argumentos titulo, descripción, precio, ranking y categoría. Este constructor
invocara al primer constructor para asignar el id. Ademas asignara los argumentos a los atributos.
Agregue todos los métodos set y get para cada atributo.

Item.java
public class Item {
private static int siguienteId = 1000;
protected int id;
...
public Item() {
this.id = ++siguienteId;
}
public Item(String titulo... ) {
this();
this.titulo = titulo...
}
public int getId()...
...
public void setTitulo(String titulo)...
public String getTitulo()...
...
public static int getSiguienteId()...
}

La clase Cliente contara con 2 atributos, su id y su nombre. El id se generara automáticamente.

Cliente.java
public class Cliente {
private static int siguienteId = 2000;
protected int id;
...
public Cliente() {
this.id = ++siguienteId;
}
public Cliente(String nombre) {
this();
this.nombre...
}
public int getId()...
public String getNombre()...
}

Cree una clase Pelicula.java que herede de Item.java con los siguientes atributos: duracion (int) y director (String).
Estos atributos seran privados.
Agregue un constructor con argumentos titulo, descripción, precio, ranking, numero de dias, categoría, duración y
director. Este constructor invocara al constructor de la superclase y luego asignara los dos ultimos argumentos a sus
atributos privados.
Agregue todos los métodos set y get para sus dos atributos privados.
Agregue el método toString() que devuelva todos los atributos privados y heredados

Pelicula.java
public class Pelicula extends Item {
private String director;

Autor: Ing. Ángel Chata T. 77 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

private int duracion;

public Pelicula(String titulo ... int duracion) {

super(...);
this.director = director;
this.duracion = duracion;
}
public void setDirector...
public String getDirector...
public void setDuracion...
public String getDuracion...
public String toString...
}

Cree una clase Juego.java que herede de Item.java con los siguientes atributos: memoria (int) y tipo (String). Estos
atributos seran privados.
Agregue un constructor con argumentos titulo, descripción, precio, ranking, numero de dias, categoría, memoria y
tipo. Este constructor invocara al constructor de la superclase y luego asignara los dos últimos argumentos a sus
atributos privados.
Agregue todos los métodos set y get para sus dos atributos privados.
Agregue el método toString() que devuelva todos los atributos privados y heredados

Juego.java
public class Juego extends Item {
private int memoria;
private String tipo;

public Juego(String titulo ... String tipo) {

super(...);
this.memoria=...;
this.tipo=...;
}
...setMemoria...
...getMemoria...
...setTipo...
...getTipo...
public String toString...
}

En la base de datos se encontraran la lista de películas y los juegos.

BaseDeDatos.java
public class BaseDeDatos {
private static Cliente[] cliente = new Cliente [4];
private static Items[] item = new Item [4];

public BaseDeDatos() {
cliente[0] = new Cliente("Daneel Olivaw");
//...
item[0] = new Pelicula("La caravana del valor",...);
item[1] = new Pelicula("En las lunas de Endor",...);
item[2] = new Juego("Mu Online",...);
item[3] = new Juego("War Craft",...);
//...
}

public static Cliente getCliente(int id) {

for (...) {
break;
}
return cliente[];
}

public static Item getItem(int id) ...

Autor: Ing. Ángel Chata T. 78 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

La clase Alquiler.java contara con los siguientes atributos: un arreglo de Ítems que se alquilaran (Item) el cliente que
alquila (Cliente) un numero de alquiler id (int), la cantidad de ítems alquilados (int) y la cantidad de dias de alquiler
(int).
Un atributo de clase privado estático entero será el contador de id que iniciara en 500.
Una constante será el máximo numero de ítems a alquilar que es 10.
Una constante será el impuesto del alquiler de 19%.
Un constructor asignara el cliente por argumento y el numero de dias de alquiler. También creara el arreglo de ítems,
y su numero de alquiler.
Un método para agregar ítems al arreglo de ítems del alquiler.
Un método imprimira todo el detalle del alquiler en pantalla.

Alquiler.java
public class Alquiler {
private static int siguienteAlquilerId = 500;
private int alquilerId;
private int numeroDias;
private int clienteId;
private int cantidadItems;
private int[] itemId;
private final static int MAXITEMS = 10;
private final static double IMPUESTO = 0.19;
...
public Alquiler(int clienteId, int numeroDias) {
this.alquilerId = ...
this.clienteId = ...
...
itemId = new int[MAXITEMS];
}
public void agregarItem(int item) {
if (...) {
itemId[...] = item;
cantidadItems++;
}
else System.out.println("Demasiados ítems!");
}
public void imprimirReporte() {
/*
Cliente Id: 2000 Nombre: Salvor Hardin
Dias alquiler: 5
Detalle
1. El Padrino Precio = 1.10
2. Odisea 2001 Precio = 2.20
3. Aeropuerto 77 Precio = 3.30
Importe venta = 33.00
Importe total = 39.27

*/
}

El programa TacoraFilms realizara el alquiler

public class TacoraFilms {

public static void main(String[] args) {
Alquiler alquiler = new Alquiler(2001,5);
alquiler.agregarItem(1001);
alquiler.agregarItem(1002);
alquiler.agregarItem(1003);
alquiler.imprimerReporte();
}

Autor: Ing. Ángel Chata T. 79 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 80 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 6. CLASES ABSTRACTAS E INTERFASES

Resumen
Se estudiara el uso de clases abstractas, métodos abstractos, interfases, implementación de interfases

6.1. CLASES ABSTRACTAS

Clases abstractas

Sirven para modelar objetos de alto nivel, no contienen código, sino solo declaraciones. Todos sus
métodos deben existir en sus clases hijas.
Una clase abstracta no puede ser instanciada (Crear un objeto a partir de ella).

Métodos abstractos

Estos métodos son parte de clases abstractas

Un método abstracto debe ser redefinido en las subclases.
Cada subclase puede definir el método de manera diferente.

Las clases abstractas pueden contener métodos que no son abstractos.

Laboratorio.

Que falta en el siguiente código?

Item.java
public abstract class Item {
protected String titulo;
protected float precio = 5.0f;
public abstract boolean esAlquilable();
public float getPrecio() {
return precio;
}
}

Pelicula.java
public class Pelicula extends Item {
public boolean esAlquilable() {
return true;
}
}

Libro.java
public class Libro extends Item {
public float getPrecio() {
return 0.0f;
}
}

Abstracto.java
public class Abstracto {

Autor: Ing. Ángel Chata T. 81 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

public static void main (String[] args) {

Pelicula pelicula = new Pelicula();

Libro libro = new Libro();

System.out.println(pelicula.esAlquilable());
System.out.println(pelicula.getPrecio());
System.out.println(libro.esAlquilable());
System.out.println(libro.getPrecio());

6.2. Interfases
Una interfase es totalmente abstracta; todos sus métodos son abstractos, sus atributos son públicos
estáticos y final.
Una interfase define los métodos que otras clases pueden implementar pero no provee ninguna línea de
código.
Una clase solo puede heredar de una superclase.
Una clase puede implementar muchas interfases; por lo que las interfases permiten herencia múltiple.

Ejemplos de interfases:

Conducible

No Conducible

Las interfases describen la conducta que requiere muchas clases. El nombre de una interfase por lo
general es un adjetivo como Conducible, Ordenable, Ubicable.

Aquí se diferencia de una clase que usualmente es un sustantivo como Pelicula, Cliente,
Alquiler

Las clases implementadas por una interfase pueden ser no tener ninguna relación unas con otras.
A diferencia de las clases heredadas de una superclase tiene similitudes.

Las clases que implementan una interface deben definir todos los métodos de la interface.
Conducible.java
public interface Conducible {
public static final int MAXIMO_GIRO = 45;
public abstract void girarIzquierda(int grados);
public abstract void girarDerecha(int grados);

Autor: Ing. Ángel Chata T. 82 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

También se puede definir la interfase sin los calificadores public static final abstract, puesto
que son implícitos.

Para declarar que una clase que implementa una interfase se usa implements

Laboratorio

Que falta en el siguiente código?

Conducible.java
public interface Conducible {
int MAXIMO_GIRO = 90;
void girarIzquierda(int grados);
void girarDerecha(int grados);
}

NaveArea.java
public class NaveAerea {
protected char direccion;
protected int altura;
public void setDireccion(char direccion) {
this.direccion= direccion;
}
public char getDireccion() {
return this.direccion;
}
}

Globo.java
public class Globo extends NaveAerea implements Conducible {
private int volumenGas;
public void setVolumenGas(int volumenGas) {
this.volumenGas= volumenGas;
}
public int getVolumenGas() {
return this.volumenGas;
}
public void girarDerecha(int grados) {
if (getDireccion()=='N' && grados==90) setDireccion('E');
}
}

Patin.java
public class Patin implements Conducible {
public void girarDerecha(int grados) {
System.out.println("Giro de "+grados+" grados a la derecha");
}
public void girarIzquierda(int grados) {
System.out.println("Giro de "+grados+" grados a la izquierda");
}
}

TestInterface.java
public class TestInterface {

public static void main (String[] args) {

Globo zepelin = new Globo();

Autor: Ing. Ángel Chata T. 83 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

zepelin.setDireccion('N');
zepelin.girarDerecha(90);
System.out.println(zepelin.getDireccion());

Patin patin = new patin();

patin.girarDerecha(90);

EJERCICIO 1

Crear la interfaz PuedeCantar (que es capaz de cantar), un interfaz muy simple que sólo posee un
método cantar.

PuedeCantar.java
public interface PuedeCantar {
public void cantar();
}

Crear la clase Persona que implemente el interfaz Cantable y que cuando cante lo haga con las notas
musicales.

Persona.java
public class Persona implements PuedeCantar {
public void cantar() {
System.out.println("do re mi fa sol la si");
}
}

Crear la clase Canario y Gallo que implemente el interfaz PuedeCantar y que muestre como cantan
Canario.java
... System.out.println("pio pio pio") ...
Gallo.java
... System.out.println("ki ki ri ki") ...

Realice el programa que haga cantar a un canario y un tenor.

ProgramaInterfaz.java
public class ProgramaInterfaz {
public static void main(String arg[]) {

Persona pavaroti = new Persona();

hacerCantar(pavaroti);
Canario piolin = new Canario();
hacerCantar(piolin);
Gallo claudio = new Gallo();
hacerCantar(claudio);
}

public static void hacerCantar(PuedeCantar cantor) {

cantor.cantar();
}

}
Autor: Ing. Ángel Chata T. 84 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

Ejercicio 2.

Algunos seres pueden caminar y puede nadar estas dos capacidades son interfases
(PuedeCaminar.java y PuedeNadar.java). Los mamiferos son animales que pueden moverse
(Mamifero.java). El gato es un mamifero que puede nadar y moverse (Gato.java).
Un Loro puede caminar pero no puede nadar.

PuedeCaminar.java
public interface PuedeCaminar{
public void caminar();
}
PuedeNadar.java
public interface PuedeNadar {
public void nadar();
}
Mamifero.java
public class Mamifero {
String especie, color;
public void caminar() {
System.out.println("El mamífero camina");
}
}
Gato.java
public class Gato extends Mamifero implements PuedeCaminar, PuedeNadar {
private int numeroPatas = 4;
public void nadar() {
System.out.println("El gato nada");
}
}
Loro.java
public class Loro implements PuedeCaminar...
...System.out.println("El loro camina");
...

Interfaces.java
public class Interfaces {
public static void main(String[] args) {
Gato felix = new Gato();
felix.caminar();
felix.nadar();
Loro pepe = new Loro();
pepe.caminar();
}
}

Por que no se requiere escribir todos los métodos de las interfaces en la clase Gato?

Ejercicio adicional.

Agregue al ejercicio anterior la interface PuedeVolar.java

Agregue la superclase Aves.java
Herede la clase Avestruz.java (solo caminan)
Herede la clase Loro.java (caminan y vuelan)
Herede la clase Murciélago.java (es un mamífero que vuela y camina)

Autor: Ing. Ángel Chata T. 85 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Cree la clase Felino.java (es un mamifero que camina y puede nadar).

Modifique la clase Gato.java (es un Felino)
Cree la clase Tigre.java

Autor: Ing. Ángel Chata T. 86 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 7. COLECCIONES DE OBJETOS

Resumen
Se estudiara el uso de colecciones de objetos y una técnica de ordenación mediante interfaces.

7.1. LA CLASE OBJECT

Todas las clases en java heredan de la clase java.lang.Object.
Los siguientes métodos se heredan de la clase Object

boolean equals(Object obj) Indica si otro objeto es igual a otro.

int hashcode() Proporciona un valor hashcode para el objeto (id)
String toString() Proporciona una representación en cadena del objeto

Otros métodos se encuentran en:

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Object.html

7.1.1. Convertir primitivas en referencias

Las primitivas no se comparan con null.

Las primitivas no pueden integrar una Colección.
Para cada primitiva java provee un clase para convertirlo en referencia y tratarlo como un objeto y
resolver los problemas previos.

int precio ;
System.out.println(precio);
precio = 2;
System.out.println(precio + 5);

Integer objetoPrecio;
objetoPrecio = new Integer(precio);
System.out.println(objetoPrecio.toString());
System.out.println(objetoPrecio);
System.out.println(objetoPrecio+5);
System.out.println(objetoPrecio.intValue());
System.out.println(objetoPrecio.intValue()+5);

7.2. COLECCIONES
Es un conjunto librerías para manipular y almacenar datos. Estas librerías se llaman colecciones.

Las colecciones se organizan en:

- Interfaces: Manipulan los datos independientemente de los detalles de implementación.
- Clases: Implementan las interfaces.

Para programar con colecciones se debe:

- Elegir una interfaz adecuada a la funcionalidad requerida.
- Elegir una clase que implemente la interfaz
- Extender la clase si fuera necesario.

En que se diferencia una clase de una interface?

Autor: Ing. Ángel Chata T. 87 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

7.2.1. Arquitectura.
http://java.sun.com/j2se/1.4.2/docs/api/java/util/package-tree.html

Las interfaces y las clases están relacionadas en un armazón (framework) de colecciones para facilitar
su uso.
- Interfaces de colecciones que son definiciones abstractas de los tipos de colecciones.
- Clases que implementan las interfaces.
- Clases abstractas que implementan parcialmente las interfaces.
- Métodos estáticos que son algoritmos (por ejemplo ordenar una lista).
- Interfaces de soporte para las colecciones. (una infraestructura).

7.2.2. Interfaces de colecciones

http://java.sun.com/j2se/1.4.2/docs/api/java/util/package-tree.html
Interface
Collection Representa un grupo de objetos. Sin implementaciones directas, agrupa
la funcionalidad general que todas las colecciones ofrecen.

Set Colección que no puede tener objetos duplicados.

SortedSet Set que mantiene los elementos ordenados

List Colección ordenada que puede tener objetos duplicados

Map Colección que enlaza claves y valores; no puede tener claves

duplicadas y cada clave debe tener al menos un valor.

SortedMap Map que mantiene las claves ordenadas.

7.2.2.1. La interface Collection

http://java.sun.com/j2se/1.4.2/docs/api/java/util/Collection.html

Métodos de la interface
add(Object) Añade el objeto en la colección
addAll(Collection) Añade la colección.
clear() Quita todos los elementos de la colección.
contains(Object) ¿El objeto se encuentra en la colección?
containsAll(Collection) ¿Todos esos elementos están en la colección?
equals(Object) ¿Es igual esta colección al argumento?
isEmpty() ¿La colección está vacía?
Iterator iterator() Devuelve un iterador para la colección.
remove(Object) Elimina una aparición del objeto
removeAll(Collection) Elimina todos esos objetos
retainAll(Collection) Se queda sólo con los objetos del argumento
Autor: Ing. Ángel Chata T. 88 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

size() Número de elementos en la Colección

toArray() Devuelve un arreglo con los objetos de la colección.

7.2.2.2. La interface List

http://java.sun.com/j2se/1.4.2/docs/api/java/util/List.html
Colecciones ordenadas (secuencias) en las que cada elemento ocupa una posición identificada por un
índice. El primer índice es el 0. Las listas admiten duplicados.

Métodos de la interface
add(int, Object) Añade el objeto en la posición indicada
add(Object) Añade el objeto al final de la lista
addAll(int, Collection) Añade la colección en la posición
addAll(Collection) Añade la colección al final
clear() Quita todos los elementos de la lista.
contains(Object) ¿El objeto se encuentra en la lista?
containsAll(Collection) ¿Todos esos elementos están en la lista?
equals(Object) ¿Es igual la lista con el argumento?
get(int) Devuelve el objeto en la posición.
indexOf(Object) Devuelve la 1ra posición en la que está el objeto
isEmpty() ¿La lista está vacía?
Iterator iterator() Devuelve un iterador para la coleccion.
lastIndexOf(Object) Devuelve la última posición del objeto
ListIterator listIterator() Devuelve un iterador de lista
ListIterator listIterator(int) Devuelve un iterador de lista para la sublista que inicia en int
remove(int) Quita de la lista el objeto en esa posición
remove(Object) Elimina una aparición del objeto en la lista
removeAll(Collection) Elimina todos esos objetos
retainAll(Collection) Se queda sólo con los objetos del argumento
set(int, Object) Reemplaza el objeto en esa posición por el objeto
que se proporciona
size() Número de elementos en la Colección
List subList(int, int) Devuelve la sublista que comienza en el índice del primer
argumento hasta el indice del segundo argumento.
toArray() Devuelve un arreglo con los objetos de la colección.

7.2.2.3. La interface Map

http://java.sun.com/j2se/1.4.2/docs/api/java/util/Map.html
Son pares de datos(clave, valor). No puede haber claves duplicadas y cada clave se corresponde con al
menos un valor.

Métodos de la interface
clear() Elimina todos los pares del mapa
containsKey(Object) ¿La clave proporcionada se encuentra en el mapa?
containsValue(Object) ¿Hay algún par con el valor proporcionado?
equals(Object) ¿Es igual este mapa y el proporcionado?
get(Object) Devuelve el objeto que se corresponde con la clave dada.
isEmpty() ¿La lista está vacía?
put(Object clave, Object valor) Asocia la clave proporcionada con el valor proporcionado
putAll(Map) Agrega los pares de ese mapa
remove(Object) Quita la clave del mapa junto con su correspondencia.
size() Devuelve el número de pares que hay en el mapa.

7.3. Ejemplo de clases implementadas. List

Las interfases List, Set y SortedSet son descendientes de la interfase Collection
Autor: Ing. Ángel Chata T. 89 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

El concepto de Polimorfismo aplica para todas las clases que implementan estas interfases.
Las clases que implementan la interfase List son: ArrayList y LinkedList
Las clases que implementan la interfase Set son: HashSet y LinkedHashSet
La clase que implementa la sub-interfase SortedSet es: TreeSet.

7.3.1. Definiendo una clase

Para manipular las colecciones usaremos la clase Producto compuesta por dos atributos, un constructor
y un método get.
Producto.java
public class Producto {

private String nombre;

private int cantidad;

public Producto(String s, int i) {

nombre = s;
cantidad = i;
}

public String toString(){

return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {

return this.nombre;
}

7.3.2. Mostrar los elementos de una colección. ArrayList

En el ejemplo crearemos una lista del mercado y mostraremos sus elementos.

- Primero se importan las librerías de java.util.* donde se concentran la gran mayoría de las Clases del
"Collection Framework".
- Se inicia la declaración de la clase seguido de su método principal main.
- Se definen 5 instancias con el constructor de la clase Producto.
- Agregamos estas instancias al ArrayList con el método add
- Mostramos el número de objetos de la colección mediante el método size.
- Se declara una instancia Iterator la cual facilita la extracción de objetos de la colección.
- Se extrae los objetos del ArrayList y se muestran en pantalla.
- Se elimina el objeto con indice 2. Se muestra la lista nuevamente.
- Se eliminan todos los objetos mediante el método clear.

import java.util.*;
public class MercadoLista
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);

Autor: Ing. Ángel Chata T. 90 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Producto carne = new Producto("Carne", 2);

// Definir un ArrayList
ArrayList lista = new ArrayList();

// Colocar Instancias de Producto en ArrayList

lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
// Indica el indice de insercion
lista.add(1, carne);
lista.add(carne);

// Imprimir contenido de ArrayLists

System.out.println(" Lista del mercado con " + lista.size() +
" productos");

// Definir Iterator para extraer e imprimir sus valores

Iterator it = lista.iterator();
while ( it.hasNext() ) {
Object objeto = it.next();
Producto producto = (Producto)objeto;
System.out.println(producto);
}

// Eliminar elemento de ArrayList

lista.remove(2);
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
// Definir Iterator para extraer e imprimir valores

Iterator it2 = lista.iterator();

while ( it2.hasNext() ) {
Producto producto = (Producto)it2.next();
System.out.println(producto);
}

// Eliminar todos los valores del ArrayList

lista.clear();
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
}
}

7.3.3. Evitar objetos duplicados. HashSet

- Primero modificamos la clase Producto agregando dos métodos equals y hashCode
- El método equals desarrolla como se comparan dos objetos
- El método hashCode devuelve un identificador único.

Producto.java
public class Producto {

private String nombre;

private int cantidad;

Autor: Ing. Ángel Chata T. 91 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

public Producto(String s, int i) {

nombre = s;
cantidad = i;
}

public String toString(){

return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {

return this.nombre;
}

public boolean equals( Object objeto ) {

if (objeto == null) return false;

Producto producto = (Producto)objeto;

if (this.getNombre() == producto.getNombre() ) return true;

return false;
}

public int hashCode() {

return this.getNombre().hashCode();
}

- Aun cuando se agregaron 6 elementos, la lista solo cuenta con 5. Set no permite duplicados.
- La evaluacion de duplicidad de objetos se realiza mediante los métodos equals y hashCode.
- Un Set no cuenta con indice, por lo que para eliminar un elemento se indica el objeto.

MercadoHashSet.java
import java.util.*;
public class MercadoHashSet
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);
Producto res = new Producto("Carne", 3);

// Definir un HashSet
HashSet lista = new HashSet();
lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
lista.add(carne);
lista.add(res);

// Imprimir contenido de HashSet

// Aunque son insertados 6 elementos, el HashSet solo contiene 5
// Se debe a que un Set no permite elementos duplicados.

Autor: Ing. Ángel Chata T. 92 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

System.out.println(" Lista del mercado con " + lista.size() +

" productos");

// Definir Iterator para extraer e imprimir valores

for( Iterator it = lista.iterator(); it.hasNext(); ) {

Object objeto = it.next();
Producto producto = (Producto)objeto;
System.out.println(producto);
}

// No es posible eliminar elementos por indice

// En un HashSet solo se elimina por valor de Objeto

lista.remove(manzanas);
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
for( Iterator it2 = lista.iterator(); it2.hasNext();) {
Producto producto = (Producto)it2.next();
System.out.println(producto);
}

// Eliminar todos los valores del ArrayList

lista.clear();
System.out.println(" Lista del mercado con " + lista.size() +
" productos");
}
}

7.3.4. Manejar colecciones ordenadas. TreeSet

- Primero modificamos la clase Producto implementando un comparador para el ordenamiento.
- La clase implementa Comparable
- El método compareTo de la interfase Comparable indica que atributos se usaran para comparar.

import java.util.*;
public class Producto implements Comparable {

private String nombre;

private int cantidad;

public Producto(String s, int i) {

nombre = s;
cantidad = i;
}

public String toString(){

return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {

return this.nombre;
}

public boolean equals( Object objeto ) {

// Indica en base a que atributos se iguala el objeto
if (objeto == null) return false;
Producto producto = (Producto)objeto;

Autor: Ing. Ángel Chata T. 93 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

if (this.getNombre() == producto.getNombre() ) return true;

return false;
}

public int hashCode() {

// retorna un identificador unico del objeto.
return this.getNombre().hashCode();
}

public int compareTo( Object objeto ) {

// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
// Devuelve -1 si this es < que objeto
// Devuelve 0 si son iguales

Producto producto = (Producto)objeto;

String nombreObjeto = producto.getNombre().toLowerCase();
String nombreThis = this.getNombre().toLowerCase();

return( nombreThis.compareTo( nombreObjeto ) );

}
}

- Un TreeSet no permite elementos duplicados.

- Un TreeSet mantiene la lista ordenada.
- El elemento a comparar debe contar con métodos equals, hashCode y compareTo.

MercadoTreeSet.java
import java.util.*;
public class MercadoTreeSet
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);
Producto res = new Producto("Carne", 3);

// Definir un TreeSet
TreeSet lista = new TreeSet();
lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
lista.add(carne);
lista.add(res);

// Imprimir contenido de TreeSet

// Aunque se agregan 6 elementos, el TreeSet solo contiene 5
// TreeSet no permite elementos duplicados,
// TreeSet detecta que el elemento "Carne" esta duplicado
// Notese que el orden del TreeSet refleja un orden ascendente
mostrarLista(lista);

// No es posible eliminar elementos por indice

Autor: Ing. Ángel Chata T. 94 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

// Un TreeSet solo elimina por valor de Objeto

lista.remove(manzanas);
mostrarLista(lista);

// Eliminar todos los valores del TreeSet

lista.clear();
mostrarLista(lista);
}

public static void mostrarLista(Collection lista) {

System.out.println(" Lista del mercado con " + lista.size() +
" productos");
for( Iterator it = lista.iterator(); it.hasNext();) {
Producto producto = (Producto)it.next();
System.out.println(producto);
}

}
}

7.3.5. Ordenar y buscar en Colecciones. Collections.

- La clase Collections (que no es la interface Collection) nos permite ordenar y buscar elementos en
listas.
- Se usaran los métodos sort y binarySearch
- Los objetos de la lista deben tener métodos equals, hashCode y compareTo adecuados.

MercadoCollections.java
import java.util.*;
public class MercadoCollections
{
public static void main(String args[])
{
// Definir 5 instancias de la Clase Producto
Producto pan = new Producto("Pan", 6);
Producto leche = new Producto("Leche", 2);
Producto manzanas = new Producto("Manzanas", 5);
Producto brocoli = new Producto("Brocoli", 2);
Producto carne = new Producto("Carne", 2);

// Definir un ArrayList
ArrayList lista = new ArrayList();

// Colocar Instancias de Producto en ArrayList

lista.add(pan);
lista.add(leche);
lista.add(manzanas);
lista.add(brocoli);
lista.add(1,carne);

// Imprimir contenido de ArrayList

mostrarLista(lista);

// Ordenar elemntos de ArrayList

Collections.sort(lista);

// Imprimir contenido de ArrayList

Autor: Ing. Ángel Chata T. 95 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

mostrarLista(lista);

// Buscar un elemento que se compare con Pan de tipo String

String buscar = "Pan";
int indice = Collections.binarySearch(lista,buscar);

System.out.println(buscar+" es el elemento "+indice);

public static void mostrarLista(Collection lista) {

System.out.println(" Lista del mercado con " + lista.size() +
" productos");
int i=0;
for( Iterator it = lista.iterator(); it.hasNext(); i++) {
Producto producto = (Producto)it.next();
System.out.println(i+"-"+producto);
}

}
}

Producto.java
import java.util.*;
public class Producto implements Comparable {

private String nombre;

private int cantidad;

public Producto(String s, int i) {

nombre = s;
cantidad = i;
}

public String toString(){

return ("Nombre: "+nombre+" Cantidad: "+cantidad);
}

public String getNombre() {

return this.nombre;
}

public boolean equals( Object objeto ) {

// Indica en base a que atributos se iguala el objeto
if (objeto == null) return false;
Producto producto = (Producto)objeto;
if (this.getNombre() == producto.getNombre() ) return true;

return false;
}

public int hashCode() {

// retorna un identificador unico del objeto.
return this.getNombre().hashCode();
}

public int compareTo( Object objeto ) {

// Indica en base a que atributos se compara el objeto
// Devuelve +1 si this es > que objeto
Autor: Ing. Ángel Chata T. 96 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

// Devuelve -1 si this es < que objeto

// Devuelve 0 si son iguales

// Dependera del argumento como comparar los atributos.

String nombreObjeto;
if (objeto instanceof Producto ) {
Producto producto = (Producto)objeto;
nombreObjeto = producto.getNombre().toLowerCase();
}
else
if (objeto instanceof String) {
String producto = (String)objeto;
nombreObjeto = producto.toLowerCase();
}
else {
nombreObjeto = "";
}

String nombreThis = this.getNombre().toLowerCase();

return( nombreThis.compareTo( nombreObjeto ) );

}

7.4. Ejemplo de clases implementadas. Map

La clase que implementan la interfase Map es HashMap.
La clase que implementa la sub-interfase SortedMap es TreeMap.

7.4.1. Ejemplo de HashMap

- Se define una instancia de la clase HashMap
- Se colocan 9 pares clave-valor con el método put.
- Se muestra el contenido mediante un iterador que extrae los valores del HashMap.
- Se define un arreglo de String con tres claves para eliminar de la agenda.
- Se elimina las claves de la agenda

Ejercicio: Verifique si permite duplicados

AgendaHashMap.java
import java.util.*;
public class AgendaHashMap
{
public static void main(String args[])
{
// Definir un HashMap
HashMap agenda = new HashMap();

// Agregar pares "clave"-"valor" al HashMap

agenda.put("Doctor", "(+52)-4000-5000");
agenda.put("Casa", "(888)-4500-3400");
agenda.put("Hermano", "(575)-2042-3233");
agenda.put("Tio", "(421)-1010-0020");
agenda.put("Suegros", "(334)-6105-4334");

Autor: Ing. Ángel Chata T. 97 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

agenda.put("Oficina", "(304)-5205-8454");
agenda.put("Abogado", "(756)-1205-3454");
agenda.put("Papa", "(55)-9555-3270");
agenda.put("Tienda", "(874)-2400-8600");

// Definir Iterator para extraer/imprimir valores

mostrarMapa(agenda);

// Definir un arreglo con valores determinados

String personas[] = {"Tio", "Suegros", "Abogado"};

// Eliminar los valores contenidos en el arreglo

for(int i = 0; i < personas.length; i++) {
agenda.remove(personas[i]);
}
mostrarMapa(agenda);
}

public static void mostrarMapa(Map agenda) {

System.out.println(" Agenda con " + agenda.size() +
" telefonos");
for( Iterator it = agenda.keySet().iterator(); it.hasNext();) {
String clave = (String)it.next();
String valor = (String)agenda.get(clave);
System.out.println(clave + " : " + valor);
}
}
}

7.4.2. Ejemplo de TreeMap

- En un TreeMap los elementos estan ordenados por la clave
- Luego se definen dos referencias de la interfase SortedMap
- En la primera se colocan las claves que se encuentran entre A y O. Metodo submap("A", "O")
- La segunda almacena las claves desde la P hacia el final.
- Estas comparaciones se han hecho con la clase String.
- Otras clases deberán definir sus propios métodos compareTo, equals y hashCode.

AgendaTreeMap.java
import java.util.*;
public class AgendaTreeMap
{
public static void main(String args[])
{
// Definir un TreeMap
TreeMap agenda = new TreeMap();

// Agregar pares "clave"-"valor" al HashMap

agenda.put("Doctor", "(+52)-4000-5000");
agenda.put("Casa", "(888)-4500-3400");
agenda.put("Hermano", "(575)-2042-3233");
agenda.put("Tio", "(421)-1010-0020");
agenda.put("Suegros", "(334)-6105-4334");
agenda.put("Oficina", "(304)-5205-8454");
agenda.put("Abogado", "(756)-1205-3454");
agenda.put("Papa", "(55)-9555-3270");
agenda.put("Tienda", "(874)-2400-8600");

Autor: Ing. Ángel Chata T. 98 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

// Notese que el orden del TreeMap refleja un orden ascendente

// en sus elementos independientemente del orden de insercion.
// Debido al uso de String se refleja un orden alfabetico
mostrarMapa(agenda);

// Definir dos TreeMap nuevos

SortedMap agendaAO = agenda.subMap("A", "O");
SortedMap agendaPZ = agenda.tailMap("P");

System.out.println("---- Agenda A-O ----");

mostrarMapa(agendaAO);

System.out.println("---- Agenda P-Z ----");

mostrarMapa(agendaPZ);

public static void mostrarMapa(Map agenda) {

System.out.println(" Agenda con " + agenda.size() +
" telefonos");
for( Iterator it = agenda.keySet().iterator(); it.hasNext();) {
String clave = (String)it.next();
String valor = (String)agenda.get(clave);
System.out.println(clave + " : " + valor);
}
}
}

7.5. EJERCICIO
public class Pelicula6 {
private int codigo;
private String titulo;
private float precio;
private String tipo;
Pelicula(int codigo, String titulo, float precio, String tipo) {
...
}
...
}
public class TestCartelera {
public static void main (String[] args) {
...
}
}
En la clase pelicula agregue los métodos compareTo, equals y hashCode.
En el programa TestCartelera.java cree una lista ordenada (TreeSet) de 5 películas y muestrelas en
orden alfabetico. Muestrelas en orden inverso también.
Agregue dos películas mas y muestre las películas.
Coloque las 7 peliculas en una mapa (TreeMap) el objeto pelicula será la clave y su valor será un String
que almacena el nombre del cliente que lo alquila.

Autor: Ing. Ángel Chata T. 99 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 8. MANEJO DE EXCEPCIONES.

Resumen
Se estudiara conceptos básicos para el manejo de excepciones.

8.1. EXCEPCIONES

8.1.1. Definiciones

Que es una excepción?

Es un evento que interrumpe la ejecución de un programa
- Usar un índice fuera de los limites de un arreglo
- Dividir entre cero
- Realizar métodos de objetos nulos.
Que es un error?
En java es cuando la situación es irrecuperable y termina el programa.
- No hay memoria para correr JVM
- Errores internos en JVM
Cual es la diferencia?
Una excepción se puede controlar en el programa. Un error no.

8.1.2. Características del Java

Cuando ocurre una excepción en un método, Java lanza (throws) una excepcion (Exception).
El objeto Exception generado contiene el tipo de excepción, y el estado del programa cuando ocurrió el
error.

Separando el manejo de errores

El manejo de excepciones en java permite separarlos del algoritmo principal.
El resultado es un código mas legible y menos propenso a errores de programación.

Manejo tradicional de errores. Manejo de excepciones en Java.

int leerRegistroArchivo() { leerRegistroArchivo() {

int errorCode = 0; try {
abrirArchivo(); abrirArchivo();
if (errorAbrirArchivo) { leerArchivo();
errorCode = OPEN_ERROR; cerrarArchivo();
} }
else { catch (errorAbrirArchivo) {
leerArchivo(); manejarErrorAbrirArchivo;
if (errorLeerArchivo) { }
errorCode = READ_ERROR; catch (errorLeerArchivo) {
} manejarErrorLeerArchivo;
cerrarArchivo(); }
if (errorCerrarArchivo) { catch (errorCerrarArchivo) {
errorCode = CLOSE_ERROR; manejarErrorCerrarArchivo;
} }
} }
return errorCode;
}
Java separa los detalles del manejo de errores del código principal, obteniéndose un código mas legible
y menos propenso a errores de codificación.

Autor: Ing. Ángel Chata T. 100 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

8.1.3. Excepciones

Devolviendo la excepción hasta el manejador de excepciones.

No se requiere que cada método invocado maneje la excepción, sino únicamente lo hará el primer
manejador de excepciones de la lista de métodos invocados.

Maneo Tradicional de errores Excepciones en Java

Metodo1 Metodo1
Manejo de errores Manejo de excepciones
Código de error

Metodo2 Metodo2

Código de error
Metodo3 Metodo3
Código de error
Excepcion
Metodo4 Metodo4

El método4 retorna el código de error al El metodo4 lanza una excepción

método3. El metodo1 captura la excepción y la maneja
El método3 retorna el código de error al
método2
El método2 retorna el código de error al
metodo1
El metodo1 maneja el error.

Las excepciones no pueden ignorarse

Una vez que un método lanza un error no puede ignorarse a diferencia de la programación tradicional
donde se debe controlar en cada punto de invocación.

Autor: Ing. Ángel Chata T. 101 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Maneo Tradicional de errores Excepciones en Java

Metodo1 Metodo1
Manejo de errores Manejo de excepciones

Metodo2 Metodo2

Metodo3 Metodo3
Código de error
Excepcion
Metodo4 Metodo4

8.1.4. Throwable

Todos los errores y excepciones heredan de la clase Throwable

Throwable

Error Exception

Errores Excepciones RuntimeException

Irrecuperables Controladas
Excepciones
no Controladas
(run-time)

Errores.
Heredan de la clase Error; estos se generan cuando ocurren errores fatales para el programa como por
ejemplo: cuando la memoria esta llena o cuando es imposible encontrar una clase requerida.

Excepciones no controladas
Heredan de la clase RuntimeException.
Estas ocurren cuando por ejemplo se divide entre cero o se intenta acceder a un elemento del arreglo
fuera de sus limites.
Mediante código se puede capturar, manipular o ignorar estas excepciones.
Si no maneja el error, el java terminara el programa indicando el estado del error.

Excepciones controladas
Heredan de la clase Exception.
Estas deben ser capturadas y manejadas en algun lugar de la aplicación.
Las excepciones creadas por el programador seran heredadas de la clase Exception.
Autor: Ing. Ángel Chata T. 102 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

8.1.5. Que se puede hacer con una Excepción?

Excepciones controladas

Se puede:

- Capturar la excepción y manipularla

- Pasar la excepción al método invocador.
- Capturar la excepción y lanzar una excepción diferente.

Excepciones no controladas

No necesitan ser controladas en el código.

El JVM terminara el programa cuando las encuentra.
Si no desea que el programa termine tendrá que manejarlas.

8.2. EXCEPCIONES CON JAVA

8.2.1. Como capturar y manejar una excepción

- Encierre el código del método en un bloque try {

try // código del método
- Maneje cada exception en un bloque catch. }
- Cualquier proceso final realícelo en un catch (exception1) {
bloque finally. Este bloque siempre se // manejar la excepción1
ejecutara, ocurra o no una excepción. }
catch (exception2) {
// manejar la excepción2
}
...
finally {
// cualquier otro proceso final
}

La documentación del java indicara que excepciones lanza los métodos del java.

Clase : java.io.FileInputStream
Método: public FileInputStream(String name)
throws FileNotFoundException
Método: public int read() throws IOException

http://java.sun.com/j2se/1.4.2/docs/api/java/io/FileInputStream.html

8.2.2. Capturando una excepción.

Este ejemplo convierte una cadena en un entero

int cantidad;
String cadena = "5";
Autor: Ing. Ángel Chata T. 103 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

try {
cantidad = Integer.parseInt(cadena);
}
catch ( NumberFormatException e) {
System.err.println(cadena + " no es un entero");
}

Laboratorio:
Pruebe este ejemplo en un programa TestException.java. Cambie la cadena por "cinco", "1.1", "2f".

8.2.3. Capturando múltiples excepciones

Este ejemplo convierte una cadena en un entero y realiza una division.

public class TestMultiException {

public static void main (String[] args) {

int cantidad= 0;
int divisor = 0;
String cadena = "5";
try {
cantidad = Integer.parseInt(cadena);
System.out.println(cantidad);
int resultado = cantidad / divisor;
System.out.println(resultado);
}
catch ( NumberFormatException e) {
System.err.println(cadena + " no es un entero");
}
catch ( ArithmeticException e) {
System.err.println("Error en "+cantidad+"/"+divisor);
}
}
}

Laboratorio:
Pruebe este ejemplo en un programa TestMultiException.java. Cambie la cadena por "cinco",
"1.1", "5" y divisor cambie por 0, 1, 500

8.2.4. Ejecución del bloque finally

El bloque finally siempre se ejecuta dependiendo como se termina el bloque try.

- Hasta terminar la ultima sentencia del bloque try.
- Debido a sentencias return o break en el bloque try.
- Debido a una excepción.

public class TestFinally {

public static void main (String[] args) {

int cantidad= 0;
int divisor = 0;
String cadena = "5";
try {

Autor: Ing. Ángel Chata T. 104 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

if (cadena.equals("5"))
return;

cantidad = Integer.parseInt(cadena);
System.out.println(cantidad);
int resultado = cantidad / divisor;
System.out.println(resultado);
}
catch ( NumberFormatException e) {
System.err.println(cadena + " no es un entero");
}
catch ( ArithmeticException e) {
System.err.println("Error en "+cantidad+"/"+divisor);
}
finally {
System.err.println("Se trabajo con "+cadena+" y
"+divisor);
}
}
}

Laboratorio:
Pruebe este ejemplo, cambie la cadena por "cinco", "1.1", "5" y divisor cambie por 0, 1, 500

8.2.5. Como pasar la excepción al método invocado.

Para pasar el método al invocador, se declara con la declaración throws.

La excepción se propaga al método que lo invoco.
En el ejemplo, las excepciones de los métodos se manejan en el método invocador.

public void metodoInvocador() {

try {
miMetodo();
getResultado();
}
catch {
}
finally {
}
}
public int miMetodo() throws Exception {
// código que podria lanzar la Exception
}
public int getResultado() throws NumberFormatException {
// código que podria lanzar la exception NumberFormatException
}
TestThrows.java
public class TestThrows {

public static void main (String[] args) {

String cadena = "abcde";

int posicion = 6;
char letra = ' ';
try {
letra = getLetra(cadena,posicion);
System.out.println(letra );

Autor: Ing. Ángel Chata T. 105 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

}
catch (IndexOutOfBoundsException e) {
System.err.println("Error en "+cadena+" "+posicion);
}
}
public static char getLetra(String cadena, int posicion)
throws IndexOutOfBoundsException
{
char c = cadena.charAt(posicion);
return c;
}
}

Laboratorio. Cambie posición 6 por –1, 0, 1

8.2.6. Como lanzar una excepción

Para lanzar una excepción use las declaraciones throws y throw

Puede crear excepciones para manejar posibles problemas en el código.

public String getValor(int indice) throws IndexOutOfBoundsException {

if (indice < 0 || indice > 100) {
throw IndexOutOfBoundsException();
}
}

8.2.7. Como crear una excepción

Para crear su propia excepción tiene que heredarla de la clase Exception.

Puede ser usado en caso quiera tratar cada problema en el código en forma diferente.
Por ejemplo el manejo del archivo1 puede tratarlo con una excepción1. El manejo de un archivo2 puede
tratarlo con una excepcion2. Cada archivo tendria su propia excepción.

UserFileException.java
public class UserFileException extends Exception {
public UserFileException (String mensaje) {
super(mensaje);
}
}

8.2.8. Como capturar una excepción y lanzar otra diferente.

En el ejemplo si ocurre un problema de IO (entrada/salida) se captura la excepción y se lanza una

excepción propia.

public void ReadUserFile throws UserFileException {

try {
// código que manipula un archivo
}
catch (IOException e) {
throw new UserFileException(e.toString());
}
}

Autor: Ing. Ángel Chata T. 106 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

8.3. LABORATORIO
Ensaye este ejemplo

public class CerradoException extends Exception {

public CerradoException () {}
public CerradoException (String msg) {
super(msg);
}
}

public class TestCerradoException {

public static void main(String[] args) {

try {
abrirLaPuerta();
} catch(CerradoException e) {
// printStackTrace muestra la traza de la excepcion.
e.printStackTrace(System.err);
}
try {
abrirLaVentana();
} catch(CerradoException e) {
// System.err es el stream de salida de errores
// similar a System.out.
e.printStackTrace(System.err);
}
}

public static void abrirLaPuerta() throws CerradoException {

System.out.println("abrirLaPuerta()? tiene candado!");
throw new CerradoException ("Originado en abrirLaPuerta()");
}

public static void abrirLaVentana() throws CerradoException {

System.out.println("abrirLaVentana()? Esta con cerrojo!");
throw new CerradoException ("Originado en abrirLaVentana()");
}

8.4. EJERCICIO
Agregue los siguientes métodos al programa TestExcepcionTeclado.java. Cree excepciones para
su control.

// método que lea solo un carácter.

public static char readChar(String etiqueta)...

// método que lea un decimal con enteros y decimales.

public static float readNumber(String etiqueta, int enteros, int decimales)...

// método que lea una dirección IP xxx.xxx.xxx.xxx

// 0 <= xxx <= 255
public static String readIP(String etiqueta)...

// método que lea un codigo valido de alumno UNI

public static String readCodigoUNI(String etiqueta)...

Autor: Ing. Ángel Chata T. 107 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

// método que lea una fecha valida

// formato dd/mm/yyyy
public static String readDate(String etiqueta)

TestExcepcionTeclado.java
import java.io.*;
public class TestExcepcionTeclado {

public static void main (String[] args) {

try {
String nombre = readString("Ingrese un nombre: ");
System.out.println("Su longitud es "+nombre.length());

int entero = readInt("Ingrese un entero: ");

System.out.println("El cuadrado es "+entero*entero);
}
catch (NumberFormatException e) {
System.out.println("Excepcion numerica");
e.printStackTrace(System.err);
}
catch (ArithmeticException e) {
System.out.println("Excepcion artimetica");
e.printStackTrace(System.err);
}
catch (IndexOutOfBoundsException e) {
System.out.println("Excepcion de arreglos");
e.printStackTrace(System.err);
}
catch (Exception e) {
System.out.println("Excepcion");
e.printStackTrace(System.err);
}

public static String readString(String etiqueta)

throws Exception
{
System.out.print(etiqueta);
String cadena="";
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
cadena = in.readLine();
return cadena;
}

public static int readInt(String etiqueta)

throws Exception
{
int entero = 0;
String cadena = readString(etiqueta);
Integer enteroInteger = new Integer( cadena.trim());
entero = enteroInteger.intValue();
return entero;
}

Autor: Ing. Ángel Chata T. 108 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Tema 9. Aplicaciones con Bases de datos en Java

Resumen
Se estudiara conceptos de conexión a bases de datos mediante diferentes métodos de conexión y luego
poder crear aplicaciones que usen una o más bases de datos a la vez.

9.1. Conectividad JDBC

9.1.1. Definiciones iníciales

JDBC es para Java lo que ODBC es para Windows®.

Windows® en general no sabe nada acerca de bases de datos, pero define el estándar
ODBC consistente en un conjunto de primitivas que cualquier driver o fuente ODBC debe ser
capaz de entender y manipular.

Los programadores que a su vez deseen escribir programas para manejar bases de datos
genéricas en Windows utilizan las llamadas ODBC.

Con JDBC ocurre lo mismo: JDBC es una especificación de un conjunto de clases y métodos
de operación que permiten a cualquier programa Java acceder a sistemas de bases de datos
de forma homogénea.

Sólo que JDBC no se limita al Windows® sino que se puede utilizar en cualquier sistema
operativo o plataforma.

Lógicamente, al igual que ODBC, la aplicación de Java debe tener acceso a un driver JDBC
adecuado. Este driver es el que implementa la funcionalidad de todas las clases de acceso a
datos y proporciona la comunicación entre el API JDBC y la base de datos real.

Autor: Ing. Ángel Chata T. 109 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Toda la conectividad de bases de datos de Java se basa en sentencias SQL, por lo que se
hace imprescindible un conocimiento adecuado de SQL para realizar cualquier clase de
operación de bases de datos.

Casi todos los entornos de desarrollo Java ofrecen componentes visuales que proporcionan
una funcionalidad suficientemente potente sin necesidad de que sea necesario utilizar SQL,
aunque para usar directamente el JDK se haga imprescindible.

La especificación JDBC requiere que cualquier driver JDBC sea compatible con al menos el
nivel «de entrada» de ANSI SQL 92 (ANSI SQL 92 Entry Level).

9.1.2. Acceso JDBC a base de datos

El API JDBC soporta dos modelos diferentes de acceso a Bases de Datos, los modelos de dos
y tres capas.

Modelo de dos capas

Este modelo se basa en que la conexión entre la aplicación Java o el applet que se ejecuta
en el navegador, se conectan directamente a la base de datos.

Esto significa que el driver JDBC específico para conectarse con la base de datos, debe
residir en el sistema local. La base de datos puede estar en cualquier otra máquina y se
accede a ella mediante la red. Esta es la configuración de típica Cliente/Servidor: el
programa cliente envía instrucciones SQL a la base de datos, ésta las procesa y envía los
resultados de vuelta a la aplicación.

Modelo de tres capas

En este modelo de acceso a las bases de datos, las instrucciones son enviadas a una capa
intermedia entre Cliente y Servidor, que es la que se encarga de enviar las sentencias SQL a
la base de datos y recoger el resultado desde la base de datos. En este caso el usuario no
tiene contacto directo, ni a través de la red, con la máquina donde reside la base de datos.

Autor: Ing. Ángel Chata T. 110 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Este modelo presenta la ventaja de que el nivel intermedio mantiene en todo momento el
control del tipo de operaciones que se realizan contra la base de datos, y además, está la
ventaja adicional de que los drivers JDBC no tienen que residir en la máquina cliente, lo cual
libera al usuario de la instalación de cualquier tipo de driver.

9.1.3. Tipos de drivers

Un driver es una librería .jar por lo general, la que engloba clases totalmente escritas en
Java las que permiten conectarse a una base de datos y trabajar con ellas.

Un driver JDBC puede pertenecer a una de cuatro categorías diferentes en cuanto a la forma
de operar.

1. Puente JDBC-ODBC
2. Java Binario
3. Java Protocolo Nativo
4. Java Protocolo Independiente

Todos estos drivers deben usarse referenciándose la librería .jar en el proyecto Java que los utilice.

9.2. Puente 1. JDBC-ODBC

Ésta primera categoría de drivers es la utilizada por Sun inicialmente para popularizar JDBC
y consiste en aprovechar todo lo existente, estableciendo un puente entre JDBC y ODBC.
Este driver convierte todas las llamadas JDBC a llamadas ODBC y realiza la conversión
correspondiente de los resultados.

Autor: Ing. Ángel Chata T. 111 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

9.2.1 Ventajas

 Java dispone de acceso inmediato a todas las fuentes posibles de bases de datos
 No hay que hacer ninguna configuración adicional aparte de la ya existente.

9.2.2 Desventajas

 La mayoría de los drivers ODBC a su vez convierten sus llamadas a llamadas a una
librería nativa del fabricante DBMS
o La lentitud del driver JDBC-ODBC puede ser exasperante, al llevar dos capas
adicionales que no añaden funcionalidad alguna

 El puente JDBC-ODBC requiere una instalación ODBC ya existente y configurada.

 Lo anterior implica que para distribuir con seguridad una aplicación Java que use
JDBC habría que limitarse en primer lugar a entornos Windows (donde está definido
ODBC)

 Se debe proporcionar los drivers ODBC adecuados y configurarlos correctamente.

9.2.3 Resumen

Esto hace que este tipo de drivers esté descartado en el caso de aplicaciones comerciales, e
incluso en cualquier otro desarrollo, debe ser considerado como una solución transitoria,
porque el desarrollo de drivers totalmente en Java hará innecesario el uso de estos puentes.

9.3. Java Binario

Este driver salta la capa ODBC y usa directamente la librería nativa del fabricante del gestor
de base de datos (como pudiera ser DB-Library para Microsoft SQL Server o CT-Lib para
Sybase SQL Server).

Autor: Ing. Ángel Chata T. 112 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Este driver es un driver 100% Java pero aún así necesita la existencia de un código binario
(la librería DBMS) en la máquina del cliente, con las limitaciones y problemas que esto
implica.

9.3.1 Ventajas

 Igualmente, dependiendo de la forma en que esté programado el driver, puede no

necesitar ninguna clase de configuración por parte del usuario
 No hay que hacer ninguna configuración adicional aparte de la ya existente.

9.3.2 Desventajas

 El cliente está ligado a un servidor DBMS concreto.

 Se debe proporcionar los drivers ODBC adecuados y configurarlos correctamente.

9.3.3 Resumen

Esto hace que este tipo de drivers se use ampliamente en casos en que se va a trabajar con
un único gestor base de datos, sin embargo en casos de tener que cambiar de gestor habrá
que conseguir el driver de dicho gestor y se resuelve la dificultad de una manera
relativamente sencilla.

9.4. Java Protocolo independiente

Esta es la opción más flexible, se trata de un driver 100% Java / Protocolo independiente,
que requiere la presencia de un intermediario en el servidor.

Autor: Ing. Ángel Chata T. 113 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

En este caso, el driver JDBC hace las peticiones de datos al intermediario en un protocolo de
red independiente del servidor DBMS.

El intermediario a su vez, que está ubicado en el lado del servidor, convierte las peticiones
JDBC en peticiones nativas del sistema DBMS.

9.4.1 Ventajas

 El programa que se ejecuta en el cliente

 Los drivers son 100% Java

 Independencia respecto al sistema de bases de datos que se encuentra en el

servidor.

9.4.2 Desventajas

 Sería el costo del servidor de base de datos y no del mismo dirver.

9.4.3 Resumen

Si una empresa distribuye una aplicación Java para que sus usuarios puedan acceder a su servidor MS
SQL Server y posteriormente decide cambiar el servidor por Oracle, MySql, PostGres o DB2, no necesita
volver a distribuir la aplicación, sino que únicamente debe reconfigurar la aplicación residente en el
servidor que se encarga de transformar las peticiones de red en peticiones nativas.

9.5. Lista de drivers y de cadenas de conexión

IBM DB2
jdbc:db2://<HOST>:<PORT>/<DB>
COM.ibm.db2.jdbc.app.DB2Driver

JDBC-ODBC Bridge (Access, FoxPro, Excel, Paradox, etc.)

jdbc:odbc:<DB>
sun.jdbc.odbc.JdbcOdbcDriver

Autor: Ing. Ángel Chata T. 114 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Microsoft SQL Server

jdbc:weblogic:mssqlserver4:<DB>@<HOST>:<PORT>
weblogic.jdbc.mssqlserver4.Driver

Oracle Thin
jdbc:oracle:thin:@<HOST>:<PORT>:<SID>
oracle.jdbc.driver.OracleDriver

PointBase Embedded Server

jdbc:pointbase://embedded[:<PORT>]/<DB>
com.pointbase.jdbc.jdbcUniversalDriver

Cloudscape
jdbc:cloudscape:<DB>
COM.cloudscape.core.JDBCDriver

Cloudscape RMI
jdbc:rmi://<HOST>:<PORT>/jdbc:cloudscape:<DB>
RmiJdbc.RJDriver

Firebird (JCA/JDBC Driver)

jdbc:firebirdsql:[//<HOST>[:<PORT>]/]<DB>
org.firebirdsql.jdbc.FBDriver

IDS Server
jdbc:ids://<HOST>:<PORT>/conn?dsn='<ODBC_DSN_NAME>'
ids.sql.IDSDriver

Informix Dynamic Server

jdbc:informix-sqli://<HOST>:<PORT>/<DB>:INFORMIXSERVER=<SERVER_NAME>
com.informix.jdbc.IfxDriver

InstantDB (v3.13 and earlier)

jdbc:idb:<DB>
jdbc.idbDriver

InstantDB (v3.14 and later)

jdbc:idb:<DB>
org.enhydra.instantdb.jdbc.idbDriver

Interbase (InterClient Driver)

jdbc:interbase://<HOST>/<DB>
interbase.interclient.Driver

Hypersonic SQL (v1.2 and earlier)

jdbc:HypersonicSQL:<DB>
hSql.hDriver

Hypersonic SQL (v1.3 and later)

jdbc:HypersonicSQL:<DB>
org.hsql.jdbcDriver

Microsoft SQL Server (JTurbo Driver)

jdbc:JTurbo://<HOST>:<PORT>/<DB>
com.ashna.jturbo.driver.Driver

Autor: Ing. Ángel Chata T. 115 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Microsoft SQL Server (Sprinta Driver)

jdbc:inetdae:<HOST>:<PORT>?database=<DB>
com.inet.tds.TdsDriver

Microsoft SQL Server 2000 (Microsoft Driver)

jdbc:microsoft:sqlserver://<HOST>:<PORT>[;DatabaseName=<DB>]
com.microsoft.jdbc.sqlserver.SQLServerDriver

MySQL (MM.MySQL Driver)

jdbc:mysql://<HOST>:<PORT>/<DB>
org.gjt.mm.mysql.Driver

Oracle OCI 8i
jdbc:oracle:oci8:@<SID>
oracle.jdbc.driver.OracleDriver

Oracle OCI 9i
jdbc:oracle:oci:@<SID>
oracle.jdbc.driver.OracleDriver

PostgreSQL (v6.5 and earlier)

jdbc:postgresql://<HOST>:<PORT>/<DB>
postgresql.Driver

PostgreSQL (v7.0 and later)

jdbc:postgresql://<HOST>:<PORT>/<DB>
org.postgresql.Driver

Sybase (jConnect 4.2 and earlier)

jdbc:sybase:Tds:<HOST>:<PORT>
com.sybase.jdbc.SybDriver

Sybase (jConnect 5.2)

jdbc:sybase:Tds:<HOST>:<PORT>
com.sybase.jdbc2.jdbc.SybDriver

9.6. Ejemplo de una consulta sencilla

Existen una serie de operaciones y procesos que son muy comunes contra una tabla en una base de
datos en disco, la más común es desplegar todos los registros de la tabla que están en la base de datos, a
este proceso le llamaremos SELECCION, consulta o despliegue.

Como se indicó anteriormente la comunicación con la base de datos se tendrán que dar usando el
lenguaje especializado de bases de datos llamado SQL (structured query language), la instrucción SQL
que se usa para resolver este problema tiene el siguiente formato:

SELECT [lista de campos, * o ALL] FROM TABLA;

El procedimiento que se intenta seguir cuando se construya un programa jsp que tenga que manipular
una tabla en disco deberá seguir los siguientes pasos:

 1.- Crear una conexión o enlace a la base de datos.

Autor: Ing. Ángel Chata T. 116 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

 2.- Abrir la conexión a la base de datos.

 3.- Crear el enlace y cargarlo con la instrucción SQL

 4.- Crear el RESULTSET y cargarlo

 5.- Cargar un objeto table de HTML con el RESULTSET

 6.- Procesar el table de HTML

 7.- Cerrar resultset, statement, driver o conexión

Autor: Ing. Ángel Chata T. 117 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 118 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Ventana de Acceso: jfrmAcceso

Diseño de la interfaz
jtxtUsuario,
jlblUsuario, basado en
basado en JTextField
JLabel

jpwdClave,
jlblClave, basado en
basado en JPasswordField
JLabel

jbtnAceptar, jbtnCancelar,
basado en basado en
JButton JButton

Personalización de Objetos

JFrame jfrmAcceso
title Acceso al sistema

JLabel jlblUsuario
text Usuario
displayedMnemonic U

JLabel jlblClave
text Clave
displayedMnemonic v

Autor: Ing. Ángel Chata T. 119 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

JTextField jtxtUsuario
text

JPasswordField jpwdClave
text

JButton jbtnAceptar
text Aceptar
mnemonic A
toolTipText Iniciar la validación

JButton jbtnCancelar
text Cancelar
mnemonic C
toolTipText Cerrar la Ventana

Plan de Eventos

Control Evento Actividades

jbtnCancelar actionPerformed Cerrar la ventana
- Verificar que se haya ingresado el Usuario
- Verificar que se haya ingresado la Clave
- Buscar la clave del usuario usando como dato el
usuario ingresado
- Si se encuentra el usuario
o Verificar que la clave ingresada corresponda con
jbtnAceptar actionPerformed la clave encontrada
o Si corresponde cargar la ventana jfrmPrincipal y
luego cerrar la ventana jfrmAcceso
o Si no corresponde la clave mostrar el mensaje
Clave Incorrecta
- Si no se encuentra el usuario en la tabla de usuario
mostrar el mensaje Usuario No autorizado

Codificación y Programación de Eventos

1. Importando librerías antes del inicio de la clase

import java.sql.*; // Para trabajar con Bases de datos

import javax.swing.*; // Para trabajar con controles de ventana

2. Declarando variables después del inicio de la clase

Connection oConexion=null;//objeto conexion

Statement oInstruccion=null;//objeto instruccion
Autor: Ing. Ángel Chata T. 120 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

ResultSet oTabla=null;//objeto resultset

//String strConexion= "jdbc:microsoft:sqlserver://l203pc13:1433;DataBaseName=Ventas";
String strBase_Datos = System.getProperty("user.dir") + "/Ventas.mdb";
String strConexion = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=" + strBase_Datos;

3. Realizando la conexión en el método Constructor de la clase

public jfrmAcceso() {
initComponents();//inicializar datos debajo de esta linea
try
{
//Registra la clase de conexion
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
oConexion = DriverManager.getConnection(strConexion,"sa","");
oInstruccion = oConexion.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_UPDATABLE);
}// Fin de try
// Captura de excepciones
catch (java.lang.ClassNotFoundException e){
// Si la clase a registrar no existe
JOptionPane.showMessageDialog(this, e.getMessage(),
"Clase no Ubicada", JOptionPane.ERROR_MESSAGE);
}
catch (SQLException e) {
// Si ha ocurrido algún error de conexión con la base de datos
JOptionPane.showMessageDialog(this, e.getMessage(),
"Falló la conexión", JOptionPane.ERROR_MESSAGE);
}; // Fin try-catch

} // Fin del constructor

4. Implementando los eventos de los botones jtnCancelar y jbtnAceptar.

Para implementar el evento clic en el botón jbtnCancelar de clic derecho en él y luego elija
Events, seguido de Actions y finalmente elija actionPerformed. Como se aprecia en la
figura:

Autor: Ing. Ángel Chata T. 121 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Luego se genera de manera automática el evento jbtnCancelarActionPerformed.

private void jBtnCancelarActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
this.setVisible(false);
}
La instrucción:

this.setVisible(false);

Hace invisible la ventana.

5. Para implementar el evento clic en el botón jbtnAceptar de clic derecho en él y luego

elija Events, seguido de Actions y finalmente elija actionPerformed. Como en el caso
del botón anterior.

private void jBtnAceptarActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:
String strUsuario=jTxtUsuario.getText(); // Capturando usuario
String strClave=jPwdClave.getText(); // Capturando clave
String strClave_BD; // Clave a capturar de la Base de datos
try
{
Autor: Ing. Ángel Chata T. 122 Revisado por: José Canchcucaja V.
“Fundamentos de Java” Julio 2008

String strSQL= "SELECT Clave FROM Usuarios WHERE Usuario='" +

strUsuario + "'";
oTabla = oInstruccion.executeQuery (strSQL);

// Validando dato del usuario ingresado

if (!oTabla.next()){
// El usuario no Existe en la tabla de usuarios
JOptionPane.showMessageDialog(this,
"no existe el usuario ingresado",
"Atencion",
JOptionPane.ERROR_MESSAGE); }
else{
// El usuario fue ubicado en la tabla de usuarios
strClave_BD=oTabla.getString(1);
if(strClave.equals(strClave_BD)){
// La clave ingresada le corresponde al usuario ingresado
jfrmPrincipal ofrm=new jfrmPrincipal();
ofrm.setVisible(true);
this.setVisible(false);
}
else{
// La clave ingresada no le corresponde al usuario ingresado
JOptionPane.showMessageDialog(this,
"Clave Incorrecta",
"Error",
JOptionPane.ERROR_MESSAGE); };
}// Fin de if-else
}// Fin de try
catch(SQLException e)
{JOptionPane.showMessageDialog(this,e.getMessage(),"Error de conexion",
JOptionPane.ERROR_MESSAGE);
}//fin try-catch
}

Autor: Ing. Ángel Chata T. 123 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Pasos para usar una base de datos Oracle Express (Gratuita)

http://www.oracle.com/technology/products/database/xe/index.html
Ir a la página inicial

Autenticarse al Oracle

Autor: Ing. Ángel Chata T. 124 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Ir a administración

Autor: Ing. Ángel Chata T. 125 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

En administración ir a Usuarios Base Datos

Crear nuevo usuario

Autor: Ing. Ángel Chata T. 126 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Deconectarse

Autor: Ing. Ángel Chata T. 127 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Volver a conectarse

Autor: Ing. Ángel Chata T. 128 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Crear una tabla del usuario Ventas:

- Dar clic al Explorador de Objetos

- Crear una nueva tabla

Autor: Ing. Ángel Chata T. 129 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Crear la Clave Principal de la tabla de usuarios (Primary Key):

Autor: Ing. Ángel Chata T. 130 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Crear claves ajenas (Foreing Key):

No vamos crear ninguna

Crear Restricciones (Constraints):

No vamos crear ninguna

Terminar

Autor: Ing. Ángel Chata T. 131 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Introducir datos

Autor: Ing. Ángel Chata T. 132 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Ingresa los datos

Creando otro usuario

Autor: Ing. Ángel Chata T. 133 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Finalizamos

Autor: Ing. Ángel Chata T. 134 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Descargando el conector Java de Oracle

Autor: Ing. Ángel Chata T. 135 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 136 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Descargar el Driver apropiado

Clic a Accept

Utilizando el Driver
- Crear una carpeta libs

Autor: Ing. Ángel Chata T. 137 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Autor: Ing. Ángel Chata T. 138 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Importar el controlador de Oracle al inicio del programa

import java.sql.*; // Para trabajar con Bases de datos

import javax.swing.*; // Para trabajar con controles de ventana
import oracle.jdbc.OracleDriver;

Definiendo la cadena de conexión

String strConexion = "jdbc:oracle:thin:@10.10.10.128:1522:XE";

Autor: Ing. Ángel Chata T. 139 Revisado por: José Canchcucaja V.

“Fundamentos de Java” Julio 2008

Registrando la clase para conectarse con el Oracle

Class.forName("oracle.jdbc.driver.OracleDriver");

Conectándose a la base de datos Oracle

//oConexion = DriverManager.getConnection(strConexion);
oConexion = DriverManager.getConnection(strConexion,
"Ventas", "123");

Código completo del botón Aceptar

new Pelicula();

Autor: Ing. Ángel Chata T. 140 Revisado por: José Canchcucaja V.