Libro i. ibm.

Core Java
Código del Curso: CY420
Versión: 5.1
Guía del Estudiante
Libro 1: Core Java
IBM Training
Worldwide Certified Material

.
Información Sobre la Publicación
Esta publicación ha sido producida usando Microsoft Word 2000 y Microsoft PowerPoint
2000 para Windows.
Marcas Registradas
IBM ® es una marca registrada por International Business Machines Corporation.
Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o
marcas de servicios de otros.
Marcas Registradas de otras Compañías
HotJava browser, Java Development Kit (JDK), Java, Java Servlet, Solaris, Enterprise
Java Beans, Java Server Pages, JDK, JSP – Sun Microsystems, Microsoft MAKECAB,
Windows operating system, ASP, VB, .NET, VC++, Microsoft Access, Microsoft SQL
Server, Microsoft ODBC for Oracle – Microsoft Corp, WinZip – Nico Mak Computing,
Inc., Time – Time Warner, JDBC – Javasoft, Oracle – Oracle Corporation, Sybase –
Sybase Inc., UDB DB2 – IBM.
Edición Octubre 2007
La información contenida en este documento no ha sido sometida a ninguna prueba
formal de IBM y es distribuida básicamente “como es" sin ninguna garantía ya sea
expresa o implícita. El uso de esta información o la implementación de cualquiera de
estas técnicas es responsabilidad del comprador y dependerá de la habilidad de éste
para su evaluación e integración en el ambiente operacional del comprador. A pesar de
que cada tema ha sido revisado por IBM para su exactitud en una situación específica,
no hay garantía de que obtener el mismo resultado o uno similar a éste en otra
situación. Los compradores que intenten adaptar estas técnicas a sus propios
ambientes lo hacen bajo su propio riesgo.
Copyright International Business Machines Corporation, 2007. All rights reserved.
Este documento no puede ser reproducido en su totalidad o en parte sin el previo
permiso escrito de IBM.
Instrucciones Especiales para la Impresión de este Curso:
No elimine páginas en blanco que puedan aparecer al final de cada unidad o entre
unidades. Estas páginas fueron insertadas intencionalmente.

Guía del Estudiante Core Java
i
© Copyright IBM Corp. 2007
Los materiales del curso no pueden ser reproducidos total o
parcialmente sin el previo permiso escrito de IBM.
Contenido
Descripción del Curso: Core Java....................................................................iv
Descripción de Unidades ................................................................................viii
Volumen 1: Fundamentos de Java....................................................................1
Unidad 1: Visión General de Java .....................................................................3
Objetivos del Aprendizaje 3
1. Introducción 4
2. Historia de Java 4
3. Comparación entre Java y C++ 5
4. Características de Java 6
5. La Plataforma Java 11
6. Impacto de Java en la WWW 16
7. Clases y Objetos 17
8. Orientación a Objetos en Java 21
9. Ejemplo de una Aplicación Java 26
10. Ejemplo de Applet Java 27
Resumen 29
Unidad 1: Examen de Autoevaluación 30
Respuestas a la Unidad 1: Examen de Autoevaluación 32
Unidad 2: Operadores, Expresiones y Control de Flujo................................33
1. Introducción 34
2. Tipos de Datos en Java 34
3. Clases Envolventes 39
4. Math Clases Colaboradoras sobre los Tipos de Datos 44
5. Manejo de String 44
6. Identificadores 50
7. Declaración e Inicialización de Variables 51
8. Operadores en Java 53
9. Conversión de Tipos 63
10. Arreglos 66
11. Estructuras de Control 71
Resumen 86

Core Java Guía del Estudiante
ii
Unidad 3: Lab. de Operaciones, Expresiones y Control de Flujo.................90
Ejercicios de Laboratorio 91
Volumen 2: Programación Orientada a Objetos.............................................95
Unidad 1: Clases y Objetos..............................................................................97
1. Introducción 98
2. Clases y Objetos 98
3. Estructura de una Clase Java 101
4. Variables 103
5. Métodos 108
6. Modificadores de Acceso 113
7. Constructores de una Clase 121
8. Sobrecarga de Método 124
9. Clases Anidadas 127
10. Argumentos de Línea de Comandos 130
11. Ciclo de Vida de un Objeto 131
12. Manejo de la Memoria en Java 136
13. Enumeraciones 136
Resumen 138
Respuestas a Unidad 1: Examen de Autoevaluación 141
Unidad 2: Laboratorio de Clases y Objetos..................................................143
Unidad 3: Herencia .........................................................................................147
1. Introducción 148
2. Sintaxis para Declarar Clases Usando Herencia en Java 148
3. Conceptos Esenciales de Herencia 152
Resumen 177
Unidad 4: Laboratorio de Herencia ...............................................................181
Objetivos de Aprendizaje 181

iii
Unidad 5: Clases Abstractas e Interfaces.....................................................183
2. Clases Abstractas 184
3. Uso de Clases Abstractas 186
4. ¿Qué son las Interfaces? 194
5. Usar Interfaces Como Referencias 202
6. Heredar de una Interfaz 205
7. Opciones de Herencia en Java 208
Resumen 210
Unidad 6: Laboratorio de Clases Abstractas e Interfaces...........................215
Unidad 7: Paquetes.........................................................................................219
2. Necesidad de los Paquetes 220
3. Crear Paquetes en Java 222
4. Representación del Paquete en el Sistema de Archivos 224
5. Paquetes y Protección de Acceso 227
6. Usar Miembros de Paquetes 235
7. Agrupar Paquetes 239
8. Despliegue de Paquetes 239
9. Paquetes Incorporados en Java Usados Comúnmente 245
Resumen 248

iv
Descripción del Curso: Core Java
Nombre del Curso
Core Java
Duración
La duración del curso es de 108 horas.
Propósito
Este curso ofrece a los estudiantes un estudio del lenguaje Java. El primer volumen del
curso se ocupa de los fundamentos de Java, del impacto de Java en la Web, la
orientación a objetos en Java, operadores y estructuras de control. Los estudiantes
aprenderán sobre las características de Java, convenciones de nombres, declaración de
variables y su inicialización.
El segundo volumen del curso se ocupa de la programación orientada a objetos.
Proporciona una descripción de los miembros de una clase Java, del uso de los
métodos de clase y del manejo de la memoria en Java. Los estudiantes aprenderán
sobre los fundamentos de la herencia, de clases, métodos abstractos y las interfaces.
También aprenderán sobre los paquetes incorporados comúnmente usados de Java.
El tercer volumen del curso trata de las excepciones y los métodos para lanzar
excepciones. Los estudiantes aprenderán cómo distinguir entre las excepciones
verificadas y no verificadas. También aprenderán sobre cómo crear y usar excepciones
definidas por el usuario.
El cuarto volumen del curso proporciona una descripción de las capacidades para
entrada/salida. Trata de los archivos y los flujos, los flujos de caracteres, las clases
lectoras y escritoras, además de los archivos de acceso aleatorio. También se ocupa de
la serialización de objetos, de la interfaz serializable y de la interfaz externalizable. Los
estudiantes estudiarán la clase ObjectOutputStream y la clase ObjectInputStream.
El quinto volumen del curso provee una descripción de las interfaces de usuario usando
AWT y Swing. Se ocupa de las clases y contenedores de AWT, dibujo y actualización de
los componentes de la interfaz del usuario. También trata los métodos heredados por
los componentes de AWT de las clases componente y contenedor. Los estudiantes
aprenderán sobre los administradores de diseño, además de asociarlos al contenedor.
Adicionalmente, obtendrán información sobre el modelo de delegación de eventos y el
manejo de eventos.
Se proporciona una introducción a ciertas clases fundamentales de Java. Se ocupa de
la arquitectura MVC y las clases Swing, las diferencias entre AWT y Swing, los
componentes Swing, el API de Java 2D y la representación en 2D.
El sexto volumen del curso introduce a los applets. Se ocupa del ciclo de vida de un
applet, prueba de applets, carga de un applet, métodos de dibujo y manejo de eventos.

v
Los estudiantes aprenderán conceptos tales como: usar el API de applet, localizar y
cargar archivos de datos, mostrar documentos en un navegador web, comunicación con
otros applet y restricciones de seguridad en applets.
El séptimo volumen del curso contiene una introducción a multihilos y redes. Estudia el
ciclo de vida de los hilos, creación y funcionamiento, realizar subclases de la clase de
hilo e implementar la interfaz Runnable. También se ocupa de la sincronización de hilos,
de los métodos y sentencias sincronizadas, además de la comunicación entre hilos. Los
estudiantes aprenderán sobre el trabajo con URLs y programación de conectores,
clases orientadas a conexión en Java, envío y recepción de datagramas.
El octavo volumen de este curso presenta una descripción del API de colecciones. Se
ocupa del marco de trabajo para colecciones de Java, de las interfaces e
implementaciones de las colecciones. Presenta la conectividad a la base de datos en
Java y las sentencias SQL usadas en los programas Java, además de los pasos que
implica el acceso a base de datos. Los estudiantes aprenderán sobre procedimientos
almacenados, manejo de la transacción, soporte de cursores, procesamiento de
múltiples conjuntos de resultados, entre otras funcionalidades de JDBC. Para finalizar
se discute acerca de las características avanzadas, tales como: las consideraciones de
seguridad cuando se trabaja con programas Java, los Java beans y los conceptos de la
internacionalización.
El curso incorpora varias sesiones de laboratorios donde los estudiantes obtendrán
experiencia práctica en los conceptos de Core Java.
Audiencia
Estudiantes, Profesionales y Gente de Negocios.
Prerrequisitos
CY410, CY350

vi
Objetivos
Al completar este curso, usted será capaz de:
• Entender las características principales de Java.
• Explicar los principios de orientación a objetos en Java.
• Explicar las diferentes estructuras de control usadas en Java.
• Explicar la necesidad y el uso de los constructores de una clase.
• Describir cómo se realiza el manejo de la memoria en Java.
• Describir cómo crear jerarquías de herencia.
• Definir y explicar cómo implementar una interfaz.
• Explicar la variable classpath y describir su uso.
• Discutir las excepciones y las técnicas tradicionales para el manejo de errores.
• Describir el manejo de excepciones en Java.
• Examinar las diferentes formas en las que las excepciones pueden ser lanzadas,
capturadas y manejadas.
• Exponer la clase File.
• Explicar los diferentes flujos de caracteres y de byte.
• Explicar la interfaz Serializable y la clase ObjectInputStream.
• Describir algunas clases útiles y algunos GUI en AWT.
• Explicar cómo escoger un administrador de diseño y sus responsabilidades.
• Explicar cómo implementar el mecanismo de delegación de eventos.
• Describir la arquitectura MVC.
• Explicar los administradores de diseño definidos en Swing.
• Describir las propiedades de la apariencia de Swing.
• Establecer las diferencias entre un applet y una aplicación.
• Describir los métodos para agregar componentes de UI.
• Mencionar las ventajas del API Applet.
• Explicar los conceptos de hilos y multihilos.
• Explicar cómo crear hilos desde la clase Thread y desde la interfaz Runnable.
• Describir el concepto de sincronización.
• Explicar los métodos y sentencias sincronizadas.
• Exponer los URLs y las excepciones de URL.
• Explicar los conectores orientados a conexión y no orientados a conexión.
• Describir las interfaces de colecciones.
• Describir los algoritmos polimórficos del JDK que operan en las colecciones.
• Discutir el API de JDBC.
• Explicar el manejo de excepciones en JDBC.

vii
• Explicar el uso de PreparedStatement y CallableStatement en JDBC.
• Mencionar algunas de las clases de soporte de JDBC en Java.
• Explicar la manipulación de objetos de una clase.
• Exponer las características de seguridad cuando se trabaja con programas Java.
• Explicar el empaquetamiento de componentes Java.
• Exponer el API Java 2D.
Agenda
Cada unidad en este curso es de 2 horas de duración.

viii
Descripción de Unidades
Volumen 1: Fundamentos de Java
Unidad 1: Visión General de Java
Esta unidad introductoria proporciona una visión general de Java, incluyendo la historia
del desarrollo de Java, fundamentos básicos de la Programación Orientada a Objetos y
aspectos básicos de Java. También cubre la plataforma de Java y su efecto en la
WWW.
Unidad 2: Operadores, Expresiones y Flujo de Control
Esta unidad se ocupa de los elementos fundamentales de Java: tipos de datos y
variables, diferentes tipos de operadores en Java y de la precedencia de operadores.
También se discuten las conversiones de tipo y las estructuras de control en Java.
Unidad 3: Laboratorio de Operadores, Expresiones y Flujo de Control
Esta unidad de Laboratorio permite al estudiante poner en práctica algunos de los
aspectos fundamentales de Java, como operaciones aritméticas, operadores de bits y
lazos en Java. Esta actividad se realiza a través de un pequeño conjunto de ejercicios.
Volumen 2: Programación Orientada a Objetos
Unidad 1: Clases y Objetos
El concepto de una clase, el ciclo de vida de un objeto y los constructores de una clase
son algunos de los tópicos tratados en esta unidad. Esta unidad también examina las
especificaciones para el control del acceso, cómo declarar variables miembro, métodos
miembro, la manera de acceder a las clases utilizando métodos estáticos, métodos
sobrecargados y argumentos en la línea de comandos. Finalmente, se ofrece una visión
general sobre el recolector de basura.
Unidad 2: Laboratorio de Clases y Objetos
En esta unidad se desarrollan ejercicios de laboratorio para crear clases y objetos,
llamar métodos de una clase y sobrecargar métodos de una clase. También proporciona
una ruta de experiencia práctica acerca de los paquetes, el CLASSPATH y su
utilización, la protección de acceso mientras se usan los paquetes, miembros de
paquetes y cómo importar paquetes. También le permite al estudiante tener una visión
general de los paquetes intrínsecos de Java más usados.
Unidad 3: Herencia
El principal objetivo de esta unidad es entender los aspectos básicos de la herencia,
cómo utilizar el modificador súper, cómo crear la herencia multi-nivel y los fundamentos
del método de sobreescritura. También se discute el uso de la palabra clave final para
evitar la sobreescritura y para evitar la herencia.

ix
Unidad 4: Laboratorio de Herencia
Esta unidad de laboratorio permite al estudiante tener una mejor comprensión del
concepto de herencia y cómo llamar a los métodos de la clase base.
Unidad 5: Clases Abstractas e Interfaces
En esta unidad se discute acerca del modificador abstract y las clases y métodos
abstractos. También se discuten las interfaces, su implementación total o parcial, el uso
de interfaces y referencias, las variables de una interfaz y cómo heredar desde una
interfaz.
Unidad 6: Laboratorio de Clases Abstractas e Interfaces
Esta unidad de laboratorio le ofrece parcialmente al estudiante una exposición del uso
de las clases abstractas y la necesidad de usar interfaces.
Unidad 7: Paquetes
Los paquetes son un aspecto importante en el estudio de Java. En esta unidad se
define qué es un paquete, el CLASSPATH y su utilización, además de la protección de
acceso mientras se usan los paquetes. También explica cómo utilizar los paquetes
miembro, cómo importar paquetes y se explican algunos de los paquetes intrínsecos de
Java más utilizados.
Volumen 3: Manejo de Excepciones
Unidad 1: Manejo de Excepciones y Tipos de Excepciones
El lenguaje Java proporciona algunos mecanismos sofisticados para el manejo de
excepciones, en comparación con otros lenguajes de programación modernos. Esta
unidad establece qué es una excepción y discute la importancia del manejo de
excepciones. Proporciona una breve visión del manejo de excepciones en los lenguajes
de programación y cómo se aplica en Java. Se examinan los tipos de excepciones, su
jerarquía en Java, las declaraciones try y catch, así como la cláusula finally en
Java. Proporciona una visión de las excepciones en tiempo de ejecución (runtime) y los
diferentes métodos para el lanzamiento y propagación de excepciones.
Unidad 2: Lanzamiento y Manejo de Excepciones
Esta unidad trata con los métodos de lanzamiento de excepciones, métodos para
manejar excepciones y las diferentes formas en que las excepciones pueden ser
lanzadas, capturadas y manipuladas. También se discute el método mediante el cual se
crean y usan las excepciones definidas por el usuario.
Unidad 3: Laboratorio de Lanzamiento y Manejo de Excepciones
Basándose en las unidades 1 y 2, esta unidad de Laboratorio proporciona una ruta para
experimentar en forma práctica cómo manejar excepciones, como usar las cláusulas

x
throw y catch aparte de dominar el uso de la cláusula throws. También permite al
estudiante aprender a escribir excepciones definidas de usuario.
Volumen 4: Facilidades de Entrada / Salida
Unidad 1: Archivos y Flujos
Esta unidad trata los conceptos File, FileDescriptor, flujos, flujos de caracteres,
flujos byte y acceso aleatorio de archivos.
Unidad 2: Laboratorio de Archivos y Flujos
Esta unidad provee un conjunto de ejercicios para aprender acerca de creación de
archivos, lectura y escritura desde y hacia archivos. También provee ejercicios para
acceder a directorios y subdirectorios.
Unidad 3: Serialización de Objetos
La serialización de Objetos es un tópico importante en Java y esta unidad trata sobre
ese tema, la interfaz Serializable, la interfaz Externalizable, la clase
ObjectOutputStream y la clase ObjectInputStream.
Unidad 4: Laboratorio de Serialización de Objetos
Esta unidad de laboratorio se construye sobre la base conceptual de la unidad 3 y le
permite al estudiante aprender a realizar la serialización de Objetos en Java.
Volumen 5: Crear Interfaces Usando AWT y Swing
Unidad 1: Componentes y Contenedores AWT
En esta unidad se discute el ‘abstract window toolkit –AWT- (grupo de programas de
ventana abstracta), algunas clases útiles en AWT y algunos componentes GUI en
AWT.
Unidad 2: Laboratorio de Componentes y Contenedores AWT
Este laboratorio le permite al estudiante aprender a usar varios controles que se
incluyen en el AWT, a crear y manejar ventanas y a usar las clases MenuBar, Menu y
FileDialog.
Unidad 3: Administradores de Diseño (Layout Managers)
Esta unidad ofrece una amplia cobertura de los manejadores de diseño y su selección.
Se discuten los diferentes administradores de diseño, sus responsabilidades y las reglas
para su aplicación y uso.

xi
Unidad 4: Laboratorio de Administradores de Diseño (Layout Managers)
En esta unidad de laboratorio, los estudiantes practican el uso de varios manejadores
de diseño y trabajan en la creación de varios controles como TextField, TextArea,
CheckboxGroup y Button.
Unidad 5: Modelo de Delegación de Eventos y Manejo de Eventos
Esta unidad examina el Modelo de Conducción de Eventos, los ‘Listeners’ (Oyentes) y
‘Adapters’ (Adaptadores). También provee una manera de implementar el mecanismo
de conducción de eventos.
Unidad 6: Laboratorio de Modelo de Delegación de Eventos y Manejo de
Eventos
En esta unidad de laboratorio el estudiante aprende el mecanismo de manejo de
eventos y el uso de la clase PopupMenu.
Unidad 7: Arquitectura MVC y Clases Swing
En esta unidad se discuten en gran detalle la arquitectura MVC y los componentes
Swing. La mayoría de los componentes se analizan en detalle, con ejemplos ilustrativos.
Unidad 8: Componentes Swing
Esta unidad trata con las clases swing, las propiedades look y feel (Apariencia) de
Swing y el API Java 2D. Se incluyen detalles de todas las clases y ejemplos dados.
Unidad 9: Laboratorio de Componentes Swing
En esta unidad de Laboratorio, se espera que los estudiantes entiendan el uso del
componente Swing y las características de las clases Swing.
Volumen 6: Applets
Unidad 1: Escribir y Desplegar Applets
En el lenguaje Java, los applets son uno de los tópicos más interesantes y significativos.
Esta unidad establece qué es un applet y lo que puede hacer. Provee un resumen de
los applets, su ciclo de vida y cada una de sus fases significativas. Se discuten los
métodos para responder a eventos (milestones), el uso de los métodos para dibujar y
manejar eventos, los métodos para añadir componentes UI y la aplicación y ventajas del
API en un applet.
Unidad 2: Laboratorio de Escribir y Desplegar Applets
En esta unidad, los estudiantes aprenden a desarrollar applets sencillos, los cuales
interactúan con el usuario y realizan comunicaciones entre applets a través del
programa Cliente-Servidor.

xii
Volumen 7: Multihilos y Sistema de Redes
Unidad 1: Crear Hilos
Java es conocido por su poder en términos de hilos. En esta unidad se discuten los
conceptos de hilos y multihilos (threads y multithreading), el ciclo de vida de los hilos, el
API Thread y el método de crear hilos de la clase Thread y la interfaz Runnable.
También se cubren propiedades especiales de los hilos como establecer prioridades y el
ThreadGroup.
Unidad 2: Laboratorio Crear Hilos
Esta unidad proporciona ejercicios para fortalecer la base conceptual presentada en la
unidad 1 de creación de hilos y ayudar a escribir programas que apliquen hilos en Java.
Unidad 3: Sincronización de Hilos
En esta unidad se examinan los conceptos de sincronización, métodos sincronizados y
sentencias sincronizadas. También se discuten los interbloqueos o puntos muertos
(deadlocks) y provee una visión de comunicación entre hilos.
Unidad 4: Laboratorio de Sincronización de Hilos
Esta unidad ha sido diseñada para bosquejar el entorno teórico en términos de
sincronización de hilos y reforzar el aprendizaje del uso de la sincronización de hilos en
la solución de problemas usando Java.
Unidad 5: URLs y Programación de Conectores (Sockets)
Esta unidad trata acerca del ‘Uniform Resource Locators –URLs’ (Localizadores de
Recursos Uniformes), la creación de un URL y la creación de un URL relativo a otro
URL. También se discuten los tópicos de MalformedURLException, cómo analizar un
URL, leyendo directamente desde un URL, cómo conectarse a un URL, cómo leer
desde un objeto URLConnection, y cómo escribir a un objeto URLConnection. Por
otra parte, abarca los diferentes modos de operaciones de socket, el modo orientado a
conexiones de operación de sockets, etc.
Unidad 6: Laboratorio de URLs y Programación de Conectores
Esta unidad de laboratorio permite a los estudiantes practicar el uso de Java trabajando
con URLs y realizar trabajos con conectores en el ámbito de programación.
Volumen 8: Conceptos Avanzados
Unidad 1: API de Colecciones
Esta unidad ayuda a entender el marco de trabajo de las colecciones de Java, las
interfaces de colecciones y el impacto que produjo la inclusión de los Genéricos en Java
5.0. También discute algunos algoritmos polimórficos de JDK operando en colecciones y
algunas implementaciones de colecciones.

xiii
Unidad 2: Laboratorio del API de Colecciones
Esta unidad proporciona ejercicios para ayudar a entender la interfaz collection,
cómo usar ArrayList, y el uso de las interfaces SortedSet, HashSet y TreeSet.
También ayuda a usar la clase iterator y sus métodos.
Unidad 3: JDBC
Esta unidad trata la conectividad de base de datos en Java y el API JDBC de Java.
Discute las sentencias SQL usadas en los programas de Java y cómo funciona el
manejo de excepciones.
Unidad 4: Laboratorio de JDBC
Existen algunos ejercicios en esta unidad para ayudar a los estudiantes a conectarse a
una base de datos a través de un programa Java, además de entender cómo acceder a
la base de datos una vez que se establece una conexión.
Unidad 5: JDBC Avanzado
Se explican algunos conceptos avanzados de JDBC tales como usar las clases
heredadas de Statement, procedimientos almacenados (stored procedures) y otras
funcionalidades JDBC, como por ejemplo el manejo de transacciones.
Unidad 6: Laboratorio de JDBC Avanzado
Esta unidad permite al estudiante escribir código en Java para crear y usar los
procedimientos almacenados, además de facilitar la comprensión acerca de la forma en
que trabaja la administración de transacciones.
Unidad 7: Características Avanzadas
En esta unidad, los objetivos consisten en la capacitación del trabajo con imágenes y
gráficos, incorporar elementos de seguridad mientras se trabaja con programas en Java
y aprender el concepto de internacionalización en Java. También se explican los Java
beans y cómo realizar la invocación remota de métodos.
Unidad 8: Laboratorio de Características Avanzadas
En esta unidad, los estudiantes aprenderán a convertir un programa Java usando
internacionalización y trabajarán con la invocación de métodos remotos.

Libro 1: Core Java Volumen 1: Fundamentos de Java 1
Volumen 1: Fundamentos de Java

Unidad 1: Visión General de Java
Objetivos del Aprendizaje
Al final de esta unidad, usted será capaz de:
• Discutir la evolución de Java.
• Comparar Java con C++.
• Discutir las características principales de Java.
• Explicar la plataforma Java.
• Describir el impacto de Java en WWW.
• Definir clases y objetos.

Unidad 1: Visión General de Java Libro 1: Core Java 4
1. Introducción
Antes que Java existiera, C y C++ eran los lenguajes de programación más usados. C
es un lenguaje de programación estructurada, mientras que C++ brinda soporte tanto a
la programación estructurada como a la programación orientada a objetos. Estos dos
lenguajes de programación son complejos y tienen algunas limitaciones inherentes.
Aunque Java no fue diseñado como solución a los problemas encontrados en C o C++,
algunas de sus características han solventado las limitaciones de estos dos lenguajes.
Uno de los objetivos principales detrás de la creación de Java fue tener un lenguaje
orientado a objetos que fuera poderoso, pero simple. Java ha simplificado muchas de
las estructuras complicadas y ambiguas de C++. Otra ventaja fundamental es que Java
trajo el concepto de la independencia de plataforma. Se aprenderá acerca de estas
características en detalle en las próximas secciones.
Sin embargo, antes de continuar, se presenta un breve resumen de la evolución de
Java.
2. Historia de Java
Patrick Naughton, Mike Sheridan y James Gosling de SUN Microsystems iniciaron un
proyecto secreto llamado "Proyecto Verde" (Green Project) a finales de 1990. El objetivo
de este proyecto era anticiparse a la revolución en el mundo de la computación que
estaba por llegar. El equipo decidió intentar introducirse en el mercado de la electrónica
de consumo y desarrollar programas para pequeños dispositivos electrónicos.
Desarrollaron un dispositivo llamado StarSeven (*7), este dispositivo era capaz de
controlar una variedad de plataformas de entretenimiento y dispositivos de uso
doméstico, además de mostrar animaciones simultáneamente. *7 usaba un procesador
independiente del lenguaje llamado Oak para adaptarse a una variedad de plataformas
y dispositivos de uso doméstico. Tras unos comienzos dudosos, Sun decidió crear una
filial, denominada FirstPerson Inc., para dar margen de maniobra al equipo responsable
del proyecto. Este grupo intentó mercadear él *7 a la industria de televisión por cable,
pero la tecnología usada para desarrollar él *7 estaba adelantada a la tecnología
existente en la industria de televisión por cable y por esto no fue aceptado.
Afortunadamente para el grupo creador del *7, Internet se estaba volviendo popular en
ese momento. La Internet tenía una configuración de red similar al *7, y estaba siendo
usada cada vez más para la transferencia de texto, gráficos y video, esencialmente
datos estáticos. El equipo FirstPerson amplió Oak, transformándolo en un lenguaje que
permitía al programador escribir programas que corrían en una gran variedad de
dispositivos, a un lenguaje que permitía escribir código ejecutable que podía ser
distribuido en Internet.
En el año 1995, este nuevo lenguaje evolucionado fue llamado Java. Java permitía a los
usuarios de Internet transferir contenido estático a través de la misma. Adicionalmente,
permitía transferir pequeñas aplicaciones dinámicas a través de la red en la forma de
applets de Java. Algunos de los miembros del grupo FirstPerson mostraron el lenguaje

y sus nuevas características, incluyendo la transferencia de animaciones a través de la
Internet, en la Conferencia de Diseño, Tecnología y Entretenimiento en Monterrey.
Sus características y funcionalidades asombraron a los participantes, ya que la
tecnología proveía un método más sencillo para transferir datos en la Internet. El equipo
pronto construyó el navegador HotJava, y publicó el código fuente Java gratuitamente
en Internet. En poco tiempo, el número de usuarios de la tecnología Java se incrementó
rápidamente.
A continuación se va a comparar Java y C++, ambos lenguajes de programación
orientado a objetos, para descubrir que ha hecho a Java tan popular.
3. Comparación entre Java y C++
Java simplifica muchas de las ambigüedades encontradas en C++, y es, al mismo
tiempo, un lenguaje de programación igualmente poderoso. Se ha visto con anterioridad
las ventajas del paradigma de programación orientada a objetos.
Existen algunas deficiencias en C++, por el hecho de que permite programación
estructurada. Esto ha sido eliminado en Java, que es un lenguaje puramente orientado
a objetos.
Las principales diferencias entre C++ y Java se listan en la Tabla 1.1.
Java C++
Es tanto un lenguaje de programación
como una plataforma de software.
Es sólo un lenguaje de programación.
Es un lenguaje puramente orientado
a objetos.
Da soporte tanto a la programación estructurada
como a la programación orientada a objetos.
Todas las declaraciones de variables
y métodos deben estar dentro de la
definición de la clase.
Las declaraciones de variables y funciones
pueden estar presentes fuera de las definiciones
de las clases. No es necesario para un programa
en C++ tener una clase.
El lenguaje es independiente de la
plataforma. El código Java, una vez
escrito, puede ser ejecutado en
cualquier plataforma.
El código C++, una vez escrito para una
plataforma, necesita ser compilado de nuevo, y
el código objeto reenlazado para ser ejecutado
en otra plataforma diferente.
Maneja la memoria automáticamente.
Los programadores tienen que hacerse cargo de
liberar la memoria no utilizada.
No se soporta características como
sobrecarga de operadores y
conversiones automáticas en ambos
sentidos.
Da soporte a características como sobrecarga de
operadores y conversiones automáticas en
ambos sentidos.
Una clase no puede heredar
directamente de más de una clase.
Se da soporte a la herencia múltiple
usando interfaces.
Una clase puede heredar directamente de más
de una clase.
Tiene rutinas de librerías extensibles. Sus rutinas de librerías no son extensibles.

La programación de redes es más
fácil. Los objetos pueden ser
accedidos a través de la red usando
URLs.
La programación para redes es compleja, a
menos que se usen APIs de terceros. C++, es un
lenguaje, que no brinda soporte incorporado para
programación de redes.
Los programadores no pueden usar
apuntadores. Los apuntadores se
usan internamente.
Los programadores pueden usar apuntadores.
Implementa arreglos verdaderos.
Se implementan los arreglos con aritmética de
apuntadores.
Tabla 1.1: Comparación entre C++ y Java
Aunque las construcciones de programación de Java (sintaxis) son similares a las de
C++, Java no debe ser interpretado como la versión Internet de C++, ni como un
reemplazo para C++. El equipo FirstPerson contó con programadores expertos para
asegurar que Java permitiera a los programadores tener un control completo sobre la
ejecución del programa, excepto por las restricciones inherentes al ambiente de
Internet.
Ahora se estudiarán las diversas características ofrecidas por Java.
4. Características de Java
Java puede usarse para desarrollar dos tipos de programas:
Aplicaciones: Las aplicaciones son programas independientes que pueden correr en
una computadora, usando la plataforma Java con el soporte del sistema operativo de la
computadora.
Applets: Los applets son programas especiales Java, que pueden usarse para
transmitir información en Internet.
Los applets pueden ser incrustados en una página HTML usando la etiqueta Applet, y
pueden ejecutarse en un navegador web con soporte para Java. Los applets pueden
adaptarse a la entrada del usuario inteligentemente. Las aplicaciones Java y los applets
pueden ser compilados y ejecutados usando el Kit de Desarrollo de Java (Java
Development Kit JDK).
La Figura 1.1 muestra las diferentes características de Java.

Figura 1.1: Características de Java
4.1 Simple de Usar
El estilo de programación en Java está basado en C++, y soporta la mayoría de las
características ofrecidas por C++. De aquí que, los programadores no encontrarán Java
muy difícil de entender y usar. Un programador con un buen conocimiento de los
conceptos de orientado a objetos puede sacar el máximo provecho a Java, ya que se
implementan los conceptos en una forma mucho más sencilla que en C++.
4.2 Seguridad
Inicialmente, cuando la Internet comenzó y Java no era tan conocido, los usuarios de
Internet temían descargar programas ejecutables debido al daño alarmante causado por
la difusión de virus. Las personas que descargaban archivos eran muy cautelosas de
revisar estos archivos cuidadosamente antes de usarlos. Había también programas
maliciosos que recababan información acerca de tarjetas de crédito, palabras clave, etc.
del sistema de archivos local. Esto fue, por supuesto, desastroso para las personas que
navegan por la Internet. Java proporcionó un modelo de seguridad, que previene el
acceso a los recursos del sistema, y así bloquear cualquier intento malicioso.
4.3 Portabilidad
Existen muchas ocasiones en donde los usuarios de Internet pueden querer descargar
programas y ejecutarlos dinámicamente. Los usuarios pueden estar usando diferentes

tipos de plataformas, para permitirles descargar programas y ejecutarlos
dinámicamente, se necesita de un mecanismo para crear código ejecutable que sea
portable entre varias plataformas.
Java solventa este inconveniente de portabilidad con el uso de bytecodes. El compilador
Java (javac) primero convierte el código fuente (archivo con extensión .java) a
bytecodes (archivo con extensión .class), que puede entender el sistema de tiempo
de ejecución de Java o la Máquina Virtual de Java (Java Virtual Machine JVM); estos
bytecodes son interpretados por el intérprete de Java, y convertidos a una forma
ejecutable que la entiende la plataforma en la cual el sistema de tiempo de ejecución de
Java se está ejecutando.
El ambiente de tiempo de ejecución de Java es el ambiente en donde es posible que los
programas puedan ser compilados y ejecutados. Este ambiente administra el manejo de
la memoria y otras necesidades en tiempo de ejecución durante la ejecución del
programa. La Máquina Virtual de Java (JVM) es la capa entre el microprocesador y los
archivos class de Java. Realiza la funcionalidad de traducir los bytecodes de Java, a
una forma entendible por la máquina.
Existe otro componente llamado el compilador ‘Just-In-Time (JIT)’. El compilador JIT
compila los bytecodes a código máquina, haciéndolos más rápidos que la interpretación
hecha por la JVM.
El sistema de tiempo de ejecución de Java es específico a la plataforma en la cual se
ejecuta. Java soporta la portabilidad, porque los bytecodes son interpretados antes de la
ejecución. La Figura 1.2, explica cómo Java logra la portabilidad.
Figura 1.2: JVM e Independencia de la Plataforma

El sistema de tiempo de ejecución Java previene que el código acceda a cualquier
recurso fuera de él. De este modo, el sistema de tiempo de ejecución mejora las
características de seguridad ya provistas por Java. Los bytecodes de Java también son
útiles al mejorar el nivel de seguridad ofrecido por Java. Aún si Java hubiese sido
diseñado para ser compilado justo antes de la ejecución, en vez de ser interpretado
como actualmente lo es, soportaría la portabilidad. Esto se debe a que la ejecución del
programa está todavía en manos del sistema de tiempo de ejecución de Java. Este
método de compilación usado para convertir bytecodes a código nativo se llama
compilación ‘justo a tiempo’ (Just In Time JIT).
La Figura 1.3 muestra como trabaja el compilador JIT.
Figura 1.3: Compilador JIT y la JVM
4.4 Distribuido
La computación distribuida es muy útil en el ambiente de la Internet, donde los módulos
de los programas pueden estar presentes en diferentes computadoras alrededor del
mundo. Java fue diseñado para brindar soporte TCP/IP. El soporte a redes de Java
permite construir aplicaciones cliente/servidor, adicionalmente Java tiene el paquete de
Invocación de Métodos Remota (Remote Method Invocation RMI). Este permite a
programas que se ejecutan en una JVM invocar un método en una clase Java
ejecutándose en otra JVM.
4.5 Orientado a Objetos
C++ tenía que mantener las características y ser compatible con C. Cuando Java
estaba siendo diseñado, sus diseñadores y desarrolladores no quisieron que Java fuera
compatible al nivel de código fuente con ningún otro lenguaje. Por lo anterior, tuvieron la
opción de crear un lenguaje orientado a objetos que hace uso de un modelo de objetos
simple, y usa tipos de datos simples no objetos, asegurando un alto rendimiento.
4.6 Robusto
A medida que los usuarios de Java en Internet comenzaron a incrementarse en número,
creció también la necesidad de ejecutar una aplicación en diversas plataformas. Estas
plataformas diversas tenían demandas diferentes por parte de las aplicaciones para que
se ejecutaran apropiadamente y por tanto, la aplicación tenía que ocuparse de todas
estas demandas. Para poder hacer esto, la aplicación debía de ser robusta

El diseño de Java hace posible que los programadores identifiquen errores en la misma
etapa de desarrollo. El código puede ser revisado para asegurar confiabilidad colocando
restricciones en ciertas áreas claves de la programación y teniendo un diseño para
evitar los errores más comunes de programación. Java está diseñado para ser un
lenguaje estrictamente tipado, Por lo tanto, verifica errores de codificación tanto en
tiempo de compilación como en tiempo de ejecución.
Java provee manejo de excepciones para ocuparse de los errores de una manera
sofisticada. La robustez del manejo de excepciones de Java ayuda a construir
programas confiables. Funciones como la recolección automática de basura en Java
hace que los programas sean menos propensos a errores relacionados con la memoria.
Esto a su vez da seguridad a los programadores para predecir el comportamiento del
programa en diversas situaciones.
4.7 Dinámico
Java enlaza el código dinámicamente. Java fue implementado para usar los datos
disponibles en los archivos class en tiempo de ejecución. Los objetos que se crean y
usan en un programa son verificados y resueltos en tiempo de ejecución. Esta
característica es útil cuando se quiere actualizar el bytecode en un sistema en
ejecución.
4.8 Fuertemente Tipificado
Java es fuertemente tipificado. Java fue diseñado de forma que si se comete cualquier
error en una invocación de método, se mostrará un mensaje de error al programador en
tiempo de compilación. Por esta razón, los programadores no necesitan preocuparse de
cometer errores no detectables en las invocaciones de métodos.
4.9 Interpretado
Los bytecodes de Java son interpretados por la JVM en el lenguaje nativo de la
plataforma subyacente. Los lenguajes interpretados tienen limitaciones de rendimiento
comparados con los lenguajes que son compilados. Java combina las ventajas de la
compilación e interpretación. El compilador Java JIT puede ayudar a superar las
limitaciones de rendimiento asociadas a la JVM.
4.10 Arquitectura Neutral
Al compilar un programa en Java, el código resultante es un tipo de código binario
conocido como bytecode. Este código es interpretado por diferentes computadoras de
igual manera, solamente hay que implementar un intérprete para cada plataforma. De
esa manera Java logra ser un lenguaje que no depende de una arquitectura
computacional definida.

4.11 Ambiente Multihilos
Java brinda soporte a la programación multihilos, que permite que un único programa
lleve a cabo varias tareas concurrentemente. Los programadores pueden hacer uso de
esto para crear aplicaciones de red interactivas. El sistema en tiempo de ejecución de
Java (JVM) se implementó de forma eficiente, para permitir la fácil sincronización de
hilos, que a su vez facilitan la programación interactiva.
Ahora que se conocen las características principales de Java, se discute a continuación
la plataforma de Java.
5. La Plataforma Java
Una plataforma es el entorno sobre el cual se ejecutan los programas. Una plataforma
puede ser una plataforma de software, una plataforma de hardware o una combinación
de ambos. La plataforma Java es una plataforma de sólo software, la cual se puede
ejecutar en varias plataformas de hardware así como en varios sistemas de operativos.
La plataforma Java esta conformada por dos componentes, llamados la JVM y el API de
Java, como se muestra en la Figura 1.4.
Figura 1.4: Los dos Componentes de la Plataforma Java
5.1 JVM
La JVM es una aplicación ejecutable que representa a un procesador genérico en el
cual corren los bytecodes de Java. Una implementación particular de esta máquina
virtual, que es escrita para operar en un entorno particular, aún brindará soporte al API
general de Java. Esto es lo que hace a Java independiente de la plataforma.

La JVM consta de los siguientes tres aspectos:
• Especificación abstracta.
• Implementación concreta.
• Instancia en tiempo de ejecución.
Esto se muestra en la Figura 1.5.
Figura 1.5: Diferentes Aspectos de la JVM
La especificación Java define la especificación abstracta de la JVM, que se necesita
para permitir que los programas se ejecuten en ella. La implementación concreta de la
JVM es la implementación actual de la especificación abstracta. La instancia de tiempo
de ejecución (la instancia de una JVM que está en ejecución actualmente) soporta la
ejecución de los programas Java. El código fuente de Java (archivo .java) es
convertido en bytecodes (archivo .class) por el compilador Java. Estos bytecodes son
luego convertidos a código de máquina nativo por alguna JVM que sea específica a una
plataforma en particular. De aquí que, los archivos .class son portables a cualquier
implementación de la máquina virtual.
Para entender la diferencia entre los archivos .java y .class, se va a mostrar
brevemente el flujo de un programa Java.

• El código fuente Java se ingresa usando un editor.
• El comando javac se usa para iniciar el compilador Java, que compila el código
fuente Java (archivo .java) a bytecodes, suponiendo que no hay errores en
tiempo de compilación. Si existe un error, el programador debe regresar al
editor, corregir los problemas, y ejecutar nuevamente javac hasta que todos los
errores sean solucionados y se obtenga una compilación limpia.
• Una vez compilado, se produce un archivo .class que podrá ser usado con
cualquier JVM ejecutándose en cualquier plataforma.
• El comando java se usa para iniciar el intérprete Java, y para ejecutar el archivo
.class.
Se ha discutido que los bytecodes Java obtenidos después de la compilación en
cualquier JVM pueden ser transferidos a cualquier otra JVM ejecutándose en cualquier
otra plataforma y ser ejecutado allí. Esta característica ayudará a los usuarios a
descargar bytecodes Java de la Internet y ejecutarlos en sus JVM sin riesgos de
seguridad. Sin embargo, hay un pequeño problema, los bytecodes descargados no
tienen que haber sido producidos por un compilador Java estándar, por lo que estos
bytecodes pueden estar erróneos.
Para resolver este problema, una vez que el bytecode sea descargado, la JVM en la
máquina del usuario inicia un proceso de verificación del bytecode. Durante este
proceso, los fragmentos del bytecode son probados para verificar su validez. Se revisa
cualquier manipulación ilegal de apuntadores, violación de restricciones colocadas para
acceder a las variables y métodos de las clases, uso ilegal de objetos, etc. Si no se
encuentran ninguna de las violaciones anteriores, y si el bytecode descargado pasa
todas las otras pruebas que el verificador impone, entonces el bytecode es tratado
como un código confiable.
Actualmente, el verificador de bytecode no realiza ninguna suposición acerca del
bytecode que recibe. El bytecode puede provenir del sistema local o haber sido
descargado de la Internet. Sin importar la fuente, el bytecode es objeto del mismo
proceso de verificación; esto asegura la confiabilidad del código y también protege al
intérprete Java. Dado que la confiabilidad del código fue verificada, el intérprete Java
opera a toda capacidad sin tener que revisar cualquier aspecto de seguridad.
Cuando surge un aspecto vinculado con la seguridad en Java, el administrador de
seguridad de Java juega un papel fundamental. El administrador de seguridad (clase
java.lang.SecurityManager) es una clase definida en Java, que permite a las
aplicaciones Java implementar una política apropiada de seguridad. Cuando una
aplicación Java implementa esta política de seguridad, tiene la capacidad de
determinar si la operación que está a punto de realizarse, es una operación insegura o
sensible. También se pueden obtener más detalles de la operación, y si la operación se
realiza dentro de un contexto de seguridad que permita a la aplicación llevar a cabo esa
operación.
El modelo de seguridad de Java provee una ‘caja de arena’ (sandbox) que es
configurable, ésta protege a las aplicaciones y applets Java de ser atacados por virus,

que son difundidos a través de programas descargados de máquinas no confiables. Las
aplicaciones y applets Java pueden realizar cualquier operación que este bajo la
supervisión de la caja de arena y nada más. En este modelo de caja de arena, las
aplicaciones y applets Java pueden descargar cualquier código de cualquier máquina.
El código no se revisa por virus, porque mientras se ejecuta el código, la caja de arena
revisa si viene de una máquina confiable o no.
Si el código proviene de una máquina no confiable, se evita realizar cualquier operación
que pueda dañar al sistema. La ventaja del modelo de caja de arena es que la
aplicación Java no necesita revisar si el código es confiable, ni necesita revisar por virus
en el código. La caja de arena evita que un virus o código no confiable realicen
operaciones maliciosas.
La caja de arena de Java incluye las características de seguridad provistas por la JVM,
el administrador de seguridad, el cargador de clases y el verificador de archivos class.
La caja de arena se puede personalizar en dos de sus componentes, son estos: el
administrador de seguridad y el cargador de clases. El administrador de seguridad
puede ser personalizado al escribir clases definidas por el usuario. Las clases definidas
por el usuario pueden ser creadas derivando de la clase
java.lang.SecurityManager y sobrescribiendo los métodos necesarios. Estos
administradores de seguridad personalizados son útiles cuando se quieren cargar
clases que no son completamente confiables. No se tienen que escribir nuestra propia
caja de arena personalizada para las aplicaciones y applets Java que se escriben día a
día, simplemente se puede usar las cajas de arena estándar que otros crean. Si se
quiere ejecutar un applet en un navegador Web, por ejemplo, se usa la caja de arena
que viene con el navegador Web.
A continuación se discute el cargador de clases que es el otro componente que puede
personalizarse de la caja de arena, El cargador de clases carga las clases en la JVM.
Los cargadores de clases pueden ser de dos tipos:
• Cargador de Clases Primordial.
• Objetos Cargadores de Clases.
El cargador de clases primordial es actualmente una parte de la implementación de la
JVM, mientras que el objeto cargador de clase es un objeto que se usa para cargar una
clase. El cargador de clases primordial carga solamente clases confiables, incluyendo
las clases definidas en el API Java que están disponibles en el sistema local. Es posible
escribir objetos cargadores de clases propios, que pueden ser personalizados para
cargar clases específicas. El cargador de clases primordial en principio no confía de las
clases cargadas por estos objetos cargadores de clases. Actualmente, estos objetos
cargadores de clases son sólo aplicaciones Java que se ejecutan en la JVM.
Considere una clase MiClase que es cargada por un objeto cargador de clases.
Asuma que MiClase carga otras clases tales como OtraClase1 y OtraClase2.
Estas dos clases son actualmente cargadas a través del mismo cargador de clases que
ha cargado a MiClase.

En Java, las clases son agrupadas dentro de paquetes, es decir, cada paquete tiene un
conjunto de clases. El término espacio de nombres se refiere a la entidad que mantiene
los nombres de las clases. Java usa paquetes para este propósito. Dentro de un
espacio de nombres en particular, sólo puede existir una clase con un nombre dado. Sin
embargo, puede existir cualquier número de cargadores de clases dentro de una JVM.
Cada cargador de clases puede estar asociado a un espacio de nombre diferente. La
misma clase puede ser cargada a través de diferentes cargadores de clases que están
asociados a diferentes espacios de nombres. No puede haber ninguna interacción entre
cargadores de clases que están presentes en diferentes espacios de nombres, a menos
que el cargador de clase expresamente permita esa interacción.
Se pueden diferenciar las clases descargadas de la red desde diferentes máquinas en
diferentes espacios de nombres. A estas clases se les restringirá el acceso a otra clase
que esté en un nombre de espacios diferente. Así, se puede usar esta arquitectura de
cargador de clase para evitar cualquier daño causado por código malicioso.
5.2 El API de Java
El API (Application Programming Interface) de Java es una muy buena colección de
componentes de software apropiadas para el desarrollo de programas Java. En Java
hay diferentes tipos de programas tales como aplicaciones, applets y Servlets. El API de
Java ayuda al desarrollo y ejecución de estos diferentes tipos de programas mediante
una amplia librería. El soporte de las diversas características de Java se realiza a través
del API. Éstas son básicamente librerías o paquetes de componentes relacionados. La
Figura 1.6 muestra las características provistas por el núcleo del API de Java.
Figura 1.6: Características Provistas por el Núcleo del API Java

Se ha visto cómo Java evolucionó como una aplicación de Internet. A continuación se
discute el impacto que Java ha tenido sobre Internet y la WWW.
6. Impacto de Java en la WWW
Los usuarios de la WWW hacen uso de varios tipos de máquinas, y tienen diferentes
plataformas. Así que el problema clave es hacer que la información en la Internet sea
compatible con todas las plataformas. Debido a que Java permite la portabilidad, se
logra este punto. Usando la característica de portabilidad, el mismo programa puede ser
ejecutado en diferentes plataformas, con resultados predecibles. La información no
necesita ser replicada para soportar diferentes plataformas.
El otro tema principal de los usuarios de la WWW enfrentan es la seguridad. Debido a la
amplia difusión de los virus y programas que pueden capturar información como
palabras claves y detalles de las tarjetas de crédito del sistema de archivos local, los
usuarios hasta hace poco, estaban temerosos de descargar cualquier programa
ejecutable desde máquinas no confiables.
Los programas Java no tienen permiso de acceder a cualquier recurso fuera del alcance
de la JVM. Por esto, la JVM controla los intentos de romper la seguridad a través de
programas Java.
Java también hace la programación de aplicaciones interactivas muy fácil, las cuales se
usan en muchos portales en Internet para atraer clientes.
Java comenzó de una manera modesta al permitir que los programas se ejecutaran en
la Internet usando los applets de Java. Sin embargo, esto ha crecido hasta alcanzar un
mayor poder de funcionalidad. Existen varias tecnologías basadas en Java que se usan
para obtener funcionalidades especializadas. Por ejemplo, tecnologías como los Java
Servlets, Java Server Pages (JSP), Enterprise Java Beans (EJB), etc., han otorgado al
programador mucho más poder para construir aplicaciones robustas y escalables para
Internet.
Considere la Figura 1.7, la cual muestra como las diferentes tecnologías Java se usan
para alcanzar varias funcionalidades en un ambiente Internet.

Figura 1.7: Tecnologías Java en Internet
Nota: Todas las tecnologías listadas en la Figura 1.7, excepto la tecnología applet,
están basadas en la ejecución sobre la JVM de una máquina en vez de la JVM de un
navegador. Por lo tanto, sólo los applets tienen restricciones en acceder los recursos del
sistema fuera de la JVM.
A continuación se estudian las diferentes clases y objetos en Java.
7. Clases y Objetos
Una clase es un prototipo que se usa para definir las características y los
comportamientos que son comunes a todos los objetos de un mismo tipo. Las variables
se usan para representar las características de los objetos y los métodos se usan para
representar el comportamiento de los objetos. Se puede declarar una variable
especificando su tipo de datos y el nombre de la variable.
Similarmente, se puede declarar objetos especificando lo siguiente:
• Tipo (nombre de clase).
• Nombre de Objeto.
int a;
Computador comp;

En el fragmento de código anterior, a es el nombre de la variable, e int es su tipo de
datos. Similarmente, comp es el nombre del objeto, y Computador es el tipo del objeto,
es decir, el nombre de la clase. Se pueden declarar muchas variables del mismo tipo de
datos. Similarmente, se pueden declarar muchos objetos del mismo tipo (muchos
objetos de la misma clase).
La Figura 1.8, muestra más de un objeto de una misma clase.
Figura 1.8: Clases y Objetos Java
La Figura 1.8 muestra una clase llamada Cliente y objetos con los nombres ObjetoA,
ObjetoB y ObjetoC de este tipo. La clase Cliente es una representación orientada a
objetos del cliente del mundo real, mantiene los datos del cliente. Típicamente, la clase
tendrá variables miembro para mantener información, como el ID del cliente, el nombre
del cliente, etc.
Se define una clase en Java usando la palabra reservada class. La sintaxis es la
siguiente:
class NombreClase {
// variables miembro
// funciones miembro
}

Considere la clase Computador, que tiene los atributos cpu, monitor, teclado y
mouse. Se pueden crear dos instancias de la clase Computador que tengan diferentes
valores para estos atributos. Estas dos instancias están representadas por comp1 y
comp2.
Los objetos en Java se crean usando la palabra clave new.
La sintaxis es la siguiente:
NombreClase objecto = new NombreClase();
Los constructores en Java tienen la misma funcionalidad que en C++. Los constructores
en Java pueden aceptar nombres de variables y tipos de variables como argumentos.
A su vez, como en C y C++, donde la función main() es el punto de inicio del
programa, se tiene que main() es el punto de inicio del programa Java también.
La función main() tiene la siguiente declaración de función:
public static void main(String args[]){
// El código principal va aquí
}
Así como en C y C++, los programas Java pueden aceptar parámetros por la línea de
comandos, el main()de Java puede tomar estos argumentos. En C o C++, se pueden
tener parámetros de la línea de comandos usando int argc y char* argv[]. En
Java, se toman como un arreglo de objetos String. Además, mientras en C o C++ es
opcional para la función main() tomar argumentos desde la línea de comandos, es
obligatorio que los argumentos de la línea de comandos estén declarados en la función
main() de Java.
Nota: La función main() en Java no puede ser global, como en C o C++. En Java,
debe estar presente dentro de una clase Java.
La palabra clave public es un tipo de especificador de acceso en Java. Se verán otros
tipos de especificadores de acceso en el Volumen 2, Unidad 1 - Clases, Objetos y
Referencias.
Las variables miembro son conocidos como miembros, y las funciones miembros como
los métodos de una clase. No se puede tener la declaración de la clase separada, y la
definición de la función miembro apareciendo libremente, como en C++. Ambos deben
aparecer dentro del bloque de definición de la clase.
Observe el Ejemplo 1.1, que tiene el código Java para la clase Computador. En este
momento, la sintaxis del código no es importante, dado que el punto ahora es entender
la relación entre clases y objetos.

Ejemplo 1. 1
El siguiente programa representa una computadora.
El código Java comienza aquí...
1. /*Definicion de la clase Computador comienza aqui*/
2. class Computador {
3. boolean cpu, teclado, mouse;
4. String monitor;
5. }/*Definicion de la clase Computador termina aqui*/
6.
7. /*Definicion de la clase ComputadorEjemplo comienza aqui*/
8. public class ComputadorEjemplo {
9. /*El metodo main comienza aqui */
10. public static void main(String[] args) {
11. //Crear la instancia de la clase Computer
12. Computador comp1 = new Computador();
13. Computador comp2 = new Computador();
14.
15. comp1.cpu = true;
16. comp1.monitor = "Negro";
17. comp1.teclado = true;
18. comp1.mouse = true;
19.
20. comp2.cpu = true;
21. comp2.monitor = "Blanco y negro";
22. comp2.teclado = true;
23. comp2.mouse = false;
24. }/* El metodo main termina aqui */
25. }/*Definicion de la clase ComputadorEjemplo termina aqui*/
El código Java termina aquí
Fin del Ejemplo 1.1
Aquí, se tienen dos clases, Computador y ComputadorEjemplo. La clase
Computador define el prototipo para un conjunto de objetos que tienen los mismos
atributos. La clase ComputadorEjemplo crea dos objetos de tipo Computador, y

también se muestra que estos dos objetos pueden contener diferentes valores para sus
atributos.
Considere la Figura 1.9 para entender mejor el código anterior.
Figura 1.9: Múltiples Objetos de una Clase
A continuación se discuten los principios de la programación orientada a objetos usados
en Java.
8. Orientación a Objetos en Java
Se sabe que Java brinda soporte a la programación orientada a objetos. En la
programación orientada a objetos, los programadores crean objetos de software, que
son modelados como los objetos del mundo real. Se describen los objetos del mundo
real usando sus atributos y comportamiento. Similarmente se describen los objetos de
software usando variables y métodos. Se tiene un prototipo a partir del cual se crean
objetos del mismo tipo del mundo real. Similarmente, se tiene un prototipo llamado
clase, de la cual se pueden crear muchos objetos de software del mismo tipo. Java
implementa la orientación a objetos a través de tres importantes propiedades, que son:

• Encapsulación.
• Herencia.
• Polimorfismo.
A continuación se discuten en detalle cada uno de ellos.
8.1 Encapsulación
La capacidad de presentación de información dentro de un objeto se divide en dos
partes bien diferenciadas:
• Interna: la información que necesita el objeto para operar y que es innecesaria
para los demás objetos de la aplicación. Estos atributos se denominan privados
y tienen como marco de aplicación únicamente a las operaciones asociadas al
objeto.
• Externa La que necesitan el resto de los objetos para interactuar con el objeto
que definimos. Estas propiedades se denominan públicas y corresponde a la
información que necesitan conocer los restantes objetos de la aplicación
respecto del objeto definido para poder operar.
Se puede imaginar la encapsulación como introducir el objeto dentro de una caja negra
donde existen dos ranuras denominadas entrada y salida. Si se introducen datos por la
entrada automáticamente obtendrá un resultado en la salida. No necesita conocer
ningún detalle del funcionamiento interno de la caja.
El término encapsulación indica la capacidad que tienen los objetos de construir una
cápsula a su alrededor, ocultando la información que contienen (aquella que es
necesaria para su funcionamiento interno, pero innecesaria para los demás objetos) a
las otras clases que componen la aplicación.
Esto se ilustra en la Figura 1.10.

Figura 1.10: Encapsulación en una Clase
Esta característica está disponible en Java y se llama encapsulación.
Tome el ejemplo de un ATM, telecajero. Se puede ir a un ATM a retirar dinero, revisar el
saldo de una cuenta, y depositar dinero. Estas son las funcionalidades proporcionadas a
los usuarios. Ellos no saben cómo estas funcionalidades están implementadas, y no
están preocupados por la implementación. Los usuarios pueden acceder a la
información pertinente solo a sus cuentas. Ellos no pueden acceder a la información de
otros usuarios, a los usuarios no se les da acceso a saber cómo trabaja el ATM.
Considere la Figura 1.11, que muestra como la encapsulación se lleva a cabo en una
clase Java. La clase que se muestra es Direccion. Un objeto Direccion es
instanciado y un método es invocado. El código que es privado en la clase Direccion
no es visible para la clase ServicioCliente.

Figura 1.11: Encapsulación en el Objeto Direccion
8.2 Herencia
Considere el ejemplo de un profesor de física y uno de matemáticas. Ambos pertenecen
a una categoría general llamada profesores. Ellos tienen ciertos atributos y
comportamiento que son comunes a todos los profesores. Adicionalmente, ellos tienen
ciertos atributos especiales que son comunes a todos los profesores de física y
matemáticas. Cuando se modela este ejemplo usando objetos de software, se puede
tener una clase llamada Profesor que defina todos los atributos y comportamiento
comunes a todos los profesores. Subsecuentemente, se pueden definir dos clases
ProfesorFisica y ProfesorMatematica, que hereden los atributos y
comportamiento comunes a todos los profesores, desde la clase Profesor. En este
caso, la clase Profesor será la súper clase de las clases ProfesorFisica y
ProfesorMatematica y estas serán subclases de la clase Profesor.
Algunos lenguajes como C++, permiten la herencia múltiple en la cual una clase puede
heredar de varias clases. En Java, una clase sólo puede tener una súper clase. Esto
significa que una clase en Java no puede directamente derivar de varias clases. Sin
embargo, Java soporta herencia múltiple indirectamente usando interfaces. Las
interfaces serán tratadas en detalle en el Volumen 1, Unidad 5 – Clases Abstractas e
Interfaces.
La Figura 1.12 muestra un ejemplo de herencia. De esta figura, se puede deducir que
Bicicleta, MonoPatin y Moto tienen propiedades que son comunes a todos los

vehículos de dos ruedas, mientras que Carro, Autobus y Camion tienen propiedades
que son comunes a todos los vehículos de cuatro ruedas. Además, los vehículos de dos
y cuatro ruedas, a su vez, tienen propiedades que son comunes a los vehículos.
Figura 1.12: Herencia: Clases Como Especialización de la SuperClase Vehiculo
8.3 Polimorfismo
Se pueden tener muchas situaciones cuando se quieren hacer varias operaciones
similares unas con otras dependiendo de la entrada que se obtenga. Esto se denomina
polimorfismo, formado de dos raíces griegas, ‘poly’ y ‘morphus’. La palabra ‘poly’
significa muchos y 'morphus' significa formas.
En programación orientada a objetos, polimorfismo significa una sola interfaz y múltiples
implementaciones. En otras palabras, los nombres de métodos son los mismos, pero
tienen diferentes implementaciones basadas en los parámetros que le son pasados, o
en los objetos sobre los cuales son invocados.
Suponga que se desea implementar a la clase Mamiferos, suponga también que uno
de los métodos que se desea implementar para esta clase, es el que permita a tales
mamíferos desplazarse de forma natural, a este método se le llamará desplazar().
Se encontrará entonces conque para algunos mamíferos el desplazamiento se realizará
por medio de caminar, como es en el caso de las personas, para otros el
desplazamiento natural será nadar, como en el caso de los delfines e inclusive para
otros, el desplazamiento se logrará por medio de volar, como sucede con los
murciélagos. Se usa el mismo nombre del método para invocar sus diferentes
implementaciones.
Ahora, se va a comenzar la programación en Java escribiendo la aplicación
HolaMundo, que escribe la cadena Hola Mundo en la salida estándar.
Los Ejemplos 1.2 y 1.3 tienen algunos elementos sintácticos, que no se han visto en
detalle hasta ahora. Estos elementos serán cubiertos en las próximas unidades. Estos
ejemplos simplemente ayudarán a exponer al usuario a la sintaxis Java.

9. Ejemplo de una Aplicación Java
Observe el Ejemplo 1.2. La aplicación Java HolaMundo de este ejemplo imprime la
cadena de caracteres Hola Mundo! en la salida estándar.
Ejemplo 1.2
1. /*Definicion de la clase HolaMundo comienza aqui*/
2. public class HolaMundo {
3. /*El metodo main comienza aqui */
4. public static void main(String[] args) {
5. System.out.println("Hola Mundo!");
6. }/* El metodo main termina aqui */
7. }/*Definicion de la clase HolaMundo termina aqui*/
En este programa, HolaMundo es el nombre de la clase, tienen un método (comparable
a una función en C o a una función miembro en C++) con el nombre main. Este método
tiene una instrucción que imprime Hola Mundo! en la salida estándar (el monitor)
cuando se ejecuta. Esta clase define un prototipo, y se puede crear cualquier número de
objetos de este tipo instanciando esta clase.
Ahora que se tiene el código fuente listo, se debe compilar el programa y ejecutarlo. El
programa debe ser almacenado en un archivo bajo el nombre HolaMundo.java.
Usualmente, el nombre del archivo será el mismo que el nombre de la clase que
contiene el método main(), ya que la ejecución del programa usualmente comienza
con el método main(). El archivo tendrá una extensión .java. Todo archivo Java
puede tener solamente una clase, que sea public.
El próximo paso es compilar el programa para obtener los bytecodes (archivo .class).
La compilación se realiza usando el comando javac, como sigue:
javac HolaMundo.java
Esto produce un archivo con el nombre HolaMundo.class, que contiene los
bytecodes. Estos bytecodes son interpretados por el interprete Java, y entonces
ejecutados. El intérprete Java se inicia usando el comando java, como se muestra a
continuación:
java HolaMundo
La salida del programa en el monitor será:
Hola Mundo!

Fin del Ejemplo 1.2
En la próxima sección, se presenta cómo escribir un applet Java que imprime la cadena
de caracteres Hola Mundo!.
10. Ejemplo de Applet Java
El applet Java HolaMundo que se presenta a continuación, imprime la cadena de
caracteres Hola Mundo! en el área del applet.
Ejemplo 1.3
1. import java.applet.Applet;
2. import java.awt.Graphics;
3.
4. /*Definicion de la clase HolaMundo comienza aqui*/
5. public class HolaMundo extends Applet {
6. /*El metodo paint comienza aqui */
7. public void paint(Graphics g) {
8. // Llamar al metodo drawString
9. // del objeto Graphics
10. g.drawString("Hola Mundo!", 25, 25);
11. }/* El metodo paint termina aqui */
12. }/*Definicion de la clase HolaMundo termina aqui*/
En este applet Java, primero se tienen las instrucciones import, que se usan para
importar las clases Applet y Graphics. Estas son esenciales para un programa
applet. Luego, se tiene la definición de la clase, con el nombre de la clase HolaMundo.
Esta definición de la clase usa la palabra reservada extends, seguida del nombre de la
clase Applet. Esto significa que la clase HolaMundo hereda sus características de la
clase Applet. Se aprenderá más acerca de herencia en el Volumen 2, Unidad 3 -
Herencia. Esta clase tiene un método con el nombre de paint, que imprime Hola
Mundo!. La programación de Applets será discutida en el Volumen 6, Unidad 1 -
Applets.
El código de este ejemplo también muestra el uso de los comentarios en Java. Hay
básicamente tres tipos de comentarios que se usan en Java. Son los siguientes:

Comentarios de Documentación: Encerrados dentro de /** … */. Estos comentarios se
usan para generar documentación en las clases en Java.
Bloques de Comentarios: Encerrados dentro de /* */. Estos comentarios se usan
típicamente antes de un método o clase para describir su funcionalidad.
Comentarios de Implementación: Comienzan con //. Estos comentarios se usan
típicamente dentro de la implementación del método para explicar una expresión o una
lógica de implementación compleja.
Se necesita escribir un archivo HTML para visualizar este applet. El código para el
archivo HTML requerido para ejecutar el applet HolaMundo se muestra a continuación:
El código HTML comienza aquí...
<html>
<head>
<title>Hola Mundo</title>
<body>
<applet code="HolaMundo.class" width=200 height=50>
</applet>
</body>
</html>
El código HTML termina aquí
El parámetro incluido en la etiqueta <applet> se usa para invocar el archivo
HolaMundo.class, y ejecutarlo. Este archivo se llamará HolaMundo.html. Se
necesita tener ambos el applet(archivo .class) y el archivo HTML en el mismo
directorio, una vez hecho esto, se puede ejecutar el applet usando el siguiente
comando:
appletviewer HolaMundo.html
La ventana del visualizador de applet se abre, y la salida del applet será la siguiente:
Hola Mundo!
Fin del Ejemplo 1.3

Resumen
Ahora, que ha completado esta unidad, usted debe ser capaz de:
• Discutir la evolución de Java.
• Comparar Java con C++.
• Mencionar las principales características de Java.
• Explicar la plataforma Java.
• Describir el impacto de Java en la WWW.
• Definir clases y objetos.

Unidad 1: Examen de Autoevaluación
1) ¿Cuál de los siguientes lenguajes visualiza los componentes del programa como
objetos?
a) Lenguaje Procedimental
b) Lenguaje Orientado a Objetos
c) Lenguaje de Máquina
d) Ninguno de los anteriores
2) ¿Cuál de las siguientes características describe la arquitectura del lenguaje Java?
a) Orientado a Procedimientos
b) Abstracto
c) Independiente de Plataforma
d) Específico
3) ¿Cuál método deben tener todos los programas de aplicación Java?
a) start()
b) begin()
c) main()
d) main(String args[])
4) ¿Cuál es el comando para ejecutar un programa compilado en Java?
a) javac
b) java
c) run
d) execute
5) En Java, una clase puede tener cualquier número de súper clases.
a) Verdadero
b) Falso
6) ¿Cuáles de los siguientes programas puede acceder a recursos fuera de la JVM?
a) Aplicaciones Java
b) Applets Java
c) Servlets Java
d) Ninguno de los anteriores

7) ¿Cuál es la extensión usada para guardar los archivos fuente Java?
a) .java
b) .javac
c) .javax
d) .src
8) ¿Cuál de los siguientes es usado para referirse a una subclase?
a) Clase Interna
b) Clase Anidada
c) Clase Derivada
d) Clase Oculta
9) ¿Cuál de las siguientes opciones ha hecho popular a Java a través de la Internet?
a) Applets Java
b) Aplicaciones Java
c) Bytecodes Java
d) Ninguna de las anteriores
10) ¿Cuál de las siguientes afirmaciones es cierta acerca de Java?
a) Tiene solo un compilador
b) Tiene solo un interpretador
c) Tiene ambos un compilador y un interpretador
d) Interpreta y luego compila

Respuestas a la Unidad 1: Examen de Autoevaluación
1) b
2) c
3) d
4) b
5) b
6) a y c
7) a
8) c
9) a
10) c

Unidad 2: Operadores, Expresiones y
Control de Flujo
Objetivos del Aprendizaje
Al final de esta unidad, usted será capaz de:
• Mencionar los tipos de datos primitivos usados en Java.
• Describir la declaración e inicialización de variables en Java.
• Discutir los diferentes operadores usados en Java.
• Explicar la precedencia de operadores en Java.
• Definir los tipos de conversiones automáticas y explícitas en Java.
• Explicar las diferentes estructuras de control usadas en Java.

Unidad 2: Operadores, Expresiones y Control de Flujo Libro 1: Core Java 34
1. Introducción
En esta unidad, se discute la sintaxis básica de Java, se encontrarán muchas
similitudes entre la sintaxis de Java y C++.
Antes de aprender acerca de la sintaxis de programación de Java, se discuten los tipos
de datos que provee el lenguaje Java.
2. Tipos de Datos en Java
Los tipos de datos en Java son de dos tipos:
• Tipos Primitivos: Tipos de datos que mantienen valores primitivos como 10, ‘a’,
12.2 etc.
• Tipos Referencias: Tipos de datos que mantienen valores de referencia como
objetos y arreglo de referencias.
Además de los tipos de datos en Java, también existen los genéricos que nos permiten
especificar el tipo de elemento de un Colección en tiempo de compilación. En lugar de
especificar una lista, especificamos su contenido, por ejemplo: Double (doble).
La Figura 2.1 muestra los tipos de datos que Java soporta.
Figura 2.1: Tipos de Datos en Java

En la Figura 2.1, bajo los tipos primitivos, se tienen ocho tipos de datos. Los nombres
mostrados en la figura son las palabras claves usadas en Java para denotar estos tipos
de datos. Los tres tipos referencia, es decir, arreglos, clases e interfaz, se les coloca
identificadores definidos por el usuario al escribir código Java. Por ejemplo,
nombre[20] denota a nombre definido por el usuario como tipo arreglo.
A continuación se verá en detalle los tipos de datos primitivos usados en Java.
2.1 Tipos Primitivos
Los tipos de datos primitivos se usan para definir variables en Java. El tipo de dato
especificado junto con un identificador en el momento de la declaración de la variable
define el rango de valores que puede ser almacenado en esta variable. Java provee
ocho tipos de datos primitivos. La Tabla 2.1 proporciona el nombre del tipo de dato
primitivo y el tamaño ocupado por cada tipo de dato primitivo en memoria.
Tipo de Dato Primitivo Tamaño Ocupado en Memoria
boolean 1 byte
byte 1 byte
char 2 bytes
short 2 bytes
int 4 bytes
Long 8 bytes
Float 4 bytes
Double 8 bytes
Tabla 2.1: Tamaño Ocupado por los Tipos de Datos Primitivos en la Memoria
A continuación se discute cada uno de los ocho tipos de datos en Java, comenzando
con los tipos de datos enteros.
2.1.1 Tipos de Datos Enteros
Los tipos de datos enteros se usan para almacenar valores enteros. La Figura 2.1
muestra cinco tipos diferentes de tipos de datos enteros, estos son: byte, short,
int, long, y char. El rango de valores que estos tipos de datos primitivos pueden
almacenar se muestra a continuación:
• byte -27
hasta 27
– 1
• short -215
hasta 215
– 1

• int -231
hasta 231
– 1
• long -263
hasta 263
– 1
Las diferentes variables de los tipos de datos enteros se declaran como se muestra en
el siguiente código:
byte b = 1;
short s = 1;
int i = 1;
long l = 1;
En las declaraciones anteriores, a todas las variables se les ha asignado el valor del
literal entero 1. Los literales son valores constantes que son asignados a las variables.
El tipo de dato char se usa para almacenar caracteres. Estos caracteres deben ser
caracteres Unicode. Unicode provee números únicos a los caracteres, que permanecen
igual en cualquier plataforma o lenguaje.
Debido a que se usan números para almacenar caracteres en la máquina, el tipo de
datos char esta dentro de la categoría de tipos de datos enteros.
El rango del tipo de datos char se muestra a continuación:
char 0 hasta 215
Java reserva 2 bytes para almacenar el valor de un char. El siguiente código muestra la
declaración de una variable char.
char ch = ‘a’;
Los literales de carácter se definen usando la comilla simple, mientras que las cadenas
de caracteres se definen usando comillas dobles. Java también usa secuencias de
escape, en los caracteres. Una secuencia de escape es un conjunto especial de
caracteres que tienen algún significado especial. Todas las secuencias de escape en
Java comienzan con el caracter ‘’. A continuación se muestran algunas secuencias de
escape en Java:
• r – retorno de carro
• n – nueva línea
• t – tabulador
• b – borrado a la izquierda
• f – comienzo de página
• - caracter
• ’ – comilla simple ’
• " – comilla doble ”

Un programa Java puede interactuar con caracteres internacionales, lo cual no es
posible en C o C++, a menos que se programen cada conjunto de caracteres
separadamente.
2.1.2 Tipos de Datos de Punto Flotante
Los tipos de datos de punto flotante se usan para almacenar valores de punto flotante.
Los dos tipos de tipos de datos para punto flotante son float y double.
El rango de estos tipos de datos primitivos es el siguiente:
float -3.4 * 1038
hasta 3.4 * 1038
double -1.8 * 10308
hasta 1.8 * 10308
El siguiente código muestra la declaración de dos variables pertenecientes al tipo de
datos de punto flotante.
float a = 1.1f;
double d = 1.1;
Las variables literales float deben terminar con f o F.
La Figura 2.2 muestra literales que se pueden asignar a float y double.
Figura 2.2: Literales Asignados a float y double
2.1.3 Tipo de Datos boolean
El tipo de datos boolean se usa para almacenar valores booleanos, es decir, true o
false. La palabra clave boolean se usa para denotar el tipo de datos booleano. El
siguiente código muestra la declaración de una variable boolean.
boolean bool = true;

2.1.4 Valores Aceptables Para Diferentes Tipos de Datos Primitivos en Java
La Tabla 2.2 muestra algunos ejemplos de valores aceptables para los diferentes tipos
de datos primitivos en Java.
Tipo de Datos Valor Aceptable
Entero
2 (se asume int)
2L
0777 (octal)
0xa5fd (hexadecimal)
‘a’, ‘n’, ‘udddd’
Punto Flotante
3.14 (se asume double)
3.12E4
2e12
2.0d
2.0F
Boolean true, false
Tabla 2.2: Algunos Ejemplos de Valores para los Tipos de Datos en Java
2.1.5 Tamaños de los Tipos de Datos en C, C++, y Java
En lenguajes como C y C++, el tamaño del tipo de datos puede variar entre plataformas
y es dependiente de la máquina. Por ejemplo, el tipo de datos entero ocupa 2 bytes en
ciertos compiladores de C, en cambio ocupa 4 bytes en otros.
En Java, sin embargo, el tamaño del tipo de datos es independiente de la plataforma en
la cual la aplicación se ejecuta. El tamaño de cada tipo de datos primitivo es el mismo
sin importar la plataforma. Por ejemplo, el tipo de datos entero siempre ocupa 4 bytes
en cualquier implementación válida de la JVM. Un valor por defecto está siempre
asociado con los tipos de datos primitivos. Para los tipos de datos enteros, el valor por
defecto es 0. Para los tipos de datos de punto flotante, el valor por defecto es siempre
0.0. Para los tipos de datos caracteres, el valor por defecto es u0000. El valor por
defecto para los boolean es false.
2.2 Tipos de Referencia
Los tres tipos de referencia provistos por Java son los arreglos, clases e interfaz. No se
entrará en una discusión detallada de estos tres tipos de datos ahora, solo se
mencionará que una referencia es un elemento de datos que mantiene la dirección de
una posición de memoria. Los arreglos en Java no son referidos como tipos de datos
estructurados como en C o C++. Los arreglos son tipos referencia, donde el
identificador que se usa para identificar al arreglo contiene la dirección del arreglo.
Estos serán tratados en detalle en una sección posterior en esta unidad.
Java es un lenguaje de programación orientado a objetos, y por esto todo el esfuerzo en
la programación esta alrededor de la creación de clases. Java también permite la
creación de interfaces, que son similares a las clases. Los identificadores usados para

identificar a las clases e interfaces mantienen la dirección de la posición de la memoria.
Las clases son analizadas en detalle en el Volumen 2, Unidad 1 – Clases, Objetos y
Referencias y las interfaces en el Volumen 2, Unidad 5 – Clases Abstractas e
Interfaces. A continuación se muestra una breve descripción sobre los genéricos.
2.3 Genéricos
Java 5.0 introduce nuevas funcionalidades al lenguaje de programación Java. Una de
esas funcionalidades son los genéricos. Puede que usted encuentre construcciones
similares en otros lenguajes pero verá que hay diferencias importantes entre ellas. Los
genéricos le permiten hacer abstracciones de tipos de datos. Estos serán tratados en
detalle en el Volumen 8 - Conceptos Avanzados, Unidad 1 – API de Colecciones.
Seguidamente, se va a aprender acerca de clases envolventes (wrapper classes), que
esencialmente envuelven los tipos de datos primitivos en clases.
3. Clases Envolventes
Se han discutido varios tipos de datos primitivos de Java. Java también provee clases
envolventes para cada uno de estos tipos de datos primitivos. Una clase envolvente da
la funcionalidad de una clase para un tipo de datos primitivo. Estas clases envolventes
tienen métodos que permiten manipular el tipo de dato primitivo correspondiente que
ellos envuelven.
Los tipos de datos primitivos tienen conjuntos de operaciones que se pueden usar con
ellos. Sin embargo, cuando se quiere proveer algunas funciones utilitarias para un tipo
de dato en particular, se usan las clases envolventes y se proveen funciones primitivas
dentro de las clases envolventes.
Hay ciertas clases, que vienen como parte de la librería de Java, que requieren de un
objeto en vez de una variable de tipo de dato primitivo. Los objetos de las clases
envolventes se pueden usar también para este propósito.
Java provee clases envolventes para los ocho tipos de datos primitivos. Se discute a
continuación las ocho clases envolventes en Java, comenzando por la clase envolvente
Boolean.
3.1 La Clase java.lang.Boolean
La clase Boolean es la representación en objeto del tipo de dato primitivo boolean.
Esta clase, es una clase envolvente para el tipo primitivo boolean, por lo tanto, tiene
un miembro del tipo boolean. También tiene ciertos métodos que se pueden usar para
manipular el valor del boolean almacenado internamente.
La clase Boolean tiene el método booleanValue(), que retorna el valor del boolean
que está envuelto en este objeto. También tiene los métodos equals(), toString()
y hashCode() que son sobrescritos de la clase java.lang.Object.

La clase Boolean tiene el método static valueOf() para convertir una
representación de objeto String en un valor Boolean.
3.2 La Clase java.lang.Byte
La clase Byte es la representación en objeto del tipo de dato primitivo byte. Esta
clase, por ser una clase envolvente para el tipo de dato primitivo byte, tiene un
miembro del tipo byte. Esta clase tiene métodos que permiten obtener el valor del
byte almacenado en el objeto Byte en la forma de byte, short, int, float o
double. Esto se hace usando los siguientes métodos:
• byteValue()
• shortValue()
• intValue()
• floatValue()
• doubleValue()
La clase Byte también tiene métodos que son sobrescritos de la clase
java.lang.Object. Estos métodos son los siguientes:
• equals()
• toString()
• hashCode()
Además de estos métodos, la clase Byte tiene el método static valueOf() para
convertir una representación de objeto String en un valor byte.
3.3 La Clase java.lang.Short
La clase Short es la representación en objeto del tipo de dato primitivo short. Esta
clase, por ser una clase envolvente para el tipo primitivo short, tiene un miembro del
tipo short. Esta clase tiene métodos que permiten obtener el valor del short
almacenado en el objeto Short en la forma de byte, short, int, float o double.
Esto se hace usando los métodos:
• byteValue()
• shortValue()
• intValue()
• floatValue()
• doubleValue()
La clase Short también tiene los métodos equals(), toString() y hashCode()
que son sobrescritos de la clase java.lang.Object.

La clase Short tiene el método static valueOf() para convertir una representación
del objeto String en un valor Short.
3.4 La Clase java.lang.Character
La clase Character es la representación en objeto del tipo de dato primitivo char. La
clase Character, al ser una clase envolvente, tiene un campo del tipo primitivo char.
Se pueden usar los métodos provistos por esta clase para manipular variables que
mantienen valores del tipo primitivo char. Algunas de las funciones importantes
provistas por esta clase dan la posibilidad de determinar el tipo de carácter y convertir
un carácter en minúscula a mayúscula y viceversa. Los métodos definidos en la clase
Character están basados en la tabla de atributos Unicode. Esta tabla asocia a cada
código Unicode definido con un nombre. Los caracteres están encerrados dentro de
comillas simples. Así, ‘a’ es el carácter a. Se pueden obtener caracteres especiales
usando secuencias de escape. ‘n’ es la secuencia de escape para el carácter de
nueva línea.
Se puede usar el método charValue() de esta clase para obtener el valor char
almacenado por el objeto en la forma del tipo de dato primitivo char.
3.5 La Clase java.lang.Integer
La clase Integer es la representación en objeto del tipo de dato primitivo int. Un
objeto Integer tiene un campo, que es del tipo primitivo int. Es posible usar los
métodos provistos por esta clase para manipular variables que mantienen valores del
tipo primitivo int.
Algunas de las funciones más importantes provistas por esta clase son la posibilidad de
convertir un int a un String con el método toString(), y de un String a un int
usando el método parseInt(String s). Cuando la JVM encuentra valores int en
el código, los interpretará como enteros. Cuando se usa un número como 2, la JVM
asume que es del tipo int. Si se quiere que la JVM lo interprete como algo diferente a
un int, se debe proveer información más específica. Si se quiere que la JVM “piense”
que es del tipo long, se debe usar una "L" después del entero. Los otros tipos de datos
enteros byte y short no pueden ser especificados. Estos serán convertidos al
momento de la asignación de valores. Así, la sentencia byte b = 120; convertirá
120 de int a byte, siempre y cuando el valor pertenezca al rango válido para un byte.
Esta clase tiene métodos que permiten obtener el valor del int almacenado en el
objeto Integer en la forma de byte, short, int, float o double usando los
métodos byteValue(), shortValue(), intValue(), floatValue() y
doubleValue() respectivamente.

Libro i. ibm.

Recomendados

Recomendados

Más contenido relacionado

Similar a Libro i. ibm.

Similar a Libro i. ibm. (20)

Más de Genesis Mendez

Más de Genesis Mendez (6)

Último

Último (15)

Libro i. ibm.