cursodejava.pdf

Curso de Java

por Michael Moossen

Version 1.0.14, 16 de marzo de 2003

Este documento es de dominio publico. Se puede imprimir y distribuir libre de gastos en su forma original, incluyendo la lista de losautores. Si se altera o se utilizan partes de este dentro de otro documento, la lista de autores debe incluir todos los autores originales y el autoro autores que hayan realizado los cambios.En caso de que este documento sea utlizado con fines comerciales, se aplicaran los terminos de la GNU General Public Licence.

Copyright c by Michael Moossen. 2002-03.

Manual del Departamento de Informaticade la Universidad Tecnica Federico Santa Mara

Valparaso, Chile

Departamento de Informatica. U.T.F.S.M. Michael Moossen

Indice general

Indice General

Prefacio Convenciones de Escritura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1. Introduccion a Java 11.1. Resena Historica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2. Caractersticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2.1. Portabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2.2. Lenguaje Interpretado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2.3. Orientacion a Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2.4. Integracion en la Red . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.5. Multitarea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.6. Robustez . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2.7. Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.3. Instalacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3.1. Distribuciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3.2. Ayuda en Lnea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.4. Primer Programa Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.4.1. Compilacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.4.2. Ejecucion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2. Principios de Programacion con Java 92.1. La Sintaxis del Lenguaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1.1. Palabras Clave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.1.2. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.1.3. Literales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.1.4. Separadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.1.5. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.2. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2.1. Declaracion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2.2. Ambito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.2.3. Control de Acceso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.2.4. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.3. Tipos de Dato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.3.1. Basicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.3.2. Conversion de Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3.3. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.4. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.4.1. Operadores Unarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

INDICE GENERAL

2.4.2. Operadores Aritmeticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.4.3. Operadores de Rotacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.4.4. Operadores de Comparacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.4.5. Operadores Logicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.4.6. Operador Ternario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.4.7. Operadores de Asignacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.4.8. Precedencia de Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.4.9. Operaciones con Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.5. Control de Flujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.5.1. La Sentencia if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.5.2. La Sentencia switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.6. Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.6.1. La Sentencia while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.6.2. La Sentencia for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.6.3. Control de Flujo en Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

2.7. Manejo de Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282.7.1. try...catch...finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.7.2. La Clase Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.7.3. Capturar Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.7.4. Lanzar Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.7.5. Declaracion de Excepciones en Metodos . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.8. Recursividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312.8.1. Numeros de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.9. La Clase Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3. Programacion Orientada a Objetos 353.1. Taxonoma de Lenguajes Orientados a Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.2. Ventajas de la Tecnologa Orientada a Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.3. Desventajas de la Tecnologa Orientada a Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . 363.4. Caractersticas de la Tecnologa Orientada a Objetos . . . . . . . . . . . . . . . . . . . . . . . . 36

3.4.1. Abstraccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363.4.2. Modularidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.4.3. Encapsulamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.4.4. Jerarqua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373.4.5. Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393.4.6. Caractersticas Adicionales de los Lenguajes Orientados a Objetos . . . . . . . . . . . . . 40

3.5. Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403.5.1. Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413.5.2. Metodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413.5.3. Constructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433.5.4. Destructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.6. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.6.1. Operador new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.6.2. Objeto this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453.6.3. Objeto super . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.7. Modificadores de Atributos y Metodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483.7.1. El Modificador static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483.7.2. El Modificador final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.7.3. El Modificador abstract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.7.4. El Modificador transient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513.7.5. El Modificador volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

3.8. Clases Internas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51


INDICE GENERAL

3.8.1. Clases Internas Estaticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523.8.2. Clases Internas Miembro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.8.3. Clases Internas Locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553.8.4. Clases Anonimas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

3.9. Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.9.1. Declaracion de una Interfaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573.9.2. Uso de una Interfaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3.10. Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593.10.1. Uso de Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593.10.2. Nombre de Paquetes y Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593.10.3. Uso de Otros Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603.10.4. Estructura Jerarquica de Directorios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603.10.5. Ejecucion de las Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

4. Programacion con la API Estandar 634.1. Manejo de Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

4.1.1. La Clase String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634.1.2. La Clase StringBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644.1.3. La Clase StringTokenizer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4.2. Utilidades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654.2.1. Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654.2.2. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654.2.3. La Clase Hashtable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664.2.4. La Clase System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

4.3. Funciones Matematicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.3.1. La Clase Abstracta Number . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.3.2. La Clase Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.3.3. El paquete java.math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

4.4. Manejo de Fechas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.4.1. La Clase Date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.4.2. La Clase GregorianCalendar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714.4.3. La Clase SimpleDateFormat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724.4.4. La Clase SimpleTimeZone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

4.5. Entrada y Salida de Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744.5.1. Archivos y Directorios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744.5.2. Lectura y Escritura en Archivos de Texto . . . . . . . . . . . . . . . . . . . . . . . . . . 764.5.3. Lectura y Escritura en Archivos Binarios . . . . . . . . . . . . . . . . . . . . . . . . . . 774.5.4. Archivos de Acceso Aleatorio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784.5.5. Serializacion de Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

4.6. Conectividad a Base de Datos (JDBC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804.6.1. Introduccion a los Drivers JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804.6.2. Registrar un Driver JDBC: La Clase DriverManager . . . . . . . . . . . . . . . . . . . 814.6.3. La Conexion: La Clase Connection y URLs de Conexion . . . . . . . . . . . . . . . . . 824.6.4. Ejecutar una Instruccion SQL: La Clase Statement . . . . . . . . . . . . . . . . . . . . 834.6.5. Obtencion de Resultados: La Interfaz ResultSet . . . . . . . . . . . . . . . . . . . . . . 834.6.6. Manejo de Transacciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

4.7. Hilos y Sincronizacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874.7.1. Creacion de Hilos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874.7.2. Ciclo de Vida de un Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.7.3. Sincronizacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 914.7.4. Prioridades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934.7.5. Grupos de Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Michael Moossen Departamento de Informatica. U.T.F.S.M.

INDICE GENERAL

5. Java e Internet 955.1. Trabajo en Red . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

5.1.1. Conceptos Basicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955.1.2. URL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965.1.3. Sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025.1.4. Datagramas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

5.2. HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1115.2.1. Primera Pagina . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1115.2.2. Formateo Basico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1135.2.3. Caracteres Especiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1155.2.4. Enlaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1155.2.5. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165.2.6. Imagenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175.2.7. Formateo Fino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1185.2.8. Estructura del Documento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195.2.9. Formularios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215.2.10. Tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1245.2.11. Marcos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

5.3. Java Server Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1295.3.1. Plantilla de Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1295.3.2. Elementos de Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1295.3.3. Directivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1315.3.4. Variables Predefinidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1335.3.5. Accciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1345.3.6. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

5.4. Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1355.4.1. El Tag APPLET de HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1365.4.2. Ciclo de Vida de un Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1375.4.3. Metodos para Dibujar un Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1375.4.4. Comunicacion entre Applet y Browser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1395.4.5. Sonidos en Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1405.4.6. Imagenes en Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1405.4.7. Threads en Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1415.4.8. Applets como Aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1425.4.9. Restricciones de Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

5.5. Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1445.5.1. Controlador de Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1445.5.2. Un Controlador de Seguridad Propio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1455.5.3. Instalar un Controlador de Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1475.5.4. Decidir que Metodos Sobreescribir del SecurityManager . . . . . . . . . . . . . . . . . . 148

6. Interfaces Graficas 1516.1. Contexto Historico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1526.2. Introduccion a Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

6.2.1. Contenedores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1536.2.2. Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

6.3. Manejo de Eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1586.4. Diseno de Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

6.4.1. Administracion de Disposicion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1596.4.2. Posicionamiento Absoluto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1626.4.3. Relleno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1626.4.4. Bordes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163


INDICE GENERAL

6.4.5. Look & Feel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1646.5. Contenedores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

6.5.1. Ventanas de Dialogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1656.5.2. Contenedores Generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

6.6. Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1716.6.1. Etiquetas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1716.6.2. Botones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1726.6.3. Listas Desplegables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1736.6.4. Cajas de Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1736.6.5. Campos de Password . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1736.6.6. Areas de Texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1746.6.7. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1746.6.8. Tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

6.7. Lo que falto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

7. Java 2 Enterprise Edition 1797.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

7.1.1. Enterprise Java Bean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1797.1.2. Contenedor EJB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1797.1.3. Arquitectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1807.1.4. Distribucion de Carga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1817.1.5. Descriptores de Instalacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

7.2. Enterprise Java Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1817.2.1. Session Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1827.2.2. Entity Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1827.2.3. Message Driven Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

7.3. Transacciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1827.3.1. Manejo Programado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1837.3.2. Manejo Declarado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

A. Utilitarios de Java 185A.1. Generador de Documentacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185A.2. Java ARchive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186A.3. Applet Viewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186A.4. Java Debugger (jdb) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187A.5. Java IDEs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

B. Propiedades del Sistema 189

Bibliografa 191

Indice alfabetico 193

Michael Moossen Departamento de Informatica. U.T.F.S.M.

Prefacio

Este manual tiene la intencion de ser una herramienta de apoyo al aprendizaje del lenguaje de programacionJava, para personas con conocimientos previos mnimos de programacion, entregando por una parte una sobrevistageneral del lenguaje mismo y sus principales areas y aplicaciones, como tambien todos los conceptos para que elalumno pueda desarrollarse mas alla de este manual por s mismo.

Este curso se divide en seis captulos:

El captulo 1 introduce el lenguaje de programacion Java exponiendo sus virtudes y desventajas. Ademas, se venaspectos practicos de los pasos de configuracion de una plataforma de programacion totalmente operable yel primer ejemplo de codigo.

El captulo 2 incide en los detalles basicos sobre la programacion en Java. Dando a conocer las herramientasbasicas con las que cuenta el programador y mostrando de a poco los conceptos de orientacion a objetosbasicos.

El captulo 3 entra de lleno en materia de programacion orientada a objetos, en sus orgenes y su evolucion, y detodos los aspectos practicos presentes en Java.

El captulo 4 presenta algunos temas de programacion mas especficos, como son algunas libreras estandares deJava, conectividad a bases de datos va JDBC, manipulacion avanzada de Strings y manejo de archivos.

El captulo 5 entra en el mundo web pasando de HTML basico, haca paginas JSP, servlets y applets. Ademas seven temas de seguridad y manejo de Sockets.

El captulo 6 introduce la programacion de interfaces de usuario graficas, va AWT y Swing(JFC).

El apendice A introduce algunas herramientas incluidas en la distribucion de Java y que pueden ser de granutilidad para el programador.

El apendice B presenta las propiedades del sistema que son accesibles por defecto.

Es importante leer los captulos en secuencia. Se recomienda, leer cuidadosamente los ejemplos, ya que en ellosencontrara gran parte de la informacion, entregada en este manual.

Si tiene ideas sobre algo que debera ser anadido o alterado en este documento, por favor hagalo saber.

Michael Moossen Estudiante de Magister, Departamento de Informatica, Universidad Tecnica Federico Santa Mara

La version vigente de este documento estara disponible en:http://www.labmc.inf.utfsm.cl/mmoossen

Convenciones de Escritura

Durante este curso se usaran las siguientes convenciones de escritura para el codigo Java:

Codigo FuenteEl codigo fuente, en general, sera escrito con letra monoespaciada, como en el siguiente ejemplo:

System.out.println("Ejemplo:");

for(int i=0; i

01 System.out.println("Ejemplo:");

02 for (int i=0; i

Captulo 1

Introduccion a Java

1.1. Resena Historica

El desarrollo del lenguaje Java se inicio en 1991, contemporaneamente a la creacion en Suiza de la WorldWide Web. En esa epoca, un equipo de Sun MicroSystems, en el que participaba James Gosling, trabajaba en elproyecto de crear productos electronicos de consumo que fueran sencillos y fiables. Para ello, se necesitaba unaforma de crear codigo, que fuera independiente de la plataforma y que permitiera ejecutar el software en cualquierCPU.Como punto de partida, para un lenguaje informatico que implementara esta independencia de la plataforma, elequipo de Sun se fijo en un primer momento en C++. Pronto abandonaron la idea y no consiguieron encontrarningun lenguaje que se adaptara a sus necesidades.Decidieron entonces desarrollar un lenguaje nuevo llamado Oak (el nombre fue tomado de un enorme roble quehaba frente al despacho de Mike Sheridan, coordinador y fundador del equipo de trabajo), mas tarde y al existirya un lenguaje llamado Oak, se rebautizo el lenguaje con el nombre de Java (Java, en el argot norteamericanosignifica cafe. El equipo de trabajo de Sheridan se reuna en una cafetera cercana a las instalaciones de Sun,donde discutan acaloradamente del proyecto. De aqu tomo su nombre Java). Hacia el otono de 1992, el equipohaba puesto en marcha un proyecto llamado Star 7 (*7), consistente en un control remoto personal y manual;para este proyecto el equipo se constituyo en una sociedad filial de Sun llamada la First Person, Inc. First Personperdio un concurso convocado por la Time Warner para desarrollar una television set-top box, First Person sedisolvio y a Sun MicroSystems unicamente le quedo el lenguaje Java.A mediados de 1994, la popularidad de la Web atrajo la atencion de los directivos de Sun e intuyendo las enormesposibilidades de este nuevo medio de comunicacion, decidieron programar un navegador, empleando la tecnologaJava.Aquel primer programa, que se llamoWebRunner, quedo listo enMayo de 1995 y viendo las enormes posibilidadesdecidieron mejorar el navegador. El 23 de Mayo de 1995 en la Sun World 95 de San Francisco, Sun presenta sunuevo navegador HotJava y Netscape anuncia su intencion de integrar Java en su navegador.A partir de aquel verano, los acontecimientos se desarrollan vertiginosamente para el mundo Java, sobre tododespues del lanzamiento y distribucion libre del Java Development Kit (JDK) 1.0. A finales de 1995 (solo seismeses despues del lanzamiento de JDK!!) Java haba firmado acuerdos con las principales firmas del software, paraque pudieran utilizar Java en sus productos, entre otras Netscape, Borland, Mitsubishi Electronics, DimensionX, Adobe, IBM, Lotus, Macromedia, Oracle, SpyGlass... pero lo mas espectacular fue el anuncio por parte deBill Gates, presidente y director ejecutivo de Microsoft, el 7 de Diciembre de 1995, de la voluntad por parte deMicrosoft, de obtener la licencia de utilizacion de Java.Aquel anuncio vena a mostrar claramente que Microsoft consideraba a Java como una parte importante en laestratega global de Internet. Este anuncio es significativo, si se considera el desprecio que meses antes Bill Gateshaba mostrado hacia Java, calificandolo como un lenguaje mas. El propio director general de Microsoft enEspana, haba calificado a Java como un lenguaje para tostadoras.

1

1.2. CARACTERISTICAS

Durante 1996 se planteo el debate de crear un terminal tonto o netPc, que unicamente sirviera para conectarsea la World Wide Web. En un principio se proyecto que este terminal estara gobernado por un sistema operativoJava. La idea del netPc no cuajo como se esperaba, pero la idea de producir un sistema operativo Java, si que se hadesarrollado, se llama JavaOS. S algun da podra competir con los sistemas operativos de moda como Windows9x y Linux, solo el tiempo lo dira. Tambien se sabe (aunque Sun no lo reconoce abiertamente) del proyectode construir un chip Java que incorporara todo el codigo de la Maquina Virtual Java en el propio hardware.Esto sin duda, acelerara enormemente los tiempos de proceso de cualquier programa Java y lo equiparara a lasvelocidades de lenguajes que compiten directamente con Java, por ejemplo C++. El desarrollo de una tecnologade componentes (JavaBeans) al estilo OLE y ActiveX, facilmente implementables en codigo, la incorporacionvertiginosa por parte de Sun de nuevas APIs (Java2D, APIS de telefona, JDBC, etc..) mas la renovacion continuadel compilador gratuito JDK (actualmente la version mas reciente de JDK es la 1.4) hacen de Java una tecnologaprometedora que sin duda tiene un papel importante en la actualidad y lo tendra cada vez mas en el futuro.

1.2. Caractersticas

1.2.1. Portabilidad

Efectivamente, Java esta preparado para practicamente la totalidad de las plataformas y sistemas operativosexistentes hoy en da.El proceso de diseno y programacion del codigo de un programa Java, no es distinto del de cualquier programa enotro lenguaje. Se usa un editor de texto para escribir las sentencias y el archivo de codigo fuente obtenido se guar-da en un archivo con extension .java. La novedad que introduce Java, viene dada en el proceso de compilacion.En este proceso, el compilador traduce el codigo fuente a un formato especial llamado bytecode. Este bytecodees grabado en un archivo con extension .class y no es directamente interpretable por el computador, sino porcualquier computador que tenga instalada una Maquina Virtual Java.Aqu radica la novedad que introduce Java y aunque es una idea sencilla, a la vez es potente, y es lo que ha hechoque Java sea lo mejor que le ha pasado a la informatica desde la aparicion del PC.No importa el procesador ni el sistema operativo, la unica condicion para que un programa Java pueda correr enun computador, es que tenga instalada la Maquina Virtual. Mas lejos aun, ni siquiera es necesario que sea un com-putador. Cualquier aparato que implemente la Maquina Virtual Java o partes de ella, estara preparado para ejecutarprogramas Java; podra ser el sistema de menus de un video, el control de un edificio inteligente o simplementeuna cafetera.Ya han habido otros lenguajes interpretados, como por ejemplo Visual Basic. Sin embargo, nunca se haba em-pleado como punto de partida a un lenguaje multiplataforma, ni se haba hecho de manera tan eficiente. CuandoJava aparecio en el mercado, se hablaba de que era entre 10 y 30 veces mas lento que C++. Ahora, con los com-piladores JIT (Just in Time) se habla de tiempos casi comparables. Con la potencia de las maquinas actuales, esalentitud es un precio que se puede pagar sin problemas, contemplando las ventajas de un lenguaje portable.

1.2.2. Lenguaje Interpretado

Java no es exactamente un lenguaje interpretado del todo, se podra definir como un hbrido compilado-interpretado. Otros lenguajes interpretados, como por ejemplo el Perl , no necesitan de un proceso de compi-lacion para estar preparados para correr. El caso mas simple de un lenguaje interpretado, seran los archivos batch,simplemente se escriben las ordenes en un archivo y el computador las ejecuta. Si se ha cometido un error, porejemplo escribiendo incorrectamente alguna orden, no se sabra hasta que el computador intente ejecutar esa ordenconcreta. Entonces avisara con el correspondiente mensaje de error.Los archivos de codigo fuente Java, a diferencia de los de Perl o los archivos batch, no estan preparados paracorrer en el computador, necesitan de un proceso de compilacion previa. Entonces...Por que se dice que Javaes un lenguaje interpretado?. El archivo .class (bytecode) que se obtiene de la compilacion previa del codigofuente necesita de una Maquina Virtual que interprete el bytecode y lo ejecute en el computador. As como losarchivos batch, necesitan del interprete de comandos (command.com o sh) para ejecutarse, Java necesita de la

2 Departamento de Informatica. U.T.F.S.M. Michael Moossen

CAPITULO 1. INTRODUCCION A JAVA

interpretacion de la Maquina Virtual.

1.2.3. Orientacion a Objetos

Dado que Java es un lenguaje orientado a objetos, es imprescindible entender que es esto y en que afectaa los programas. Desde el principio, la carrera por crear lenguajes de programacion, ha sido una carrera paraintentar realizar abstracciones sobre la maquina. Al principio, no eran grandes abstracciones y el concepto delenguajes imperativos es prueba de ello. Exigen pensar en terminos del computador y no en terminos del problemaa solucionar. Esto provoca que los programas sean difciles de escribir y mantener, al no tener una relacion obviacon el problema que representan, no abstraen lo suficiente.Muchos paradigmas de programacion, intentaron resolver este problema alterando la vision del mundo y adaptan-dola al lenguaje. Estas aproximaciones, modelaban el mundo como un conjunto de objetos o de listas. Funcionabanbien para algunos problemas pero no para otros. Los lenguajes orientados a objetos, mas generales, permitenrealizar soluciones que, ledas, describen el problema. Permiten escribir soluciones pensando en el problema y noen el computador que debe solucionarlo en ultimo extremo. Se basan en cinco caractersticas:

Todo es un objeto , es decir, cada elemento del problema debe ser modelizado como un objeto.

Un programa es un conjunto de objetos diciendose entre s que deben hacer, por medio de mensajes , es de-cir, cuando se necesita que un objeto realice una accion, se le manda un mensaje. Mas concretamente, seejecuta un metodo de dicho objeto.

Cada objeto tiene su propia memoria, que llena con otros objetos , es decir, cada objeto puede contener otrosobjetos. De este modo se puede incrementar la complejidad del problema, pero detras de dicha complejidadsiguen habiendo simples objetos.

Todo objeto tiene un tipo , es decir, en jerga POO, cada objeto es una instancia (un caso particular) de una clase(el tipo general). Lo que distingue a una clase de otra, es la respuesta a la pregunta, que mensajes puederecibir?.

Todos los objetos de un determinado tipo pueden recibir los mismos mensajes . Por ejemplo, dado que un ob-jeto de tipo Gato es tambien un objeto de tipo Animal, se puede hacer codigo pensando en los mensajesque se mandan a un animal y aplicarlo a todos los objetos de ese tipo, sin pensar si son tambien gatos o no.

Eso de que la programacion orientada a objetos intente establecer una relacion biunvoca entre el espacio del pro-blema y el de la solucion esta bien pero... como se logra que un objeto realice cosas utiles y necesarias? Por mediode su interfaz, que esta definida en la clase del objeto. Por ejemplo, suponga que se tiene la clase Interruptorcuya interfaz define los metodos apagar() y encender(). Entonces se hace lo siguiente:

Interruptor i = new Interruptor();

i.encender();

Primero se crea una referencia llamada i de tipo Interruptor, y luego se crea un objeto, una instancia de dichotipo, por medio de la palabra reservada new . Se asigna ese objeto a la referencia por medio del signo =. Porultimo, se enva un mensaje al objeto recien creado y asignado, poniendo el nombre de la referencia, un punto, yel nombre del mensaje (metodo).Algunos lenguajes modernos y de exito, como Visual Basic y Delphi, presumen de estar orientados a objetos yesto no es cierto, la verdad es que solo estan parcialmente orientados a POO y no aprovechan toda la potencia deesta filosofa de programacion.C++ es el lenguaje que impulso y popularizo la filosofa POO y sin duda es un lenguaje completamente orientadoal objeto. Sin embargo, C++ incorpora algunas caractersticas no estandares (muchos autores discuten que formenparte de POO) como la herencia multiple. Ademas, nada impide desarrollar un programa en C++ no orientado aobjetos. En Java, esto no es posible, puesto que en Java todo son objetos. Incluso para desarrollar el mas simpleprograma, se necesita construir por lo menos un objeto. Esto da una idea del grado de relacion entre Java y POO,filosofa de programacion de la que aprovecha todas sus ventajas.

Michael Moossen Departamento de Informatica. U.T.F.S.M. 3

1.3. INSTALACION

1.2.4. Integracion en la Red

El bytecode tiene la caracterstica de ocupar muy poco espacio. Para tener una idea, el ejemplo final delcaptulo(ver seccion 1.4), ocupa en disco solo 420 bytes. Esta virtud lo hace ideal para integrarse en la red Internety desde un principio Sun penso en la Worl Wide Web.En efecto, se pueden integrar pequenos programas Java (applets) en paginas web y as se tiene la posibilidad dedistribuir facilmente un contenido ejecutable. Este contenido, da la posibilidad al usuario que visita una pagina,de interactuar con esta y convertirla en algo mas que un simple texto plano.Por otro lado, Java cuenta con una amplia biblioteca de clases para comunicarse, empleando protocolos de InternetTCP/IP e incluyendo otros protocolos tales como HTTP y FTP. El codigo Java, puede manipular recursos via URLcon la misma facilidad a la que se esta acostumbrado para acceder a un sistema de archivos local empleando Pascal,C o Basic.

1.2.5. Multitarea

Java permite desarrollar programas de forma que corran varios procesos al mismo tiempo en un mismo com-putador. Mientras esta corriendo un proceso, se puede ordenar que comience a ejecutarse otro de una forma muysencilla. Esta es una gran ventaja que es bien aprovechada por los grandes servidores web y servidores de aplica-ciones basados en Java, al explotar sin mayor esfuerzo las potencialidades del hardware de los servidores.

1.2.6. Robustez

Un software robusto, es el que no se interrumpe facilmente a consecuencia de fallos a la hora de programaro eventuales errores logicos en la programacion. Un lenguaje de programacion que favorezca esta robustez delsoftware, suele poner mas restricciones al programador a la hora de escribir el codigo fuente. Tales restriccionesincluyen las relativas a la escritura de datos y al empleo de punteros.El lenguaje de programacion C, es poco riguroso a la hora de comprobar compatibilidades de escritura de datosdurante la compilacion y el tiempo de ejecucion. El lenguaje C++ es un poco mas rgido en este aspecto, peroretiene algunos errores respecto a la escritura de datos. Y para que mencionar los problemas de C y C++ conpunteros.En Java, al contrario la escritura de datos es mas rigurosa. Java no permite el uso de punteros y por lo tanto esimposible la escritura de datos de forma accidental, lo que puede traer consecuencias catastroficas. Java tambienhace un chequeo de los lmites de un arreglo antes de escribir en el, por lo que tambien es imposible escribir fuerade los lmites de un arreglo. En definitiva, es imposible escribir en sitios indeseados de la memoria, cosa que unprogramador en C o C++ puede hacer accidental o deliberadamente.

1.2.7. Seguridad

La posibilidad de distribuir un contenido ejecutable en la red, podra significar una autentica fiesta para loshackers. Imagine por un momento, un applet en una pagina HTML que al ser descargado, formatee su disco duroo lea datos de su computador. Afortunadamente, los creadores de Java se preocuparon bastante de este detalle ycrearon un modelo bastante seguro que hacen imposible que un applet pueda hacer algo danino, por el hecho dedescargarlo de un servidor web.

1.3. Instalacion

Las siguientes instrucciones ayudaran paso a paso, en la instalacion de la plataforma de trabajo Java. Estasinstrucciones son para usuarios de plataformas Win32, que incluye Windows 9x, Windows Me, Windows NT,Windows 2k y Windows XP.En realidad, solo se necesitan dos cosas:



1. Primero, la Edicion Estandard de la Plataforma Java 2 (J2SE) que puede ser bajada desde http://java.sun.com/j2se/1.4/download.html. Instalar el J2SE es bastante facil y ante cualquier duda, sepueden consultar las instrucciones de instalacion del proveedor, en http://java.sun.com/j2se/1.4/install-windows.html

2. Luego, se necesita un editor de texto para editar los archivos fuentes, para lo cual basta el Notepad deWindows. Pero se recomienda usar Editplus, que provee entre otras caractersticas, autocompletacion deinstrucciones, resaltado de sintaxis e integracion con el compilador y la JVM. Editplus se puede obtener dehttp://www.editplus.com.

Es aconsejable, crear un directorio para almacenar todos los programas que se escriban. Por ejemplo,

C:/codebase

Si se desea realizar una instalacion en una plataforma Unix, los pasos a seguir son practicamente los mismos. Lamayor traba que ofrece este ambiente de desarrollo, es el editor de texto. En la mayora de los casos habra queconformarse con el vi.

1.3.1. Distribuciones

Java esta disponible en varias distribuciones, a saber:

J2SE : Edicion estandar que contiene todo lo necesario para empezar a programar aplicaciones profesionales.

J2EE : Incluye el J2SE y ademas agrega un sin numero de nuevas funcionalidades enfocadas al desarrollo degrandes aplicaciones empresariales.

J2ME : Edicion reducida(Micro Edition), que permite el desarrollo de aplicaciones incrustadas, es decir, muyespecficas sobre chips de escasos recursos. Por ejemplo, un controlador de lavadoras.

Ademas existe un sin numero de paquetes opcionales, tanto de SUN como de otros proveedores, que permitenampliar las funcionalidades de Java. Por ejemplo,

Java3D : Paquete de SUN que permite la programacion de aplicaciones con graficas 3D, es parte de un con-junto de paquetes adicionales agrupados bajo el nombre de Java Media, que incluye desde libreras pa-ra manipulacion de imagenes, hasta herramientas de reconocimiento de voz. Para mas informacion, verhttp://java.sun.com/products/java-media/.

JAXP : Java API for XML Processing, paquete de SUN que permite la manipulacion de archivos XML.

JavaMail : Paquete de SUN que permite la manipulacion de correos electronicos.

Entre muchos otros.

1.3.2. Ayuda en Lnea

SUN ofrece un sin numero de documentos de ayuda, manuales de referencia, tutoriales y libros online, tododisponible en http://java.sun.com/docs.Para encontrar documentacion en espanol, ver la bibliografa de este curso [1].

1.4. Primer Programa Java

Ahora, se vera un primer ejemplo totalmente ejecutable, con el cual se revisaran los pasos necesarios paracompilar y ejecutar un programa Java, como tambien los errores tpicos que se podran presentar.El codigo es el siguiente:


1.4. PRIMER PROGRAMA JAVA

public class HelloWorldApp {public static void main(String[] args) {

System.out.println("Hello World!");

}}

Este codigo debe ser guardado en un archivo con el mismo nombre que la clase que define y con la extension.java, en este caso, HelloWorldApp.java. Mas especficamente, c:/codebase/HelloWorldApp.java.Hay que ser cuidadoso con el nombre de las clases y archivos, y en general, cualquier identificador, ya que Javadiferencia entre mayusculas y minusculas.Ahora se analizara con detalle el codigo presentado. La primera lnea define una estructura importantsima en ellenguaje Java, la estructura class . No es el momento de estudiarla en profundidad. Basta con saber por ahora,que una estructura class define una clase y que todo el codigo encerrado entre un par de llaves ({ }) inmediata-mente despues de la definicion de esta estructura, pertenece a ella.No es el caso de este ejemplo, pero un archivo puede tener mas de una estructura class .Si se ha programado anteriormente en cualquier lenguaje, se vera enseguida que la segunda lnea define un meto-do. En este caso, tiene un parametro y no retorna valor alguno. Mas adelante se profundizara en los metodos deJava.La finalidad de la tercera lnea es simplemente escribir una lnea de texto seguida por un retorno de carro en lapantalla.Luego, se indica el termino del metodo y luego el termino de la clase.El metodo main() es especialmente importante. Toda aplicacion Java debe incluir en su codigo este metodo,puesto que es el punto de entrada de la aplicacion. La primera sentencia del programa que se ejecuta, es la primerasentencia que este dentro de este metodo. El metodo main() debe estar definido exactamente como se indica, lounico que se puede variar en la definicion de este metodo, es el nombre que se le da al parametro de este metodo.En un archivo o unidad de compilacion, la clase (o estructura class ) que contiene al metodo main(), se de-nomina clase principal y tiene que cumplir dos normas. La primera, es que debe definirse como public (masadelante se vera que significa esto) y la segunda, que debe llamarse exactamente igual que el archivo en donde seencuentra definida.

1.4.1. Compilacion

Ahora es necesario compilar este archivo fuente para obtener un ejecutable, llamado en este casoHelloWorldApp.class. Para lograrlo es necesario ejecutar el comando:

javac -classpath c:/codebase; %CLASSPATH % HelloWorldApp.java

Lo que hace esta lnea es, decirle al compilador que compile el archivo HelloWorldApp.java, y que para ellobusque cualquier referencia que pueda hacer este archivo a otra clase, en el directorio c:/codebase, ademas debuscar donde normalmente lo hara.Otra manera, es setear la variable de entorno CLASSPATH, de tal forma que tambien incluya este directorio. Conesto, bastara ejecutar:

javac HelloWorldApp.java

El compilador busca las referencias donde se le indica y si encuentra alguna que no este compilada o este desac-tualizada, la compila tambien.El error mas tpico durante la compilacion es cuando se recibe el mensaje:

Bad command or file name

Que significa que Windows no puede encontrar el compilador Java, javac. Puede ser, que esto se deba a que nose ha instalado el J2SE adecuadamente o que solo falta incluir el directorio %java home %/bin a la variable deentorno PATH, siendo %java home % el directorio de instalacion del J2SE.



1.4.2. Ejecucion

Una vez creado el archivo ejecutable, se puede ejecutar usando el comando:

java -cp c:/codebase; %CLASSPATH % HelloWorldApp

En donde, la opcion -cp tiene la misma interpretacion que la opcion -classpath al compilar. Y tambien puedeser omitida, una vez que este bien seteada la variable de entorno.El error mas tpico al momento de la ejecucion de un programa Java es, cuando se recibe el mensaje:

Exception in thread "main"java.lang.NoClassDefFoundError: HelloWorldApp

Que significa que, Java no puede encontrar el archivo de bytecodes, HelloWorldApp.class. Lo que se puededeber a dos cosas: Primero, que se halla producido algun error al compilar (o no se halla compilado), o segundo,que la variable CLASSPATH esta mal seteada.


1.4. PRIMER PROGRAMA JAVA


Captulo 2

Principios de Programacion con Java

2.1. La Sintaxis del Lenguaje

La sintaxis de Java, como la de (casi) cualquier otro lenguaje de programacion, esta dada por distintos elemen-tos contructivos basicos:

Palabras Clave

Identificadores

Literales

Separadores

Comentarios

A continuacion se detallara rapidamente cada uno.

2.1.1. Palabras Clave

Las palabras clave son palabras reservadas por el lenguaje Java, para un proposito definido y especfico. Estasno se pueden usar como identificadores . Y son:

abstract catch default false goto

int null return switch true

boolean char do final if

interface package short this try

break class double finally implements

long private static throw void

byte const else float import

native protected super throws volatile

case continue extends for instanceof

new public synchronized transient while

Ademas, el lenguaje se reserva unas cuantas palabras mas, que hasta ahora no tienen una funcion especfica.Estas son:

cast const future generic goto

inner operator outer rest var

9

2.1. LA SINTAXIS DEL LENGUAJE

La Palabra Clave null

Este identificador es la referencia nula. Es decir, cuando se tiene una referencia a un objeto, y aun no se lequiere asignar uno, pero se desea utilizar esa variable, entonces se le asigna null :

public class Nulo {public static void main(String[] args) {

String cad = null ;

if (cad == null )

System.out.println("Es nulo");

}}

Como Java es un lenguaje seguro, si no se inicializa la referencia cad y se intenta acceder a ella, dara un error decompilacion. Esto tiene una excepcion: cuando se crea un arreglo, todos sus elementos se inicializaran automati-camente en null . Esto se debe a que en tiempo de compilacion, Java no tiene manera de saber que elementosestan inicializados y cuales no, por lo que no puede dar un error.

2.1.2. Identificadores

Un identificador es un nombre que se da a un elemento, es decir, una clase, un metodo, una propiedad, etc.Java distingue entre mayusculas y minusculas, y los identificadores pueden comenzar por una letra, un subrayadoo un smbolo de peso, siendo los siguientes caracteres letras o dgitos, y pueden ser de hasta mas de 500 caracteresde largo. Por ejemplo, son identificadores validos:

contador

nombre usuario

$dinero

Se recomienda no usar identificadores que comiencen con el signo peso o por el signo de subrayado.

2.1.3. Literales

Los literales son un mecanismo utilizado para expresar un valor constante (en tiempo de compilacion). Javautiliza cinco tipos de elementos literales: enteros, reales en coma flotante, booleanos, caracteres y cadenas:

Tipo EjemploEnteros 21, 0xDCReales 3.14, 2e12

Booleanos true , falseCaracteres x, \t, \u0234Cadenas "Esto es una cadena"

Notar que, mientras los caracteres se expresan encerrados en comillas simples (), las cadenas lo hacen en comillasdobles (").

2.1.4. Separadores

Existen otros elementos con significado especial en Java. Estos son los separadores, que en general, delimitancierta region del codigo, dandole un cierto significado especfico, segun la siguienta tabla:


CAPITULO 2. PRINCIPIOS DE PROGRAMACION CON JAVA

Separador Descripcion( ) Contienen listas de parametros, tanto en la definicion de un metodo, como en la llamada al mismo.

Tambien se utilizan para modificar la precedencia en una expresion (Seccion 2.4.8), contenerexpresiones para control de flujo (Seccion 2.5.1) y realizar conversiones de tipo (Seccion 2.3.2).

{ } Se utilizan para definir bloques de codigo, definir ambitos (Seccion 2.2.2) y contener los valoresiniciales de arreglos (Seccion 2.2.4).

[ ] Se utilizan tanto para declarar arreglos o matrices, como para referenciar valores dentro de losmismos (Seccion 2.2.4).

; Separador de sentencias., Separador de identificadores consecutivos en la declaracion de variables y en las listas de parame-

tros. Tambien se utiliza para encadenar sentencias dentro de una estructura for (Seccion 2.6.2).. Separa un nombre de propiedad o metodo de una variable de referencia (Seccion 2.3.3). Tambien

separa nombre de paquete de los de un subpaquete o una clase. (Seccion 3.10)

2.1.5. Comentarios

Los comentarios en Java son como los de C++ pero con ciertas funcionalidades especiales, para mas detallede esto ver seccion A.1. Los comentarios basicos son:

Comentarios de Fin de Lnea

Este tipo de comentario es introducido por // y dura hasta final de lnea:

// Esto es un comentario

Comentarios de Parrafo

Los comentarios de parrafo o bloque, pueden ocupar mas de una lnea, comenzando con /* y terminandocon */:

/* Esto es un

comentario */

2.2. Variables

2.2.1. Declaracion

Declarar una variable es darla a conocer al compilador y as tenerla lista para su posterior uso.Declarar una variable en Java es muy sencillo. En primer lugar se indica el tipo de dato al que se quiere quepertenezca esa variable y en segundo lugar su nombre. Algunos ejemplos de declaraciones:

int variable;

short variable short;

long largo;

Se puede inicializar la variable a un determinado valor, en el mismo momento en que se declara. Esto es reco-mendable y se sugiere como regla de oro, siempre inicializar las variables, ya sea con un valor util, o cero o nullpara luego asignarle un valor util en tiempo de ejecucion. Para inicializar una variable se hace uso del operador= seguido del valor que se quiere asignar a la variable, por ejemplo:

int variable = 234;

En realidad esta ultima sentencia equivaldra a estas dos sentencias seguidas:


2.2. VARIABLES

int variable;

variable = 234;

Pero, por comodidad y claridad en el codigo, es recomendable la primera forma.Otros ejemplos de declaraciones-inicializaciones:

String nombre = "Jose Antonio";

int fecha = 2000;

short negativo = -231;

float decimal = 234.565F;

char caracter = \u0234;

2.2.2. Ambito

Una variable declarada dentro de un metodo, tiene su ambito restringido al bloque delimitado por llaves ({ }),en que fue declarada. Por ejemplo,

void main() {...

int a; //Aqu comienza el ambito de a

...

} //Aqu terminaLas variables declaradas en un bloque pueden ser sobreescritas por variables declaradas en un subbloque. Porejemplo,

void main() {int a = 1;

...

if (cond) {String a = "abc";

...

}...

}Se debe ser muy cuidadoso con este tipo de codigo, por lo que se recomienda evitarlo.Por el contrario, en el caso de las variables declaradas a nivel de clase, tambien llamadas atributos o propiedadesde la clase, el ambito de acceso es global dentro de la clase y el acceso fuera de la ella esta determinado por elmodificador de acceso con que se declara la variable.

2.2.3. Control de Acceso

Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se quiere para las variablesde instancia y los metodos definidos en la clase por medio de los siguientes modificadores de acceso:

public :Cualquier clase puede acceder a las propiedades y metodos publicos.

protected :Solo las clases heredadas pueden acceder a las propiedades y metodos protegidos.

private :Las variables y metodos privados solo pueden ser accedidos desde dentro de la clase.



Por defectoTambien llamado, friendly. Solo las clases heredadas y aquellas situadas en el mismo paquete pueden acce-der a las propiedades y metodos.

Por ejemplo:

class Acceso {public int publica = 0;

private char privado = x;

protected float protegido = 2.7f;

double amigo = 1.3;

}

2.2.4. Arreglos

Un arreglo (array) es una manera de agrupar valores de un mismo tipo bajo un mismo nombre. Para accedera los valores individuales, se asigna a cada uno de ellos un numero denominado ndice, el cual comienza desdecero. En Java, se pueden declarar arreglos de dos maneras:

char c[];

char [] c;

De cualquiera de las dos formas, se obtiene un arreglo de caracteres. A partir de ahora, cuando se declare unarreglo, se utilizara la segunda manera, que separa la declaracion de tipo del nombre de la variable; al contrarioque la primera, que solo representa un mal recuerdo de C y C++.Crear matrices (arreglos multidimensionales) es tan sencillo como anadir corchetes:

char [][] c;

Los arreglos en Java son en realidad objetos (como casi todo) y por lo tanto se inicializan llamando a un constructorcon new (ver seccion 3.6.1), aunque el constructor tenga una sintaxis totalmente distinta a la vista hasta ahora:

int [][] numeros = new int [30][10];

Existe otra manera de hacerlo y es indicando los valores iniciales en la declaracion:

String[] paises = { "Chile", "Argentina", "Peru"};Esta declaracion es equivalente a crear el arreglo por medio de un constructor, e ir asignandole los valores uno auno:

String[] paises = new String[3];

paises[0] = "Chile";

paises[1] = "Argentina";

paises[2] = "Peru";

Como se puede observar, para acceder a un valor especfico de un arreglo, se pone el nombre del mismo, acom-panado del ndice correspondiente al valor encerrado entre corchetes. Esto tambien es valido cuando se quiereconsultar el valor del mismo:

public class Arreglos {static String[] paises = { "Chile", "Argentina", "Peru"}public static void main(String[] args) {

System.out.println(paises[1]);

}}


2.3. TIPOS DE DATO

Y, como buen objeto que son, todos tienen un metodo llamado length , que indica la longitud del arreglo. Porejemplo,

public static void main(String[] args) {System.out.println(paises[1]);

System.out.println(paises.length );

}Nota: En realidad, como se puede apreciar en el ejemplo, length es un atributo y no un metodo. Convienerecordar que los arreglos son objetos, porque a la hora de pasar argumentos a una funcion, se pasaran por referenciay no por valor, como los tipos de dato basicos.Por otra parte, hay que tener ciudado al inicializar arreglos multidimensionales, por ejemplo:

String[][] paises = { {"Chile", "Argentina"}, {"Peru"} };

Esto produce un arreglo de dos arreglos de String, uno de largo dos y el otro de largo uno!.

2.3. Tipos de Dato

2.3.1. Basicos

En Java, todo lo que se mueve es un objeto... excepto los tipos de datos basicos, es decir, numeros enteros,reales, caracteres, valores logicos, etc. Todo lo demas seran objetos o, mejor dicho, referencias a objetos. Son losunicos valores que se crean sin utilizar el operador new (ver seccion 45). Y son los siguientes:

Tipo Descripcion Tamano Clase Encapsuladoraboolean Valor logico 1 bit Booleanchar Caracter 16 bit Characterbyte Entero muy pequeno 8 bit Byteshort Entero pequeno 16 bit Shortint Entero normal 32 bit Integerlong Entero grande 64 bit Longfloat Numero real de precision simple 32 bit Floatdouble Numero real de doble precision 64 bit Doublevoid Tipo vaco Void

Podemos crear variables de estos tipos de la manera normal en todos los lenguajes que siguen a C:

int numero = 12;

El definir un valor al declararlo no es necesario, especialmente porque en Java todos tienen un valor por defecto(0 en los numeros, false en los booleanos y el caracter \x0); en ese caso se puede escribir simplemente:

int numero;

Siempre se debera preferir el uso de las clases que encapsulan(en ingles, Wrappers) los tipos basicos, a usar lostipos basicos por si mismos. En este ejemplo sera:

Integer numero = new Integer(12);

Ademas, todas las clases encapsuladoras de tipos de datos basicos, excepto Boolean, tienen atributos MIN VALUEy MAX VALUE, con lo cual se puede obtener el rango de valores que acepta el tipo de dato particular. As ejecutando:



class Wrappers {public static void main(String[] args) {

System.out.println("Byte: "+ Byte.MIN VALUE + "... "+ Byte.MAX VALUE);

System.out.println("Short: "+ Short.MIN VALUE + "... "+ Short.MAX VALUE);

System.out.println("Integer: "+ Integer.MIN VALUE + "... "+ Integer.MAX VALUE);

System.out.println("Long: "+ Long.MIN VALUE + "... "+ Long.MAX VALUE);

System.out.println("Float: "+ Float.MIN VALUE + "... "+ Float.MAX VALUE);

System.out.println("Double: "+ Double.MIN VALUE + "... "+ Double.MAX VALUE);

System.out.println("Character: "+ (int )Character.MIN VALUE + "... "+

(int )Character.MAX VALUE);

}}

Se obtiene:

Tipo Mnimo MaximoByte -128 127

Short -32768 32767

Integer -2147483648 2147483647

Long -9223372036854775808 9223372036854775807

Float 1.4E-45 3.4028235E38

Double 4.9E-324 1.7976931348623157E308

Character 0 65535

Notar que, para los numero reales se indica solo el rango positivo, a esto hay que agregarle el mismo rangonegativo.

2.3.2. Conversion de Tipos

Como en muchos otros lenguajes de programacion, en Java tambien es posible asignar un valor de un tipo auna variable de otro tipo. A pesar que esto no representa mucha dificultad, es necesario estar consciente que sepueden dar ciertos efectos secundarios al convertir datos, para lo cual hay que tener claros algunos conceptos yprocedimientos del compilador:

Conversion de tipos Automatica

Si al hacer la conversion de un tipo a otro, se dan las dos siguientes premisas:

Los dos tipos son compatibles.

El tipo de la variable destino es de un rango mayor al tipo de la variable que se va a convertir.

Entonces, la conversion entre tipos es automatica, esto es, la JVM tiene toda la informacion necesaria para realizarla conversion sin necesidad de ayuda externa. A esto se le conoce como conversion implcita y cuando se hablade los tipos numericos de Java, se le da el nombre de widening conversion que traducido vendra a ser algoas como conversion por ampliacion. No obstante, no todos los tipos numericos son compatibles con char oboolean (concretamente byte y short ) y estos dos tampoco lo son entre ellos.

Conversion de Tipos Incompatibles

Cuando alguna de las 2 premisas anteriores no se cumple, entonces la conversion automatica es imposible(salvo que se este evaluando una expresion como se ve en la seccion siguiente), el compilador da un error diciendoalgo as como la variable tal necesita una conversion explcita. Pero, no es que no se pueda realizar tal conversion,sino que la JVM necesita de informacion adicional: el tipo al que se va a convertir la variable de origen. Puesbien, esta conversion explcita es llamada un casting de tipos. Cuando se trata de tipos numericos, a este tipo de


2.3. TIPOS DE DATO

conversion se le llama narrowing compresion que se podra traducir como conversion por estrechamiento dadoque se esta recortando la variable para poder guardarla en el tipo destino.La expresion general del casting de un tipo es:

(tipo destino) valor

donde tipo destino indica el tipo al que se quiere hacer la conversion explcita del valor deseado.En el caso de los tipos numericos, al recortar el valor de la variable de rango mayor para que quepa en el tipo derango menor, resulta que se pierde informacion. Mas adelante, se vera en que se traduce esa perdida de informacionsegun sean los tipos.

Promocion de Tipos Automaticamente al Evaluar una Expresion

Aqu radica uno de los puntos donde la conversion puede dar problemas si no se sabe, pero que una vezasimilado es una de las muchas ventajas que Java tiene frente a otros lenguajes. El caso es que cuando la JVM,tiene que analizar una expresion, existe la posibillidad real de que el resultado intermedio de una operacion excedael rango de los operandos. Para solventar este problema, lo que Java hace es una promocion automatica de todoslos operandos de tipo byte o short a int. Pero esto tambien puede llevar al error de que se haga una conversion detipos incompatibles y, al no hacer el casting correspondiente, la compilacion fallara. Como se ve en el siguienteejemplo:Caso 1:

byte a = 40;

byte b = 50;

int c = a * b; //el compilador no dara ningun error.

Caso 2:

byte a = 25;

a = a*2; //ERROR: Explicit cast needed to convert int to byte.

Ahora, como puede dar este error si el resultado no excede del rango de un tipo byte (-128, 127)?.Pues bien, lo que ocurre, es que al hacer la multiplicacion, Java ha promocionado automaticamente este valor a inty por eso para volver a guardarlo en un tipo byte , se tiene que hacer una conversion explcita. En el primer caso,este error no se produce porque el resultado de la operacion se guarda en un int .

a = (byte )a*2; //ahora el compilador no dara ningun error.

Para concluir con las reglas de promocion de tipos cuando se evaluan expresiones, se dan a conocer otros detallesmas, que es conveniente tener en cuenta:

Si alguno de los operandos es long , entonces la expresion entera promociona a long .

Si alguno de los operandos es float , entonces la expresion entera promociona a float .

Si alguno de los operandos es double , entonces el resultado sera double .

Por ultimo, recuerde que cuando un metodo devuelve Object, dado que esta clase es la super-clase de todas, sepuede y a veces se debe hacer un casting explcito al tipo de la variable que interesa. Por ejemplo, si se tiene unvector en el que se introducieron elementos del tipo MiClase, para poderlos recuperar, hay que ejecutar:

MiClase var = (MiClase) vector.get(index);

A continuacion una serie de casos practicos para concluir este tema.



class ConversionTipos {public static void main(String args[]) {

byte b;

int i = 257;

double d = 323.142;

double d2;

float f = 5.65f;

char c = c;

short s = 1024;

b = (byte ) i;//efecto: se devuelve (i modulo 256), rango de byte.

System.out.println(b);

i = (int ) d;//efecto: truncamiento de la parte decimal.

System.out.println(i);

b = (byte )d;//efecto: truncamiento y luego (result truncado modulo 256)

System.out.println(b);

i = (int )f;//efecto: truncamiento de la parte decimal


i = c;//correcto por ser int, pero un byte necesitara un cast explcito.


f = c; d = c;//correcto.

i = b * c;//efecto: la operacion promociona a int.


d2 = (f*b) + (i/c) - (d*s);

/*

efecto: el resultado de la promocion de todas las expresiones es un double:

(f*b) promociona a float, (i/c) promociona a int y (d*s) promociona a double.

Luego, float + int - double promociona a double.

*/

System.out.println(d2);

}}

2.3.3. Objetos

Ahora bien, a parte de los tipos de dato basicos, que pueden ser cien por ciento reemplazados por sus respec-tivos wrappers, todo lo demas son objetos.Para declarar un objeto en el codigo, primero se indica la clase del objeto a crear, seguido del identificador delobjeto. El objeto declarado, tambien puede ser inicializado directamente, en la misma lnea. Por ejemplo,

String S = "abc";

Sus atributos y metodos publicos pueden ser accesados por medio del operador punto (.) . Siempre y cuando lareferencia no sea nula, en cuyo caso se genera un error en tiempo de ejecucion (NullPointerException). Porejemplo,


2.4. OPERADORES

Double.MIN VALUE;

S.trim();

2.4. Operadores

Los operadores sirven para unir identificadores y literales para formar expresiones, que son el resultado de unaoperacion. Los de Java son muy parecidos a los de C y C++.De poco servira declarar variables o inicializarlas, si no se puede operar con estas: sumarlas, restarlas, multipli-carlas, compararlas, etc. Para este tipo de operaciones sobre las variables, existen los operadores. En funcion delnumero de operandos sobre los que actuan y el tipo de operacion que efectuan, los operadores en Java se clasificansegun el siguiente cuadro:

Tipo OperadoresUnarios ++ -- + - ! ()

Aritmeticos * / % + -Rotacion > >>>

Comparacion < >= == !=Logicos & | && ||Ternarios ?:Asignacion =

2.4.1. Operadores Unarios

Se caracterizan por actuar sobre un solo operando:

Operadores Unarios ++ y --

Estos operadores incrementan o decrementan, respectivamente, la variable en una unidad.

int val = 0;

++val;

La variable entera val ahora tiene el valor 1. Esta ha sido su utilizacion prefija. Ahora, se vera su utilizacion sufija.

int val = 0;

val++;

La variable entera val ahora tiene el valor 1. A pesar que a simple vista, pareciera que usar el operador ++ enprefijo o en sufijo es lo mismo. La respuesta es no. En este ejemplo, se vera la diferencia:

int x = 34;

int y = ++x;

El valor final de x es 35 y el valor final de y es 35 tambien, sin embargo:

int x = 34;

int y = x++;

El valor final de x es 35, pero el valor final de y es 34.La diferencia radica, en que al utilizar el operador en sufijo, primero se asigna el valor de x a y, y despues seincrementa x en una unidad. Por el contrario, usando el operador en prefijo, primero se incrementa x en unaunidad, y luego se asigna el valor de x a y.



Operadores Unarios + y -

Los operadores + y - dan signo positivo o negativo a una expresion numerica.

int variable = -2;

short variable = -(x + 5);

long siguiente = +4;

Operador Unario de Negacion !

El operador ! invierte el valor de una expresion booleana. Esto es, convierte true a false y viceversa.

boolean bool=!true ;

La variable bool tiene el valor false .

Operador Unario de Inversion

Este operador() actua sobre valores numericos enteros y realiza una inversion a nivel de bits. Todos los bitsdel numero sobre el que actua son cambiados, incluyendo el bit del signo. Los ceros por unos y los unos por cero.

Operador Unario de Casting ()

Este operador es importante. Se llama operador de conversion y se utiliza para convertir expresiones numericasde un tipo a otro, como se vio en la seccion 2.3.2.

int var=234;

long largo=(long )var;

2.4.2. Operadores Aritmeticos

Estos operadores realizan operaciones aritmeticas en los operandos sobre los que actuan. No hay mucho queexplicar sobre estos operadores, porque hacen justo lo que se espera de ellos. El operador + suma, el operador- resta, el operador * multiplica y el operador / divide. Unicamente, se explicara el operador % u operadormodulo.

Operador Aritmetico Modulo %

Da como resultado el resto resultante de la division entre los dos operandos sobre los que actua.

int resto = 14 % 3;

La variable resto tiene ahora el valor 2.Todos estos operadores aritmeticos actuan sobre valores numericos, excepto el operador + que tambien lo hacesobre cadenas de caracteres. Es posible sumar el contenido de dos cadenas de caracteres para formar una sola.Por ejemplo:

String s1 = "Este curso ";

String s2 = "trata sobre el lenguaje Java";

String res = s1 + s2;

La cadena res tiene ahora el valor "Este curso trata sobre el lenguaje Java".Tambien es posible, sumar una cadena y una variable. Automaticamente Java convertira el contenido de esa varia-ble a un valor de cadena representable. Por ejemplo:

int var = 365;

String s = "Un ano tiene ";

String res = s + var + "das";

La cadena res tiene ahora el valor "Un ano tiene 365 das".


2.4. OPERADORES

2.4.3. Operadores de Rotacion

Estos operadores actuan a nivel de bits.

Operadores de Rotacion >> y >> es ligeramente distinto al operador >> y a menudo es fuente de confusion. En realidades muy sencillo de comprender, pero se necesita entender con mas detalle, como se representan los numeros enmemoria.Como ya se ha visto el tipo de dato int es un entero con signo de 32 bits. El numero 4 en memoria es representadoas:

00000000000000000000000000000100

Pero, para representar numeros negativos se utiliza el primer bit como una senal que indica si el numero es positivo(bit igual a cero) o negativo (bit igual a 1). La representacion del numero -4 es entonces:

10000000000000000000000000000100

Cuando se rotan numeros negativos con el operador de rotacion a la derecha (>>) antes visto, el signo del numerose respeta. Imagine que se rota el numero anterior a la derecha con el operador >>, el resultado sera:

10000000000000000000000000000010

Sin embargo, cuando se usa el operador >>> el bit de signo, no se respeta y es rotado tambien:

01000000000000000000000000000010

As, el resultado de la operacion:

int var = -4;

var >>>1;

La variable var tiene ahora el valor 2147483650. Sin embargo:

int var = -4;

var >>1;

La variable var tiene ahora el valor -2.



2.4.4. Operadores de Comparacion

Los operadores de comparacion dan como resultado siempre una expresion booleana (true o false ) inde-pendientemente de que los operandos sobre los que actuan sean numericos, booleanos, de caracter, etc.Los operadores de comparacion en Java son: =, == y !=.Literalmente y de izquierda a derecha estos operadores se leen as: menor que, menor o igual que, mayor que,mayor o igual que, igual que y distinto de. Aunque su uso es bastante obvio, se vera un ejemplo por cada tipo deoperador de comparacion para su mejor comprension:

boolean resultado;

resultado = (5 = 10);

La variable resultado se inicializa con el valor true .

boolean resultado = (20 == 21);

La variable resultado se inicializa con el valor false .

boolean resultado = (20 != 21);

La variable resultado se inicializa con el valor true .

2.4.5. Operadores Logicos

Los operadores logicos pueden operar sobre operandos numericos o sobre operandos booleanos. En el primercaso, devuelven una expresion numerica y en el segundo caso devuelven una expresion booleana. Cuando operansobre expresiones numericas, estos operadores actuan a nivel de bit.

Operador Logico AND &

La tabla logica de la operacion & es la siguiente:

& 0 10 0 01 0 1

Cuando se usa este operador con dos operandos numericos, este operador actua a nivel de bit. Por ejemplo:

int a = (6 & 2);

El valor de a es ahora 2, puesto que efectuando la operacion logica & sobre 6 y 2 se obtiene:

...0000110 (representacion binaria de 6)


&

...0000010 (que en numeracion decimal es 2)


2.4. OPERADORES

Cuando se usa este operador con dos operandos booleanos, se obtiene una expresion booleana y su uso es aun massencillo. Solo hay que ver la tabla logica de la operacion & y tener en cuenta que false es cero y true es 1.Por ejemplo:

boolean valor = (true & false );

La variable valor tiene ahora el valor false .

Operador Logico XOR

Su uso es similar al del operador logico &. La tabla logica de esta operacion es:

0 10 0 11 1 0

Por ejemplo:

int a = (6 2);

El valor de a es ahora 4 puesto que efectuando la operacion logica sobre 6 y 2, se obtiene:




En el caso de que los operandos sean booleanos, se devuelve un valor booleano.

boolean valor = (true true );

La variable valor tiene ahora el valor false .

Operador Logico OR |

La tabla logica de la operacion | es la siguiente:

| 0 10 0 11 1 1

Por ejemplo:

int a = (6 | 2);

El valor de a es ahora 6 puesto que efectuando la operacion logica | sobre 6 y 2, se obtiene:



|


En el caso de que los operandos sean booleanos, se devuelve siempre un valor booleano. Por ejemplo:

boolean valor = (true | false );

La variable valor tiene ahora el valor true .



Operadores Logicos && y ||

Estos operadores solo pueden usarse sobre operandos booleanos y tienen una importante diferencia respecto alos operadores & y |. Esta es, que puede que no se evalue el operando de la derecha si no es necesario, con loque se gana en eficiencia.Si, por ejemplo, se efectua la operacion "exp a || exp b" y exp a vale true , entonces la expresion exp bno es evaluada, puesto que da lo mismo que esta sea true o sea false debido a que el valor devuelto va aser invariablemente true . Esto mejora la mucho eficiencia en el caso de que exp b sea una expresion booleanacompleja, por ejemplo, formada de cientos de operandos.

2.4.6. Operador Ternario

Tambien llamado Operador Condicional , es quizas el operador mas complejo de todos, pero es bastante util.Toma tres operandos, una condicion booleana y dos expresiones. El primer operando es una condicion booleanay si su valor es true se evalua el segundo operando(la primera expresion), pero si es false se evalua el terceroperando(la segunda expresion). Se vera un ejemplo para ver su funcionamiento:

boolean condicion = true ;

int resultado = (condicion) ? 13: -13;

La variable resultado se inicializa con el valor 13. Sin embargo:

boolean condicion = false ;

int resultado = (condicion) ? 13: -13;

La variable resultado se inicializa con el valor -13.

2.4.7. Operadores de Asignacion

Operador de Asignacion =

Asigna un valor a la expresion a la izquierda del operador. Puede operar sobre todo tipo de datos.

int b = -123;

int a = b;

La variable a se inicializa con el valor -123.

Operadores de Asignacion *=, /=, %=, +=, &=, =, |=, = y >>>=

Ademas de realizar la asignacion, primero se realiza la operacion indicada. Por ejemplo:

int val = 6;

val *= 4;

La variable val tiene ahora el valor 24.

2.4.8. Precedencia de Operadores

Cuando se necesita construir una expresion compleja con varios operandos y operadores, es importante sabercuales de estos se resuelven primero, puesto que esto puede variar el resultado final de la expresion. Por ejemploen la expresion:

int x=2+4/2;


2.4. OPERADORES

Si se resuelve la expresion sumando 2mas 4 y el resultado se divide entre 2 se obtiene en x el valor 3. Sin embargo,si primero se divide 4 entre 2 y al resultado se le suma 2 se obtiene en x el valor 4.Java sigue unas estrictas pero sencillas reglas a la hora de evaluar estas expresiones. El analisis de la expresion serealiza siempre de derecha a izquierda, pero aun no esta resuelto el problema, porque aun siguiendo este orden,pueden producirse resultados inconsistentes. Para resolverlo Java da un nivel de prioridad distinto a cada operador.Segun la tabla siguiente:

Precedencia OperadoresMayor . [ ] ( )

++ -- !

* / %

+ -

> >>>

< > =

== !=

&

&&

||

? :

Menor =

En la tabla los elementos de la misma fila tienen la misma precedencia. De los elementos de la misma columnatienen mayor precedencia los que estan mas arriba. Se vera con un ejemplo, como resolvera el compilador de Javauna expresion compleja:

int res = ( 2 + 3 ) * 12 / 2 - (- 23);

El operador de mayor precedencia es el parentesis (), sin embargo, hay dos parentesis. Se resuelve primero elde la derecha. Quedara la expresion:

int res = ( 2 + 3 ) * 12 / 2 + 23;

A continuacion el parentesis de la izquierda:

int res = 5 * 12 / 2 + 23;

Los operadores de division y de multiplicacion tienen superior precedencia al operador suma, pero la mismaprecedencia entre ellos, luego se resuelve primero el operador de la derecha. La division:

int res = 5 * 6 + 23;

El operador multiplicacion tiene mayor precedencia que el operador suma.

int res = 30 + 23;

Y finalmente:

res = 53;

Es una buena practica, NO valerse de la precedencia de los operadores, sino que siempre incluir la cantidadsuficiente de parentesis, de tal forma que no quede ninguna duda del sentido de la expresion.



2.4.9. Operaciones con Objetos

El operador ==

A pesar que dos objetos pueden compararse usando el operador ==, esto generalmente, no generara el resul-tado esperado, ya que como Java no soporta sobrecarga de operadores, este operador compara las referencias delos objetos, es decir, si ocupan el mismo espacio de memoria, y no su contenido. Sin embargo, esto puede producirconfusion, como se ve en el siguiente codigo:

String S1 = "a";

String S2 = "a";

if (S1==S2) {System.out.println("Que paso aqu?");

}Lo que sucede es que, a pesar de que S1 y S2 se definieron por separado, el compilador optimiza el codigo,reconociendo la repeticion del literal "a", guardandolo en solo una direccion de memoria, a la que luego apuntantanto S1, como S2.Por lo tanto, para comparar objetos, siempre usar el metodo compareTo() si lo implementan, o usar el metodoequals() que se vera mas adelante, en la seccion 2.9.

La Interfaz Comparable

Todas los wrappers de tipos de datos numericos basicos, implementan una interfaz que provee el siguientemetodo:

int compareTo(Object o)

Esto debido a que Java no soporta sobrecarga de operadores, por lo que cualquier intento de usar operadores decomparacion con objetos, resultara en un error de compilacion. As, x.compareTo(y) retorna un entero negativosi xy. Con lo cual, se puede escribir codigo como elsiguiente ejemplo:

Double PI = new Double(3.1415);

Double E = new Double(2.7183);

if (E.compareTo(PI)

2.5. CONTROL DE FLUJO

if (o instanceof String)

System.out.println("Es una cadena")

else

System.out.println("No es una cadena");

}}

Al ejecutar el codigo: efectivamente es una cadena. Si se inicializa a cualquier cosa que no fuera una cadena diraque no lo es.

2.5. Control de Flujo

En Java existen varias sentencias de control de flujo, las mismas que provee C o C++.

2.5.1. La Sentencia if

El mas basico, sencillo y utilizado es el if -else . Dado que else es opcional, se puede escribir de dosformas:

if (expresion booleana) {sentencias

}o

if (expresion booleana) {sentencias

}else {

sentencias

}Esta construccion permite ejecutar la primera sentencia si la expresion logica es verdadera. En caso de que seafalsa (y de que el if -else este en la segunda forma) se ejecutara la segunda sentencia.

2.5.2. La Sentencia switch

Para bifurcar tambien existe el switch :

switch (expresion) {case valor1:

sentencia;

break ;

case valor2:

sentencia;

break ;

case valor3:

sentencia;

break ;

...

default :

sentencia;

break ;

}



La estructura switch compara el valor contenido en la expresion, con cada uno de los valores situados despuesdel case , ejecutando en caso de que exista coincidencia, el codigo situado a la derecha de los dos puntos. Esecodigo no se engloba mediante llaves. Si no existe coincidencia, se ejecuta la sentencia optativa default . Cadacase debera terminar con una sentencia break , de no ser as se ejecuta el codigo del case siguiente.

2.6. Ciclos

Ahora se vera las distintas estructuras que ofrece Java para realizar iteraciones.

2.6.1. La Sentencia while

Las mas genericas son while y do -while :

while (expresion booleana) {sentencia

}y

do {sentencia

} while (expresion booleana);En ambos casos se ejecutara la sentencia, mientras se cumpla la expresion booleana. La diferencia consiste en queen el primer caso, esa expresion se comprueba antes de iterar (ejecutar la sentencia) y en el segundo despues. Portanto, en ese ultimo caso, la sentencia se ejecutara siempre al menos una vez.

2.6.2. La Sentencia for

Otra iteracion interesante es el bucle for:

for (inicializacion; expresion booleana; paso) {sentencias

}En este caso lo primero que hara la JVM, sera ejecutar las sentencias (separadas por comas) contenidas en ini-cializacion, luego comprobara si es cierta la expresion booleana y ejecutara el codigo de sentencia. Finalmenteejecutara las sentencias (separadas por comas) contenidas en paso y comprobara de nuevo la expresion booleana.

2.6.3. Control de Flujo en Ciclos

Las capacidades de controlar el flujo de los ciclos, es bastante limitada, con lo que se ha visto hasta el momento.Es por eso que Java, cuenta con un par de sentencias que ayudan a controlar el flujo en ciclos.

La Sentencia break

Esta sentencia permite abortar un ciclo definitivamente. Por ejemplo:

boolean cond = false ;

int sum = 0;

int prod = 1;

for (int i = 1; i

2.7. MANEJO DE EXCEPCIONES

break ;

}prod *= i;

}Que no es lo mismo que:

for (int i = 1; (i


Tercero

Exception in thread "main"java.lang.ArrayIndexOutOfBoundsException

at Desbordamiento.main(Desbordamiento.java, Compiled Code)

Da un error de ejecucion (en esta terminologa se dira que se lanzo una excepcion) al intentar acceder a dicho valorinexistente. Se ve que, por ahora, el comportamien

cursodejava.pdf

Documents